commit caad8cde58410f8cfbc039522829ad053f943703 Author: Alexey Prokhin Date: Thu Apr 5 11:10:48 2012 +0400 Squashed 'dmd2/' content from commit 10017d5 git-subtree-dir: dmd2 git-subtree-split: 10017d50eaaff4ecdc37a0153b6c37ea0b004c81 diff --git a/access.c b/access.c new file mode 100644 index 00000000..b8b677c6 --- /dev/null +++ b/access.c @@ -0,0 +1,412 @@ + +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include + +#include "root.h" +#include "rmem.h" + +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "scope.h" +#include "id.h" +#include "mtype.h" +#include "declaration.h" +#include "aggregate.h" +#include "expression.h" +#include "module.h" + +#define LOG 0 + +/* Code to do access checks + */ + +int hasPackageAccess(Scope *sc, Dsymbol *s); + +/**************************************** + * Return PROT access for Dsymbol smember in this declaration. + */ + +enum PROT AggregateDeclaration::getAccess(Dsymbol *smember) +{ + return PROTpublic; +} + +enum PROT StructDeclaration::getAccess(Dsymbol *smember) +{ + enum PROT access_ret = PROTnone; + +#if LOG + printf("+StructDeclaration::getAccess(this = '%s', smember = '%s')\n", + toChars(), smember->toChars()); +#endif + if (smember->toParent() == this) + { + access_ret = smember->prot(); + } + else if (smember->isDeclaration()->isStatic()) + { + access_ret = smember->prot(); + } + return access_ret; +} + +enum PROT ClassDeclaration::getAccess(Dsymbol *smember) +{ + enum PROT access_ret = PROTnone; + +#if LOG + printf("+ClassDeclaration::getAccess(this = '%s', smember = '%s')\n", + toChars(), smember->toChars()); +#endif + if (smember->toParent() == this) + { + access_ret = smember->prot(); + } + else + { + if (smember->isDeclaration()->isStatic()) + { + access_ret = smember->prot(); + } + + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *b = (*baseclasses)[i]; + + enum PROT access = b->base->getAccess(smember); + switch (access) + { + case PROTnone: + break; + + case PROTprivate: + access_ret = PROTnone; // private members of base class not accessible + break; + + case PROTpackage: + case PROTprotected: + case PROTpublic: + case PROTexport: + // If access is to be tightened + if (b->protection < access) + access = b->protection; + + // Pick path with loosest access + if (access > access_ret) + access_ret = access; + break; + + default: + assert(0); + } + } + } +#if LOG + printf("-ClassDeclaration::getAccess(this = '%s', smember = '%s') = %d\n", + toChars(), smember->toChars(), access_ret); +#endif + return access_ret; +} + +/******************************************************** + * Helper function for ClassDeclaration::accessCheck() + * Returns: + * 0 no access + * 1 access + */ + +static int accessCheckX( + Dsymbol *smember, + Dsymbol *sfunc, + AggregateDeclaration *dthis, + AggregateDeclaration *cdscope) +{ + assert(dthis); + +#if 0 + printf("accessCheckX for %s.%s in function %s() in scope %s\n", + dthis->toChars(), smember->toChars(), + sfunc ? sfunc->toChars() : "NULL", + cdscope ? cdscope->toChars() : "NULL"); +#endif + if (dthis->hasPrivateAccess(sfunc) || + dthis->isFriendOf(cdscope)) + { + if (smember->toParent() == dthis) + return 1; + else + { + ClassDeclaration *cdthis = dthis->isClassDeclaration(); + if (cdthis) + { + for (size_t i = 0; i < cdthis->baseclasses->dim; i++) + { BaseClass *b = (*cdthis->baseclasses)[i]; + enum PROT access = b->base->getAccess(smember); + if (access >= PROTprotected || + accessCheckX(smember, sfunc, b->base, cdscope) + ) + return 1; + + } + } + } + } + else + { + if (smember->toParent() != dthis) + { + ClassDeclaration *cdthis = dthis->isClassDeclaration(); + if (cdthis) + { + for (size_t i = 0; i < cdthis->baseclasses->dim; i++) + { BaseClass *b = (*cdthis->baseclasses)[i]; + + if (accessCheckX(smember, sfunc, b->base, cdscope)) + return 1; + } + } + } + } + return 0; +} + +/******************************* + * Do access check for member of this class, this class being the + * type of the 'this' pointer used to access smember. + */ + +void AggregateDeclaration::accessCheck(Loc loc, Scope *sc, Dsymbol *smember) +{ + int result; + + FuncDeclaration *f = sc->func; + AggregateDeclaration *cdscope = sc->getStructClassScope(); + enum PROT access; + +#if LOG + printf("AggregateDeclaration::accessCheck() for %s.%s in function %s() in scope %s\n", + toChars(), smember->toChars(), + f ? f->toChars() : NULL, + cdscope ? cdscope->toChars() : NULL); +#endif + + Dsymbol *smemberparent = smember->toParent(); + if (!smemberparent || !smemberparent->isAggregateDeclaration()) + { +#if LOG + printf("not an aggregate member\n"); +#endif + return; // then it is accessible + } + + // BUG: should enable this check + //assert(smember->parent->isBaseOf(this, NULL)); + + if (smemberparent == this) + { enum PROT access2 = smember->prot(); + + result = access2 >= PROTpublic || + hasPrivateAccess(f) || + isFriendOf(cdscope) || + (access2 == PROTpackage && hasPackageAccess(sc, this)); +#if LOG + printf("result1 = %d\n", result); +#endif + } + else if ((access = this->getAccess(smember)) >= PROTpublic) + { + result = 1; +#if LOG + printf("result2 = %d\n", result); +#endif + } + else if (access == PROTpackage && hasPackageAccess(sc, this)) + { + result = 1; +#if LOG + printf("result3 = %d\n", result); +#endif + } + else + { + result = accessCheckX(smember, f, this, cdscope); +#if LOG + printf("result4 = %d\n", result); +#endif + } + if (!result) + { + error(loc, "member %s is not accessible", smember->toChars()); + } +} + +/**************************************** + * Determine if this is the same or friend of cd. + */ + +int AggregateDeclaration::isFriendOf(AggregateDeclaration *cd) +{ +#if LOG + printf("AggregateDeclaration::isFriendOf(this = '%s', cd = '%s')\n", toChars(), cd ? cd->toChars() : "null"); +#endif + if (this == cd) + return 1; + + // Friends if both are in the same module + //if (toParent() == cd->toParent()) + if (cd && getAccessModule() == cd->getAccessModule()) + { +#if LOG + printf("\tin same module\n"); +#endif + return 1; + } + +#if LOG + printf("\tnot friend\n"); +#endif + return 0; +} + +/**************************************** + * Determine if scope sc has package level access to s. + */ + +int hasPackageAccess(Scope *sc, Dsymbol *s) +{ +#if LOG + printf("hasPackageAccess(s = '%s', sc = '%p')\n", s->toChars(), sc); +#endif + + for (; s; s = s->parent) + { + if (s->isPackage() && !s->isModule()) + break; + } +#if LOG + if (s) + printf("\tthis is in package '%s'\n", s->toChars()); +#endif + + if (s && s == sc->module->parent) + { +#if LOG + printf("\ts is in same package as sc\n"); +#endif + return 1; + } + + +#if LOG + printf("\tno package access\n"); +#endif + return 0; +} + +/********************************** + * Determine if smember has access to private members of this declaration. + */ + +int AggregateDeclaration::hasPrivateAccess(Dsymbol *smember) +{ + if (smember) + { AggregateDeclaration *cd = NULL; + Dsymbol *smemberparent = smember->toParent(); + if (smemberparent) + cd = smemberparent->isAggregateDeclaration(); + +#if LOG + printf("AggregateDeclaration::hasPrivateAccess(class %s, member %s)\n", + toChars(), smember->toChars()); +#endif + + if (this == cd) // smember is a member of this class + { +#if LOG + printf("\tyes 1\n"); +#endif + return 1; // so we get private access + } + + // If both are members of the same module, grant access + while (1) + { Dsymbol *sp = smember->toParent(); + if (sp->isFuncDeclaration() && smember->isFuncDeclaration()) + smember = sp; + else + break; + } + if (!cd && toParent() == smember->toParent()) + { +#if LOG + printf("\tyes 2\n"); +#endif + return 1; + } + if (!cd && getAccessModule() == smember->getAccessModule()) + { +#if LOG + printf("\tyes 3\n"); +#endif + return 1; + } + } +#if LOG + printf("\tno\n"); +#endif + return 0; +} + +/**************************************** + * Check access to d for expression e.d + */ + +void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d) +{ +#if LOG + if (e) + { printf("accessCheck(%s . %s)\n", e->toChars(), d->toChars()); + printf("\te->type = %s\n", e->type->toChars()); + } + else + { + printf("accessCheck(%s)\n", d->toPrettyChars()); + } +#endif + if (!e) + { + if (d->prot() == PROTprivate && d->getAccessModule() != sc->module || + d->prot() == PROTpackage && !hasPackageAccess(sc, d)) + { + error(loc, "%s %s is not accessible from module %s", + d->kind(), d->toPrettyChars(), sc->module->toChars()); + } + } + else if (e->type->ty == Tclass) + { // Do access check + ClassDeclaration *cd = (ClassDeclaration *)(((TypeClass *)e->type)->sym); + if (e->op == TOKsuper) + { + ClassDeclaration *cd2 = sc->func->toParent()->isClassDeclaration(); + if (cd2) + cd = cd2; + } + cd->accessCheck(loc, sc, d); + } + else if (e->type->ty == Tstruct) + { // Do access check + StructDeclaration *cd = (StructDeclaration *)(((TypeStruct *)e->type)->sym); + cd->accessCheck(loc, sc, d); + } +} diff --git a/aggregate.h b/aggregate.h new file mode 100644 index 00000000..e11a8061 --- /dev/null +++ b/aggregate.h @@ -0,0 +1,320 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_AGGREGATE_H +#define DMD_AGGREGATE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" + +#include "dsymbol.h" + +struct Identifier; +struct Type; +struct TypeFunction; +struct Expression; +struct FuncDeclaration; +struct CtorDeclaration; +struct DtorDeclaration; +struct InvariantDeclaration; +struct NewDeclaration; +struct DeleteDeclaration; +struct InterfaceDeclaration; +struct TypeInfoClassDeclaration; +struct VarDeclaration; +struct dt_t; + + +struct AggregateDeclaration : ScopeDsymbol +{ + Type *type; + StorageClass storage_class; + enum PROT protection; + Type *handle; // 'this' type + unsigned structsize; // size of struct + unsigned alignsize; // size of struct for alignment purposes + unsigned structalign; // struct member alignment in effect + int hasUnions; // set if aggregate has overlapping fields + VarDeclarations fields; // VarDeclaration fields + unsigned sizeok; // set when structsize contains valid data + // 0: no size + // 1: size is correct + // 2: cannot determine size; fwd referenced + Dsymbol *deferred; // any deferred semantic2() or semantic3() symbol + bool isdeprecated; // !=0 if deprecated + +#if DMDV2 + int isnested; // !=0 if is nested + VarDeclaration *vthis; // 'this' parameter if this aggregate is nested +#endif + // Special member functions + InvariantDeclaration *inv; // invariant + NewDeclaration *aggNew; // allocator + DeleteDeclaration *aggDelete; // deallocator + +#if DMDV2 + //CtorDeclaration *ctor; + Dsymbol *ctor; // CtorDeclaration or TemplateDeclaration + CtorDeclaration *defaultCtor; // default constructor + Dsymbol *aliasthis; // forward unresolved lookups to aliasthis + bool noDefaultCtor; // no default construction +#endif + + FuncDeclarations dtors; // Array of destructors + FuncDeclaration *dtor; // aggregate destructor + +#ifdef IN_GCC + Array methods; // flat list of all methods for debug information +#endif + + AggregateDeclaration(Loc loc, Identifier *id); + void semantic2(Scope *sc); + void semantic3(Scope *sc); + void inlineScan(); + unsigned size(Loc loc); + static void alignmember(unsigned salign, unsigned size, unsigned *poffset); + Type *getType(); + void addField(Scope *sc, VarDeclaration *v); + int firstFieldInUnion(int indx); // first field in union that includes indx + int numFieldsInUnion(int firstIndex); // #fields in union starting at index + int isDeprecated(); // is aggregate deprecated? + FuncDeclaration *buildDtor(Scope *sc); + int isNested(); + int isExport(); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toDocBuffer(OutBuffer *buf); + + // For access checking + virtual PROT getAccess(Dsymbol *smember); // determine access to smember + int isFriendOf(AggregateDeclaration *cd); + int hasPrivateAccess(Dsymbol *smember); // does smember have private access to members of this class? + void accessCheck(Loc loc, Scope *sc, Dsymbol *smember); + + enum PROT prot(); + + // Back end + Symbol *stag; // tag symbol for debug data + Symbol *sinit; + Symbol *toInitializer(); + + AggregateDeclaration *isAggregateDeclaration() { return this; } +}; + +struct AnonymousAggregateDeclaration : AggregateDeclaration +{ + AnonymousAggregateDeclaration() + : AggregateDeclaration(0, NULL) + { + } + + AnonymousAggregateDeclaration *isAnonymousAggregateDeclaration() { return this; } +}; + +struct StructDeclaration : AggregateDeclaration +{ + int zeroInit; // !=0 if initialize with 0 fill +#if DMDV2 + int hasIdentityAssign; // !=0 if has identity opAssign + int hasIdentityEquals; // !=0 if has identity opEquals + FuncDeclaration *cpctor; // generated copy-constructor, if any + FuncDeclarations postblits; // Array of postblit functions + FuncDeclaration *postblit; // aggregate postblit + + FuncDeclaration *xeq; // TypeInfo_Struct.xopEquals + static FuncDeclaration *xerreq; // object.xopEquals +#endif + + StructDeclaration(Loc loc, Identifier *id); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + Dsymbol *search(Loc, Identifier *ident, int flags); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + char *mangle(); + const char *kind(); + void finalizeSize(); +#if DMDV1 + Expression *cloneMembers(); +#endif +#if DMDV2 + int needOpAssign(); + int needOpEquals(); + FuncDeclaration *buildOpAssign(Scope *sc); + FuncDeclaration *buildOpEquals(Scope *sc); + FuncDeclaration *buildPostBlit(Scope *sc); + FuncDeclaration *buildCpCtor(Scope *sc); + + FuncDeclaration *buildXopEquals(Scope *sc); +#endif + void toDocBuffer(OutBuffer *buf); + + PROT getAccess(Dsymbol *smember); // determine access to smember + + void toObjFile(int multiobj); // compile to .obj file + void toDt(dt_t **pdt); + void toDebug(); // to symbolic debug info + + StructDeclaration *isStructDeclaration() { return this; } +}; + +struct UnionDeclaration : StructDeclaration +{ + UnionDeclaration(Loc loc, Identifier *id); + Dsymbol *syntaxCopy(Dsymbol *s); + const char *kind(); + + UnionDeclaration *isUnionDeclaration() { return this; } +}; + +struct BaseClass +{ + Type *type; // (before semantic processing) + enum PROT protection; // protection for the base interface + + ClassDeclaration *base; + int offset; // 'this' pointer offset + FuncDeclarations vtbl; // for interfaces: Array of FuncDeclaration's + // making up the vtbl[] + + size_t baseInterfaces_dim; + BaseClass *baseInterfaces; // if BaseClass is an interface, these + // are a copy of the InterfaceDeclaration::interfaces + + BaseClass(); + BaseClass(Type *type, enum PROT protection); + + int fillVtbl(ClassDeclaration *cd, FuncDeclarations *vtbl, int newinstance); + void copyBaseInterfaces(BaseClasses *); +}; + +#if DMDV2 +#define CLASSINFO_SIZE_64 0x98 // value of ClassInfo.size +#define CLASSINFO_SIZE (0x3C+12+4) // value of ClassInfo.size +#else +#define CLASSINFO_SIZE (0x3C+12+4) // value of ClassInfo.size +#endif + +struct ClassDeclaration : AggregateDeclaration +{ + static ClassDeclaration *object; + static ClassDeclaration *classinfo; + static ClassDeclaration *throwable; + static ClassDeclaration *exception; + static ClassDeclaration *errorException; + + ClassDeclaration *baseClass; // NULL only if this is Object +#if DMDV1 + CtorDeclaration *ctor; + CtorDeclaration *defaultCtor; // default constructor +#endif + FuncDeclaration *staticCtor; + FuncDeclaration *staticDtor; + Dsymbols vtbl; // Array of FuncDeclaration's making up the vtbl[] + Dsymbols vtblFinal; // More FuncDeclaration's that aren't in vtbl[] + + BaseClasses *baseclasses; // Array of BaseClass's; first is super, + // rest are Interface's + + size_t interfaces_dim; + BaseClass **interfaces; // interfaces[interfaces_dim] for this class + // (does not include baseClass) + + BaseClasses *vtblInterfaces; // array of base interfaces that have + // their own vtbl[] + + TypeInfoClassDeclaration *vclassinfo; // the ClassInfo object for this ClassDeclaration + int com; // !=0 if this is a COM class (meaning + // it derives from IUnknown) + int isscope; // !=0 if this is an auto class + int isabstract; // !=0 if abstract class +#if DMDV1 + int isnested; // !=0 if is nested + VarDeclaration *vthis; // 'this' parameter if this class is nested +#endif + int inuse; // to prevent recursive attempts + + ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isBaseOf2(ClassDeclaration *cd); + + #define OFFSET_RUNTIME 0x76543210 + virtual int isBaseOf(ClassDeclaration *cd, int *poffset); + + virtual int isBaseInfoComplete(); + Dsymbol *search(Loc, Identifier *ident, int flags); + Dsymbol *searchBase(Loc, Identifier *ident); +#if DMDV2 + int isFuncHidden(FuncDeclaration *fd); +#endif + FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf); + void interfaceSemantic(Scope *sc); +#if DMDV1 + int isNested(); +#endif + int isCOMclass(); + virtual int isCOMinterface(); +#if DMDV2 + virtual int isCPPinterface(); +#endif + int isAbstract(); + virtual int vtblOffset(); + const char *kind(); + char *mangle(); + void toDocBuffer(OutBuffer *buf); + + PROT getAccess(Dsymbol *smember); // determine access to smember + + void addLocalClass(ClassDeclarations *); + + // Back end + void toObjFile(int multiobj); // compile to .obj file + void toDebug(); + unsigned baseVtblOffset(BaseClass *bc); + Symbol *toSymbol(); + Symbol *toVtblSymbol(); + void toDt(dt_t **pdt); + void toDt2(dt_t **pdt, ClassDeclaration *cd); + + Symbol *vtblsym; + + ClassDeclaration *isClassDeclaration() { return (ClassDeclaration *)this; } +}; + +struct InterfaceDeclaration : ClassDeclaration +{ +#if DMDV2 + int cpp; // !=0 if this is a C++ interface +#endif + InterfaceDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + int isBaseOf(ClassDeclaration *cd, int *poffset); + int isBaseOf(BaseClass *bc, int *poffset); + const char *kind(); + int isBaseInfoComplete(); + int vtblOffset(); +#if DMDV2 + int isCPPinterface(); +#endif + virtual int isCOMinterface(); + + void toObjFile(int multiobj); // compile to .obj file + Symbol *toSymbol(); + + InterfaceDeclaration *isInterfaceDeclaration() { return this; } +}; + +#endif /* DMD_AGGREGATE_H */ diff --git a/aliasthis.c b/aliasthis.c new file mode 100644 index 00000000..f8a74b48 --- /dev/null +++ b/aliasthis.c @@ -0,0 +1,79 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2009-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "identifier.h" +#include "aliasthis.h" +#include "scope.h" +#include "aggregate.h" +#include "dsymbol.h" + +#if DMDV2 + + +AliasThis::AliasThis(Loc loc, Identifier *ident) + : Dsymbol(NULL) // it's anonymous (no identifier) +{ + this->loc = loc; + this->ident = ident; +} + +Dsymbol *AliasThis::syntaxCopy(Dsymbol *s) +{ + assert(!s); + /* Since there is no semantic information stored here, + * we don't need to copy it. + */ + return this; +} + +void AliasThis::semantic(Scope *sc) +{ + Dsymbol *parent = sc->parent; + if (parent) + parent = parent->pastMixin(); + AggregateDeclaration *ad = NULL; + if (parent) + ad = parent->isAggregateDeclaration(); + if (ad) + { + assert(ad->members); + Dsymbol *s = ad->search(loc, ident, 0); + if (!s) + { s = sc->search(loc, ident, 0); + if (s) + ::error(loc, "%s is not a member of %s", s->toChars(), ad->toChars()); + else + ::error(loc, "undefined identifier %s", ident->toChars()); + } + else if (ad->aliasthis && s != ad->aliasthis) + error("there can be only one alias this"); + ad->aliasthis = s; + } + else + error("alias this can only appear in struct or class declaration, not %s", parent ? parent->toChars() : "nowhere"); +} + +const char *AliasThis::kind() +{ + return "alias this"; +} + +void AliasThis::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("alias "); + buf->writestring(ident->toChars()); + buf->writestring(" this;\n"); +} + +#endif diff --git a/aliasthis.h b/aliasthis.h new file mode 100644 index 00000000..c804cdb5 --- /dev/null +++ b/aliasthis.h @@ -0,0 +1,41 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2009-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_ALIASTHIS_H +#define DMD_ALIASTHIS_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "mars.h" +#include "dsymbol.h" + +/**************************************************************/ + +#if DMDV2 + +struct AliasThis : Dsymbol +{ + // alias Identifier this; + Identifier *ident; + + AliasThis(Loc loc, Identifier *ident); + + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + const char *kind(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + AliasThis *isAliasThis() { return this; } +}; + +#endif + +#endif diff --git a/apply.c b/apply.c new file mode 100644 index 00000000..f5a5ede8 --- /dev/null +++ b/apply.c @@ -0,0 +1,165 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "expression.h" + + +/************************************** + * An Expression tree walker that will visit each Expression e in the tree, + * in depth-first evaluation order, and call fp(e,param) on it. + * fp() signals whether the walking continues with its return value: + * Returns: + * 0 continue + * 1 done + * It's a bit slower than using virtual functions, but more encapsulated and less brittle. + * Creating an iterator for this would be much more complex. + */ + +typedef int (*fp_t)(Expression *, void *); + +int Expression::apply(fp_t fp, void *param) +{ + return (*fp)(this, param); +} + +/****************************** + * Perform apply() on an array of Expressions. + */ + +int arrayExpressionApply(Expressions *a, fp_t fp, void *param) +{ + //printf("arrayExpressionApply(%p)\n", a); + if (a) + { + for (size_t i = 0; i < a->dim; i++) + { Expression *e = (*a)[i]; + + if (e) + { + if (e->apply(fp, param)) + return 1; + } + } + } + return 0; +} + +int NewExp::apply(int (*fp)(Expression *, void *), void *param) +{ + //printf("NewExp::apply(): %s\n", toChars()); + + return ((thisexp ? thisexp->apply(fp, param) : 0) || + arrayExpressionApply(newargs, fp, param) || + arrayExpressionApply(arguments, fp, param) || + (*fp)(this, param)); +} + +int NewAnonClassExp::apply(int (*fp)(Expression *, void *), void *param) +{ + //printf("NewAnonClassExp::apply(): %s\n", toChars()); + + return ((thisexp ? thisexp->apply(fp, param) : 0) || + arrayExpressionApply(newargs, fp, param) || + arrayExpressionApply(arguments, fp, param) || + (*fp)(this, param)); +} + +int UnaExp::apply(fp_t fp, void *param) +{ + return e1->apply(fp, param) || + (*fp)(this, param); +} + +int BinExp::apply(fp_t fp, void *param) +{ + return e1->apply(fp, param) || + e2->apply(fp, param) || + (*fp)(this, param); +} + +int AssertExp::apply(fp_t fp, void *param) +{ + //printf("CallExp::apply(fp_t fp, void *param): %s\n", toChars()); + return e1->apply(fp, param) || + (msg ? msg->apply(fp, param) : 0) || + (*fp)(this, param); +} + + +int CallExp::apply(fp_t fp, void *param) +{ + //printf("CallExp::apply(fp_t fp, void *param): %s\n", toChars()); + return e1->apply(fp, param) || + arrayExpressionApply(arguments, fp, param) || + (*fp)(this, param); +} + + +int ArrayExp::apply(fp_t fp, void *param) +{ + //printf("ArrayExp::apply(fp_t fp, void *param): %s\n", toChars()); + return e1->apply(fp, param) || + arrayExpressionApply(arguments, fp, param) || + (*fp)(this, param); +} + + +int SliceExp::apply(fp_t fp, void *param) +{ + return e1->apply(fp, param) || + (lwr ? lwr->apply(fp, param) : 0) || + (upr ? upr->apply(fp, param) : 0) || + (*fp)(this, param); +} + + +int ArrayLiteralExp::apply(fp_t fp, void *param) +{ + return arrayExpressionApply(elements, fp, param) || + (*fp)(this, param); +} + + +int AssocArrayLiteralExp::apply(fp_t fp, void *param) +{ + return arrayExpressionApply(keys, fp, param) || + arrayExpressionApply(values, fp, param) || + (*fp)(this, param); +} + + +int StructLiteralExp::apply(fp_t fp, void *param) +{ + return arrayExpressionApply(elements, fp, param) || + (*fp)(this, param); +} + + +int TupleExp::apply(fp_t fp, void *param) +{ + return arrayExpressionApply(exps, fp, param) || + (*fp)(this, param); +} + + +int CondExp::apply(fp_t fp, void *param) +{ + return econd->apply(fp, param) || + e1->apply(fp, param) || + e2->apply(fp, param) || + (*fp)(this, param); +} + + + diff --git a/argtypes.c b/argtypes.c new file mode 100644 index 00000000..3f1d3620 --- /dev/null +++ b/argtypes.c @@ -0,0 +1,193 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2010-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// http://www.dsource.org/projects/dmd/browser/branches/dmd-1.x/src/argtypes.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "dsymbol.h" +#include "mtype.h" +#include "scope.h" +#include "init.h" +#include "expression.h" +#include "attrib.h" +#include "declaration.h" +#include "template.h" +#include "id.h" +#include "enum.h" +#include "import.h" +#include "aggregate.h" +#include "hdrgen.h" + +/**************************************************** + * This breaks a type down into 'simpler' types that can be passed to a function + * in registers, and returned in registers. + * It's highly platform dependent. + * Returning a tuple of zero length means the type cannot be passed/returned in registers. + */ + + +TypeTuple *Type::toArgTypes() +{ + return NULL; // not valid for a parameter +} + + +TypeTuple *TypeBasic::toArgTypes() +{ Type *t1 = NULL; + Type *t2 = NULL; + switch (ty) + { + case Tvoid: + return NULL; + + case Tbool: + case Tint8: + case Tuns8: + case Tint16: + case Tuns16: + case Tint32: + case Tuns32: + case Tfloat32: + case Tint64: + case Tuns64: + case Tfloat64: + case Tfloat80: + t1 = this; + break; + + case Timaginary32: + t1 = Type::tfloat32; + break; + + case Timaginary64: + t1 = Type::tfloat64; + break; + + case Timaginary80: + t1 = Type::tfloat80; + break; + + case Tcomplex32: + if (global.params.is64bit) + t1 = Type::tfloat64; // weird, eh? + else + { + t1 = Type::tfloat64; + t2 = Type::tfloat64; + } + break; + + case Tcomplex64: + t1 = Type::tfloat64; + t2 = Type::tfloat64; + break; + + case Tcomplex80: + t1 = Type::tfloat80; + t2 = Type::tfloat80; + break; + + case Tascii: + t1 = Type::tuns8; + break; + + case Twchar: + t1 = Type::tuns16; + break; + + case Tdchar: + t1 = Type::tuns32; + break; + + default: assert(0); + } + + TypeTuple *t; + if (t1) + { + if (t2) + t = new TypeTuple(t1, t2); + else + t = new TypeTuple(t1); + } + else + t = new TypeTuple(); + return t; +} + +TypeTuple *TypeVector::toArgTypes() +{ + return new TypeTuple(Type::tfloat64); +} + +TypeTuple *TypeSArray::toArgTypes() +{ +#if DMDV2 + return new TypeTuple(); // pass on the stack for efficiency +#else + return new TypeTuple(Type::tvoidptr); +#endif +} + +TypeTuple *TypeDArray::toArgTypes() +{ + return new TypeTuple(); // pass on the stack for efficiency +} + +TypeTuple *TypeAArray::toArgTypes() +{ + return new TypeTuple(Type::tvoidptr); +} + +TypeTuple *TypePointer::toArgTypes() +{ + return new TypeTuple(this); +} + +TypeTuple *TypeDelegate::toArgTypes() +{ + return new TypeTuple(); // pass on the stack for efficiency +} + +TypeTuple *TypeStruct::toArgTypes() +{ + d_uns64 sz = size(0); + assert(sz < 0xFFFFFFFF); + switch ((unsigned)sz) + { + case 1: + return new TypeTuple(Type::tint8); + case 2: + return new TypeTuple(Type::tint16); + case 4: + return new TypeTuple(Type::tint32); + case 8: + return new TypeTuple(Type::tint64); + } + return new TypeTuple(); // pass on the stack +} + +TypeTuple *TypeEnum::toArgTypes() +{ + return toBasetype()->toArgTypes(); +} + +TypeTuple *TypeTypedef::toArgTypes() +{ + return sym->basetype->toArgTypes(); +} + +TypeTuple *TypeClass::toArgTypes() +{ + return new TypeTuple(Type::tvoidptr); +} + diff --git a/arrayop.c b/arrayop.c new file mode 100644 index 00000000..2eaae398 --- /dev/null +++ b/arrayop.c @@ -0,0 +1,648 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "rmem.h" + +#include "aav.h" + +#include "expression.h" +#include "statement.h" +#include "mtype.h" +#include "declaration.h" +#include "scope.h" +#include "id.h" +#include "module.h" +#include "init.h" + +extern int binary(const char *p , const char **tab, int high); + +/************************************** + * Hash table of array op functions already generated or known about. + */ + +AA *arrayfuncs; + +/********************************************** + * Check that there are no uses of arrays without []. + */ +bool isArrayOpValid(Expression *e) +{ + if (e->op == TOKslice) + return true; + Type *tb = e->type->toBasetype(); + + if ( (tb->ty == Tarray) || (tb->ty == Tsarray) ) + { + switch (e->op) + { + case TOKadd: + case TOKmin: + case TOKmul: + case TOKdiv: + case TOKmod: + case TOKxor: + case TOKand: + case TOKor: + case TOKassign: + case TOKaddass: + case TOKminass: + case TOKmulass: + case TOKdivass: + case TOKmodass: + case TOKxorass: + case TOKandass: + case TOKorass: +#if DMDV2 + case TOKpow: + case TOKpowass: +#endif + return isArrayOpValid(((BinExp *)e)->e1) && isArrayOpValid(((BinExp *)e)->e2); + + case TOKcall: + return false; // TODO: Decide if [] is required after arrayop calls. + + case TOKneg: + case TOKtilde: + return isArrayOpValid(((UnaExp *)e)->e1); + + default: + return false; + } + } + return true; +} + +/*********************************** + * Construct the array operation expression. + */ + +Expression *BinExp::arrayOp(Scope *sc) +{ + //printf("BinExp::arrayOp() %s\n", toChars()); + + Type *tb = type->toBasetype(); + assert(tb->ty == Tarray || tb->ty == Tsarray); + if (tb->nextOf()->toBasetype()->ty == Tvoid) + { + error("Cannot perform array operations on void[] arrays"); + return new ErrorExp(); + } + + if (!isArrayOpValid(e2)) + { + e2->error("invalid array operation %s (did you forget a [] ?)", toChars()); + return new ErrorExp(); + } + + Expressions *arguments = new Expressions(); + + /* The expression to generate an array operation for is mangled + * into a name to use as the array operation function name. + * Mangle in the operands and operators in RPN order, and type. + */ + OutBuffer buf; + buf.writestring("_array"); + buildArrayIdent(&buf, arguments); + buf.writeByte('_'); + + /* Append deco of array element type + */ +#if DMDV2 + buf.writestring(type->toBasetype()->nextOf()->toBasetype()->mutableOf()->deco); +#else + buf.writestring(type->toBasetype()->nextOf()->toBasetype()->deco); +#endif + + size_t namelen = buf.offset; + buf.writeByte(0); + char *name = buf.toChars(); + Identifier *ident = Lexer::idPool(name); + + /* Look up name in hash table + */ + FuncDeclaration **pfd = (FuncDeclaration **)_aaGet(&arrayfuncs, ident); + FuncDeclaration *fd = (FuncDeclaration *)*pfd; + if (!fd) + { + /* Some of the array op functions are written as library functions, + * presumably to optimize them with special CPU vector instructions. + * List those library functions here, in alpha order. + */ + static const char *libArrayopFuncs[] = + { + "_arrayExpSliceAddass_a", + "_arrayExpSliceAddass_d", // T[]+=T + "_arrayExpSliceAddass_f", // T[]+=T + "_arrayExpSliceAddass_g", + "_arrayExpSliceAddass_h", + "_arrayExpSliceAddass_i", + "_arrayExpSliceAddass_k", + "_arrayExpSliceAddass_s", + "_arrayExpSliceAddass_t", + "_arrayExpSliceAddass_u", + "_arrayExpSliceAddass_w", + + "_arrayExpSliceDivass_d", // T[]/=T + "_arrayExpSliceDivass_f", // T[]/=T + + "_arrayExpSliceMinSliceAssign_a", + "_arrayExpSliceMinSliceAssign_d", // T[]=T-T[] + "_arrayExpSliceMinSliceAssign_f", // T[]=T-T[] + "_arrayExpSliceMinSliceAssign_g", + "_arrayExpSliceMinSliceAssign_h", + "_arrayExpSliceMinSliceAssign_i", + "_arrayExpSliceMinSliceAssign_k", + "_arrayExpSliceMinSliceAssign_s", + "_arrayExpSliceMinSliceAssign_t", + "_arrayExpSliceMinSliceAssign_u", + "_arrayExpSliceMinSliceAssign_w", + + "_arrayExpSliceMinass_a", + "_arrayExpSliceMinass_d", // T[]-=T + "_arrayExpSliceMinass_f", // T[]-=T + "_arrayExpSliceMinass_g", + "_arrayExpSliceMinass_h", + "_arrayExpSliceMinass_i", + "_arrayExpSliceMinass_k", + "_arrayExpSliceMinass_s", + "_arrayExpSliceMinass_t", + "_arrayExpSliceMinass_u", + "_arrayExpSliceMinass_w", + + "_arrayExpSliceMulass_d", // T[]*=T + "_arrayExpSliceMulass_f", // T[]*=T + "_arrayExpSliceMulass_i", + "_arrayExpSliceMulass_k", + "_arrayExpSliceMulass_s", + "_arrayExpSliceMulass_t", + "_arrayExpSliceMulass_u", + "_arrayExpSliceMulass_w", + + "_arraySliceExpAddSliceAssign_a", + "_arraySliceExpAddSliceAssign_d", // T[]=T[]+T + "_arraySliceExpAddSliceAssign_f", // T[]=T[]+T + "_arraySliceExpAddSliceAssign_g", + "_arraySliceExpAddSliceAssign_h", + "_arraySliceExpAddSliceAssign_i", + "_arraySliceExpAddSliceAssign_k", + "_arraySliceExpAddSliceAssign_s", + "_arraySliceExpAddSliceAssign_t", + "_arraySliceExpAddSliceAssign_u", + "_arraySliceExpAddSliceAssign_w", + + "_arraySliceExpDivSliceAssign_d", // T[]=T[]/T + "_arraySliceExpDivSliceAssign_f", // T[]=T[]/T + + "_arraySliceExpMinSliceAssign_a", + "_arraySliceExpMinSliceAssign_d", // T[]=T[]-T + "_arraySliceExpMinSliceAssign_f", // T[]=T[]-T + "_arraySliceExpMinSliceAssign_g", + "_arraySliceExpMinSliceAssign_h", + "_arraySliceExpMinSliceAssign_i", + "_arraySliceExpMinSliceAssign_k", + "_arraySliceExpMinSliceAssign_s", + "_arraySliceExpMinSliceAssign_t", + "_arraySliceExpMinSliceAssign_u", + "_arraySliceExpMinSliceAssign_w", + + "_arraySliceExpMulSliceAddass_d", // T[] += T[]*T + "_arraySliceExpMulSliceAddass_f", + "_arraySliceExpMulSliceAddass_r", + + "_arraySliceExpMulSliceAssign_d", // T[]=T[]*T + "_arraySliceExpMulSliceAssign_f", // T[]=T[]*T + "_arraySliceExpMulSliceAssign_i", + "_arraySliceExpMulSliceAssign_k", + "_arraySliceExpMulSliceAssign_s", + "_arraySliceExpMulSliceAssign_t", + "_arraySliceExpMulSliceAssign_u", + "_arraySliceExpMulSliceAssign_w", + + "_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T + "_arraySliceExpMulSliceMinass_f", + "_arraySliceExpMulSliceMinass_r", + + "_arraySliceSliceAddSliceAssign_a", + "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] + "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] + "_arraySliceSliceAddSliceAssign_g", + "_arraySliceSliceAddSliceAssign_h", + "_arraySliceSliceAddSliceAssign_i", + "_arraySliceSliceAddSliceAssign_k", + "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] + "_arraySliceSliceAddSliceAssign_s", + "_arraySliceSliceAddSliceAssign_t", + "_arraySliceSliceAddSliceAssign_u", + "_arraySliceSliceAddSliceAssign_w", + + "_arraySliceSliceAddass_a", + "_arraySliceSliceAddass_d", // T[]+=T[] + "_arraySliceSliceAddass_f", // T[]+=T[] + "_arraySliceSliceAddass_g", + "_arraySliceSliceAddass_h", + "_arraySliceSliceAddass_i", + "_arraySliceSliceAddass_k", + "_arraySliceSliceAddass_s", + "_arraySliceSliceAddass_t", + "_arraySliceSliceAddass_u", + "_arraySliceSliceAddass_w", + + "_arraySliceSliceMinSliceAssign_a", + "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] + "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] + "_arraySliceSliceMinSliceAssign_g", + "_arraySliceSliceMinSliceAssign_h", + "_arraySliceSliceMinSliceAssign_i", + "_arraySliceSliceMinSliceAssign_k", + "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] + "_arraySliceSliceMinSliceAssign_s", + "_arraySliceSliceMinSliceAssign_t", + "_arraySliceSliceMinSliceAssign_u", + "_arraySliceSliceMinSliceAssign_w", + + "_arraySliceSliceMinass_a", + "_arraySliceSliceMinass_d", // T[]-=T[] + "_arraySliceSliceMinass_f", // T[]-=T[] + "_arraySliceSliceMinass_g", + "_arraySliceSliceMinass_h", + "_arraySliceSliceMinass_i", + "_arraySliceSliceMinass_k", + "_arraySliceSliceMinass_s", + "_arraySliceSliceMinass_t", + "_arraySliceSliceMinass_u", + "_arraySliceSliceMinass_w", + + "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] + "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] + "_arraySliceSliceMulSliceAssign_i", + "_arraySliceSliceMulSliceAssign_k", + "_arraySliceSliceMulSliceAssign_s", + "_arraySliceSliceMulSliceAssign_t", + "_arraySliceSliceMulSliceAssign_u", + "_arraySliceSliceMulSliceAssign_w", + + "_arraySliceSliceMulass_d", // T[]*=T[] + "_arraySliceSliceMulass_f", // T[]*=T[] + "_arraySliceSliceMulass_i", + "_arraySliceSliceMulass_k", + "_arraySliceSliceMulass_s", + "_arraySliceSliceMulass_t", + "_arraySliceSliceMulass_u", + "_arraySliceSliceMulass_w", + }; + + int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); + if (i == -1) + { +#ifdef DEBUG // Make sure our array is alphabetized + for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) + { + if (strcmp(name, libArrayopFuncs[i]) == 0) + assert(0); + } +#endif + /* Not in library, so generate it. + * Construct the function body: + * foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++) + * loopbody; + * return p; + */ + + Parameters *fparams = new Parameters(); + Expression *loopbody = buildArrayLoop(fparams); + Parameter *p = (*fparams)[0 /*fparams->dim - 1*/]; +#if DMDV1 + // for (size_t i = 0; i < p.length; i++) + Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t)); + Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init); + Statement *s1 = new ForStatement(0, + new DeclarationStatement(0, d), + new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))), + new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)), + new ExpStatement(0, loopbody)); +#else + // foreach (i; 0 .. p.length) + Statement *s1 = new ForeachRangeStatement(0, TOKforeach, + new Parameter(0, NULL, Id::p, NULL), + new IntegerExp(0, 0, Type::tint32), + new ArrayLengthExp(0, new IdentifierExp(0, p->ident)), + new ExpStatement(0, loopbody)); +#endif + Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident)); + //printf("s2: %s\n", s2->toChars()); + Statement *fbody = new CompoundStatement(0, s1, s2); + + /* Construct the function + */ + TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc); + //printf("ftype: %s\n", ftype->toChars()); + fd = new FuncDeclaration(loc, 0, ident, STCundefined, ftype); + fd->fbody = fbody; + fd->protection = PROTpublic; + fd->linkage = LINKc; + fd->isArrayOp = 1; + + sc->module->importedFrom->members->push(fd); + + sc = sc->push(); + sc->parent = sc->module->importedFrom; + sc->stc = 0; + sc->linkage = LINKc; + fd->semantic(sc); + fd->semantic2(sc); + fd->semantic3(sc); + sc->pop(); + } + else + { /* In library, refer to it. + */ + fd = FuncDeclaration::genCfunc(type, ident); + } + *pfd = fd; // cache symbol in hash table + } + + /* Call the function fd(arguments) + */ + Expression *ec = new VarExp(0, fd); + Expression *e = new CallExp(loc, ec, arguments); + e->type = type; + return e; +} + +/****************************************** + * Construct the identifier for the array operation function, + * and build the argument list to pass to it. + */ + +void Expression::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + buf->writestring("Exp"); + arguments->shift(this); +} + +void CastExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + Type *tb = type->toBasetype(); + if (tb->ty == Tarray || tb->ty == Tsarray) + { + e1->buildArrayIdent(buf, arguments); + } + else + Expression::buildArrayIdent(buf, arguments); +} + +void SliceExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + buf->writestring("Slice"); + arguments->shift(this); +} + +void AssignExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + /* Evaluate assign expressions right to left + */ + e2->buildArrayIdent(buf, arguments); + e1->buildArrayIdent(buf, arguments); + buf->writestring("Assign"); +} + +#define X(Str) \ +void Str##AssignExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) \ +{ \ + /* Evaluate assign expressions right to left \ + */ \ + e2->buildArrayIdent(buf, arguments); \ + e1->buildArrayIdent(buf, arguments); \ + buf->writestring(#Str); \ + buf->writestring("ass"); \ +} + +X(Add) +X(Min) +X(Mul) +X(Div) +X(Mod) +X(Xor) +X(And) +X(Or) +#if DMDV2 +X(Pow) +#endif + +#undef X + +void NegExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + e1->buildArrayIdent(buf, arguments); + buf->writestring("Neg"); +} + +void ComExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) +{ + e1->buildArrayIdent(buf, arguments); + buf->writestring("Com"); +} + +#define X(Str) \ +void Str##Exp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) \ +{ \ + /* Evaluate assign expressions left to right \ + */ \ + e1->buildArrayIdent(buf, arguments); \ + e2->buildArrayIdent(buf, arguments); \ + buf->writestring(#Str); \ +} + +X(Add) +X(Min) +X(Mul) +X(Div) +X(Mod) +X(Xor) +X(And) +X(Or) +#if DMDV2 +X(Pow) +#endif + +#undef X + +/****************************************** + * Construct the inner loop for the array operation function, + * and build the parameter list. + */ + +Expression *Expression::buildArrayLoop(Parameters *fparams) +{ + Identifier *id = Identifier::generateId("c", fparams->dim); + Parameter *param = new Parameter(0, type, id, NULL); + fparams->shift(param); + Expression *e = new IdentifierExp(0, id); + return e; +} + +Expression *CastExp::buildArrayLoop(Parameters *fparams) +{ + Type *tb = type->toBasetype(); + if (tb->ty == Tarray || tb->ty == Tsarray) + { + return e1->buildArrayLoop(fparams); + } + else + return Expression::buildArrayLoop(fparams); +} + +Expression *SliceExp::buildArrayLoop(Parameters *fparams) +{ + Identifier *id = Identifier::generateId("p", fparams->dim); + Parameter *param = new Parameter(STCconst, type, id, NULL); + fparams->shift(param); + Expression *e = new IdentifierExp(0, id); + Expressions *arguments = new Expressions(); + Expression *index = new IdentifierExp(0, Id::p); + arguments->push(index); + e = new ArrayExp(0, e, arguments); + return e; +} + +Expression *AssignExp::buildArrayLoop(Parameters *fparams) +{ + /* Evaluate assign expressions right to left + */ + Expression *ex2 = e2->buildArrayLoop(fparams); +#if DMDV2 + /* Need the cast because: + * b = c + p[i]; + * where b is a byte fails because (c + p[i]) is an int + * which cannot be implicitly cast to byte. + */ + ex2 = new CastExp(0, ex2, e1->type->nextOf()); +#endif + Expression *ex1 = e1->buildArrayLoop(fparams); + Parameter *param = (*fparams)[0]; + param->storageClass = 0; + Expression *e = new AssignExp(0, ex1, ex2); + return e; +} + +#define X(Str) \ +Expression *Str##AssignExp::buildArrayLoop(Parameters *fparams) \ +{ \ + /* Evaluate assign expressions right to left \ + */ \ + Expression *ex2 = e2->buildArrayLoop(fparams); \ + Expression *ex1 = e1->buildArrayLoop(fparams); \ + Parameter *param = (*fparams)[0]; \ + param->storageClass = 0; \ + Expression *e = new Str##AssignExp(loc, ex1, ex2); \ + return e; \ +} + +X(Add) +X(Min) +X(Mul) +X(Div) +X(Mod) +X(Xor) +X(And) +X(Or) +#if DMDV2 +X(Pow) +#endif + +#undef X + +Expression *NegExp::buildArrayLoop(Parameters *fparams) +{ + Expression *ex1 = e1->buildArrayLoop(fparams); + Expression *e = new NegExp(0, ex1); + return e; +} + +Expression *ComExp::buildArrayLoop(Parameters *fparams) +{ + Expression *ex1 = e1->buildArrayLoop(fparams); + Expression *e = new ComExp(0, ex1); + return e; +} + +#define X(Str) \ +Expression *Str##Exp::buildArrayLoop(Parameters *fparams) \ +{ \ + /* Evaluate assign expressions left to right \ + */ \ + Expression *ex1 = e1->buildArrayLoop(fparams); \ + Expression *ex2 = e2->buildArrayLoop(fparams); \ + Expression *e = new Str##Exp(0, ex1, ex2); \ + return e; \ +} + +X(Add) +X(Min) +X(Mul) +X(Div) +X(Mod) +X(Xor) +X(And) +X(Or) +#if DMDV2 +X(Pow) +#endif + +#undef X + + +/*********************************************** + * Test if operand is a valid array op operand. + */ + +int Expression::isArrayOperand() +{ + //printf("Expression::isArrayOperand() %s\n", toChars()); + if (op == TOKslice) + return 1; + if (type->toBasetype()->ty == Tarray) + { + switch (op) + { + case TOKadd: + case TOKmin: + case TOKmul: + case TOKdiv: + case TOKmod: + case TOKxor: + case TOKand: + case TOKor: + case TOKassign: + case TOKaddass: + case TOKminass: + case TOKmulass: + case TOKdivass: + case TOKmodass: + case TOKxorass: + case TOKandass: + case TOKorass: +#if DMDV2 + case TOKpow: + case TOKpowass: +#endif + case TOKneg: + case TOKtilde: + return 1; + + default: + break; + } + } + return 0; +} diff --git a/arraytypes.h b/arraytypes.h new file mode 100644 index 00000000..be854a62 --- /dev/null +++ b/arraytypes.h @@ -0,0 +1,77 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2006-2007 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_ARRAYTYPES_H +#define DMD_ARRAYTYPES_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + + +#include "root.h" + +typedef ArrayBase TemplateParameters; + +typedef ArrayBase Expressions; + +typedef ArrayBase Statements; + +typedef ArrayBase BaseClasses; + +typedef ArrayBase ClassDeclarations; + +typedef ArrayBase Dsymbols; + +typedef ArrayBase Objects; + +typedef ArrayBase FuncDeclarations; + +typedef ArrayBase Parameters; + +typedef ArrayBase Identifiers; + +typedef ArrayBase Initializers; + +typedef ArrayBase VarDeclarations; + +typedef ArrayBase Types; + +typedef ArrayBase ScopeDsymbols; + +typedef ArrayBase Catches; + +typedef ArrayBase StaticDtorDeclarations; + +typedef ArrayBase SharedStaticDtorDeclarations; + +typedef ArrayBase AliasDeclarations; + +typedef ArrayBase Modules; + +typedef ArrayBase Files; + +typedef ArrayBase CaseStatements; + +typedef ArrayBase CompoundStatements; + +typedef ArrayBase GotoCaseStatements; + +typedef ArrayBase TemplateInstances; + +//typedef ArrayBase Strings; + +typedef ArrayBase Voids; + +typedef ArrayBase Blocks; + +typedef ArrayBase Symbols; + +#endif diff --git a/artistic.txt b/artistic.txt new file mode 100644 index 00000000..cae432b7 --- /dev/null +++ b/artistic.txt @@ -0,0 +1,117 @@ + + + + + The "Artistic License" + + Preamble + +The intent of this document is to state the conditions under which a +Package may be copied, such that the Copyright Holder maintains some +semblance of artistic control over the development of the package, +while giving the users of the package the right to use and distribute +the Package in a more-or-less customary fashion, plus the right to make +reasonable modifications. + +Definitions: + + "Package" refers to the collection of files distributed by the + Copyright Holder, and derivatives of that collection of files + created through textual modification. + + "Standard Version" refers to such a Package if it has not been + modified, or has been modified in accordance with the wishes + of the Copyright Holder as specified below. + + "Copyright Holder" is whoever is named in the copyright or + copyrights for the package. + + "You" is you, if you're thinking about copying or distributing + this Package. + + "Reasonable copying fee" is whatever you can justify on the + basis of media cost, duplication charges, time of people involved, + and so on. (You will not be required to justify it to the + Copyright Holder, but only to the computing community at large + as a market that must bear the fee.) + + "Freely Available" means that no fee is charged for the item + itself, though there may be fees involved in handling the item. + It also means that recipients of the item may redistribute it + under the same conditions they received it. + +1. You may make and give away verbatim copies of the source form of the +Standard Version of this Package without restriction, provided that you +duplicate all of the original copyright notices and associated disclaimers. + +2. You may apply bug fixes, portability fixes and other modifications +derived from the Public Domain or from the Copyright Holder. A Package +modified in such a way shall still be considered the Standard Version. + +3. You may otherwise modify your copy of this Package in any way, provided +that you insert a prominent notice in each changed file stating how and +when you changed that file, and provided that you do at least ONE of the +following: + + a) place your modifications in the Public Domain or otherwise make them + Freely Available, such as by posting said modifications to Usenet or + an equivalent medium, or placing the modifications on a major archive + site such as uunet.uu.net, or by allowing the Copyright Holder to include + your modifications in the Standard Version of the Package. + + b) use the modified Package only within your corporation or organization. + + c) rename any non-standard executables so the names do not conflict + with standard executables, which must also be provided, and provide + a separate manual page for each non-standard executable that clearly + documents how it differs from the Standard Version. + + d) make other distribution arrangements with the Copyright Holder. + +4. You may distribute the programs of this Package in object code or +executable form, provided that you do at least ONE of the following: + + a) distribute a Standard Version of the executables and library files, + together with instructions (in the manual page or equivalent) on where + to get the Standard Version. + + b) accompany the distribution with the machine-readable source of + the Package with your modifications. + + c) give non-standard executables non-standard names, and clearly + document the differences in manual pages (or equivalent), together + with instructions on where to get the Standard Version. + + d) make other distribution arrangements with the Copyright Holder. + +5. You may charge a reasonable copying fee for any distribution of this +Package. You may charge any fee you choose for support of this +Package. You may not charge a fee for this Package itself. However, +you may distribute this Package in aggregate with other (possibly +commercial) programs as part of a larger (possibly commercial) software +distribution provided that you do not advertise this Package as a +product of your own. You may embed this Package's interpreter within +an executable of yours (by linking); this shall be construed as a mere +form of aggregation, provided that the complete Standard Version of the +interpreter is so embedded. + +6. The source code and object code supplied as input to or produced as +output from the programs of this Package do not automatically fall +under the copyright of this Package, but belong to whoever generated +them, and may be sold commercially, and may be aggregated with this +Package. + +7. Aggregation of this Package with a commercial distribution is always +permitted provided that the use of this Package is embedded; that is, +when no overt attempt is made to make this Package's interfaces visible +to the end user of the commercial distribution. Such use shall not be +construed as a distribution of this Package. + +8. The name of the Copyright Holder may not be used to endorse or promote +products derived from this software without specific prior written permission. + +9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED +WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + + The End diff --git a/attrib.c b/attrib.c new file mode 100644 index 00000000..e55dd83b --- /dev/null +++ b/attrib.c @@ -0,0 +1,1524 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "rmem.h" + +#include "init.h" +#include "declaration.h" +#include "attrib.h" +#include "cond.h" +#include "scope.h" +#include "id.h" +#include "expression.h" +#include "dsymbol.h" +#include "aggregate.h" +#include "module.h" +#include "parse.h" +#include "template.h" +#if TARGET_NET + #include "frontend.net/pragma.h" +#endif + +extern void obj_includelib(const char *name); +void obj_startaddress(Symbol *s); + + +/********************************* AttribDeclaration ****************************/ + +AttribDeclaration::AttribDeclaration(Dsymbols *decl) + : Dsymbol() +{ + this->decl = decl; +} + +Dsymbols *AttribDeclaration::include(Scope *sc, ScopeDsymbol *sd) +{ + return decl; +} + +int AttribDeclaration::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + int m = 0; + Dsymbols *d = include(sc, sd); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + //printf("\taddMember %s to %s\n", s->toChars(), sd->toChars()); + m |= s->addMember(sc, sd, m | memnum); + } + } + return m; +} + +void AttribDeclaration::setScopeNewSc(Scope *sc, + StorageClass stc, enum LINK linkage, enum PROT protection, int explicitProtection, + unsigned structalign) +{ + if (decl) + { + Scope *newsc = sc; + if (stc != sc->stc || + linkage != sc->linkage || + protection != sc->protection || + explicitProtection != sc->explicitProtection || + structalign != sc->structalign) + { + // create new one for changes + newsc = new Scope(*sc); + newsc->flags &= ~SCOPEfree; + newsc->stc = stc; + newsc->linkage = linkage; + newsc->protection = protection; + newsc->explicitProtection = explicitProtection; + newsc->structalign = structalign; + } + for (unsigned i = 0; i < decl->dim; i++) + { Dsymbol *s = decl->tdata()[i]; + + s->setScope(newsc); // yes, the only difference from semanticNewSc() + } + if (newsc != sc) + { + sc->offset = newsc->offset; + newsc->pop(); + } + } +} + +void AttribDeclaration::semanticNewSc(Scope *sc, + StorageClass stc, enum LINK linkage, enum PROT protection, int explicitProtection, + unsigned structalign) +{ + if (decl) + { + Scope *newsc = sc; + if (stc != sc->stc || + linkage != sc->linkage || + protection != sc->protection || + explicitProtection != sc->explicitProtection || + structalign != sc->structalign) + { + // create new one for changes + newsc = new Scope(*sc); + newsc->flags &= ~SCOPEfree; + newsc->stc = stc; + newsc->linkage = linkage; + newsc->protection = protection; + newsc->explicitProtection = explicitProtection; + newsc->structalign = structalign; + } + for (unsigned i = 0; i < decl->dim; i++) + { Dsymbol *s = decl->tdata()[i]; + + s->semantic(newsc); + } + if (newsc != sc) + { + sc->offset = newsc->offset; + newsc->pop(); + } + } +} + +void AttribDeclaration::semantic(Scope *sc) +{ + Dsymbols *d = include(sc, NULL); + + //printf("\tAttribDeclaration::semantic '%s', d = %p\n",toChars(), d); + if (d) + { + for (size_t i = 0; i < d->dim; i++) + { + Dsymbol *s = d->tdata()[i]; + + s->semantic(sc); + } + } +} + +void AttribDeclaration::semantic2(Scope *sc) +{ + Dsymbols *d = include(sc, NULL); + + if (d) + { + for (size_t i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->semantic2(sc); + } + } +} + +void AttribDeclaration::semantic3(Scope *sc) +{ + Dsymbols *d = include(sc, NULL); + + if (d) + { + for (size_t i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->semantic3(sc); + } + } +} + +void AttribDeclaration::inlineScan() +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + //printf("AttribDeclaration::inlineScan %s\n", s->toChars()); + s->inlineScan(); + } + } +} + +void AttribDeclaration::addComment(unsigned char *comment) +{ + //printf("AttribDeclaration::addComment %s\n", comment); + if (comment) + { + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + //printf("AttribDeclaration::addComment %s\n", s->toChars()); + s->addComment(comment); + } + } + } +} + +void AttribDeclaration::emitComment(Scope *sc) +{ + //printf("AttribDeclaration::emitComment(sc = %p)\n", sc); + + /* A general problem with this, illustrated by BUGZILLA 2516, + * is that attributes are not transmitted through to the underlying + * member declarations for template bodies, because semantic analysis + * is not done for template declaration bodies + * (only template instantiations). + * Hence, Ddoc omits attributes from template members. + */ + + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + //printf("AttribDeclaration::emitComment %s\n", s->toChars()); + s->emitComment(sc); + } + } +} + +void AttribDeclaration::toObjFile(int multiobj) +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->toObjFile(multiobj); + } + } +} + +int AttribDeclaration::cvMember(unsigned char *p) +{ + int nwritten = 0; + int n; + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + n = s->cvMember(p); + if (p) + p += n; + nwritten += n; + } + } + return nwritten; +} + +int AttribDeclaration::hasPointers() +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (size_t i = 0; i < d->dim; i++) + { + Dsymbol *s = d->tdata()[i]; + if (s->hasPointers()) + return 1; + } + } + return 0; +} + +bool AttribDeclaration::hasStaticCtorOrDtor() +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (size_t i = 0; i < d->dim; i++) + { + Dsymbol *s = (*d)[i]; + if (s->hasStaticCtorOrDtor()) + return TRUE; + } + } + return FALSE; +} + +const char *AttribDeclaration::kind() +{ + return "attribute"; +} + +int AttribDeclaration::oneMember(Dsymbol **ps, Identifier *ident) +{ + Dsymbols *d = include(NULL, NULL); + + return Dsymbol::oneMembers(d, ps, ident); +} + +void AttribDeclaration::checkCtorConstInit() +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->checkCtorConstInit(); + } + } +} + +/**************************************** + */ + +void AttribDeclaration::addLocalClass(ClassDeclarations *aclasses) +{ + Dsymbols *d = include(NULL, NULL); + + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->addLocalClass(aclasses); + } + } +} + + +void AttribDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (decl) + { + if (decl->dim == 0) + buf->writestring("{}"); + else if (decl->dim == 1) + (decl->tdata()[0])->toCBuffer(buf, hgs); + else + { + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + buf->writeByte('}'); + } + } + else + buf->writeByte(';'); + buf->writenl(); +} + +/************************* StorageClassDeclaration ****************************/ + +StorageClassDeclaration::StorageClassDeclaration(StorageClass stc, Dsymbols *decl) + : AttribDeclaration(decl) +{ + this->stc = stc; +} + +Dsymbol *StorageClassDeclaration::syntaxCopy(Dsymbol *s) +{ + StorageClassDeclaration *scd; + + assert(!s); + scd = new StorageClassDeclaration(stc, Dsymbol::arraySyntaxCopy(decl)); + return scd; +} + +int StorageClassDeclaration::oneMember(Dsymbol **ps, Identifier *ident) +{ + + int t = Dsymbol::oneMembers(decl, ps, ident); + if (t && *ps) + { + /* This is to deal with the following case: + * struct Tick { + * template to(T) { const T to() { ... } } + * } + * For eponymous function templates, the 'const' needs to get attached to 'to' + * before the semantic analysis of 'to', so that template overloading based on the + * 'this' pointer can be successful. + */ + + FuncDeclaration *fd = (*ps)->isFuncDeclaration(); + if (fd) + { + /* Use storage_class2 instead of storage_class otherwise when we do .di generation + * we'll wind up with 'const const' rather than 'const'. + */ + /* Don't think we need to worry about mutually exclusive storage classes here + */ + fd->storage_class2 |= stc; + } + } + return t; +} + +void StorageClassDeclaration::setScope(Scope *sc) +{ + if (decl) + { + StorageClass scstc = sc->stc; + + /* These sets of storage classes are mutually exclusive, + * so choose the innermost or most recent one. + */ + if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest)) + scstc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest); + if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared)) + scstc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared); + if (stc & (STCconst | STCimmutable | STCmanifest)) + scstc &= ~(STCconst | STCimmutable | STCmanifest); + if (stc & (STCgshared | STCshared | STCtls)) + scstc &= ~(STCgshared | STCshared | STCtls); + if (stc & (STCsafe | STCtrusted | STCsystem)) + scstc &= ~(STCsafe | STCtrusted | STCsystem); + scstc |= stc; + + setScopeNewSc(sc, scstc, sc->linkage, sc->protection, sc->explicitProtection, sc->structalign); + } +} + +void StorageClassDeclaration::semantic(Scope *sc) +{ + if (decl) + { + StorageClass scstc = sc->stc; + + /* These sets of storage classes are mutually exclusive, + * so choose the innermost or most recent one. + */ + if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest)) + scstc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest); + if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared)) + scstc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared); + if (stc & (STCconst | STCimmutable | STCmanifest)) + scstc &= ~(STCconst | STCimmutable | STCmanifest); + if (stc & (STCgshared | STCshared | STCtls)) + scstc &= ~(STCgshared | STCshared | STCtls); + if (stc & (STCsafe | STCtrusted | STCsystem)) + scstc &= ~(STCsafe | STCtrusted | STCsystem); + scstc |= stc; + + semanticNewSc(sc, scstc, sc->linkage, sc->protection, sc->explicitProtection, sc->structalign); + } +} + +void StorageClassDeclaration::stcToCBuffer(OutBuffer *buf, StorageClass stc) +{ + struct SCstring + { + StorageClass stc; + enum TOK tok; + Identifier *id; + }; + + static SCstring table[] = + { + { STCauto, TOKauto }, + { STCscope, TOKscope }, + { STCstatic, TOKstatic }, + { STCextern, TOKextern }, + { STCconst, TOKconst }, + { STCfinal, TOKfinal }, + { STCabstract, TOKabstract }, + { STCsynchronized, TOKsynchronized }, + { STCdeprecated, TOKdeprecated }, + { STCoverride, TOKoverride }, + { STClazy, TOKlazy }, + { STCalias, TOKalias }, + { STCout, TOKout }, + { STCin, TOKin }, +#if DMDV2 + { STCmanifest, TOKenum }, + { STCimmutable, TOKimmutable }, + { STCshared, TOKshared }, + { STCnothrow, TOKnothrow }, + { STCpure, TOKpure }, + { STCref, TOKref }, + { STCtls, TOKtls }, + { STCgshared, TOKgshared }, + { STCproperty, TOKat, Id::property }, + { STCsafe, TOKat, Id::safe }, + { STCtrusted, TOKat, Id::trusted }, + { STCsystem, TOKat, Id::system }, + { STCdisable, TOKat, Id::disable }, +#endif + }; + + for (int i = 0; i < sizeof(table)/sizeof(table[0]); i++) + { + if (stc & table[i].stc) + { + enum TOK tok = table[i].tok; +#if DMDV2 + if (tok == TOKat) + { + buf->writeByte('@'); + buf->writestring(table[i].id->toChars()); + } + else +#endif + buf->writestring(Token::toChars(tok)); + buf->writeByte(' '); + } + } +} + +void StorageClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + stcToCBuffer(buf, stc); + AttribDeclaration::toCBuffer(buf, hgs); +} + +/********************************* LinkDeclaration ****************************/ + +LinkDeclaration::LinkDeclaration(enum LINK p, Dsymbols *decl) + : AttribDeclaration(decl) +{ + //printf("LinkDeclaration(linkage = %d, decl = %p)\n", p, decl); + linkage = p; +} + +Dsymbol *LinkDeclaration::syntaxCopy(Dsymbol *s) +{ + LinkDeclaration *ld; + + assert(!s); + ld = new LinkDeclaration(linkage, Dsymbol::arraySyntaxCopy(decl)); + return ld; +} + +void LinkDeclaration::setScope(Scope *sc) +{ + //printf("LinkDeclaration::setScope(linkage = %d, decl = %p)\n", linkage, decl); + if (decl) + { + setScopeNewSc(sc, sc->stc, linkage, sc->protection, sc->explicitProtection, sc->structalign); + } +} + +void LinkDeclaration::semantic(Scope *sc) +{ + //printf("LinkDeclaration::semantic(linkage = %d, decl = %p)\n", linkage, decl); + if (decl) + { + semanticNewSc(sc, sc->stc, linkage, sc->protection, sc->explicitProtection, sc->structalign); + } +} + +void LinkDeclaration::semantic3(Scope *sc) +{ + //printf("LinkDeclaration::semantic3(linkage = %d, decl = %p)\n", linkage, decl); + if (decl) + { enum LINK linkage_save = sc->linkage; + + sc->linkage = linkage; + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + s->semantic3(sc); + } + sc->linkage = linkage_save; + } + else + { + sc->linkage = linkage; + } +} + +void LinkDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ const char *p; + + switch (linkage) + { + case LINKd: p = "D"; break; + case LINKc: p = "C"; break; + case LINKcpp: p = "C++"; break; + case LINKwindows: p = "Windows"; break; + case LINKpascal: p = "Pascal"; break; + default: + assert(0); + break; + } + buf->writestring("extern ("); + buf->writestring(p); + buf->writestring(") "); + AttribDeclaration::toCBuffer(buf, hgs); +} + +char *LinkDeclaration::toChars() +{ + return (char *)"extern ()"; +} + +/********************************* ProtDeclaration ****************************/ + +ProtDeclaration::ProtDeclaration(enum PROT p, Dsymbols *decl) + : AttribDeclaration(decl) +{ + protection = p; + //printf("decl = %p\n", decl); +} + +Dsymbol *ProtDeclaration::syntaxCopy(Dsymbol *s) +{ + ProtDeclaration *pd; + + assert(!s); + pd = new ProtDeclaration(protection, Dsymbol::arraySyntaxCopy(decl)); + return pd; +} + +void ProtDeclaration::setScope(Scope *sc) +{ + if (decl) + { + setScopeNewSc(sc, sc->stc, sc->linkage, protection, 1, sc->structalign); + } +} + +void ProtDeclaration::importAll(Scope *sc) +{ + Scope *newsc = sc; + if (sc->protection != protection || + sc->explicitProtection != 1) + { + // create new one for changes + newsc = new Scope(*sc); + newsc->flags &= ~SCOPEfree; + newsc->protection = protection; + newsc->explicitProtection = 1; + } + + for (size_t i = 0; i < decl->dim; i++) + { + Dsymbol *s = (*decl)[i]; + s->importAll(newsc); + } + + if (newsc != sc) + newsc->pop(); +} + +void ProtDeclaration::semantic(Scope *sc) +{ + if (decl) + { + semanticNewSc(sc, sc->stc, sc->linkage, protection, 1, sc->structalign); + } +} + +void ProtDeclaration::protectionToCBuffer(OutBuffer *buf, enum PROT protection) +{ + const char *p; + + switch (protection) + { + case PROTprivate: p = "private"; break; + case PROTpackage: p = "package"; break; + case PROTprotected: p = "protected"; break; + case PROTpublic: p = "public"; break; + case PROTexport: p = "export"; break; + default: + assert(0); + break; + } + buf->writestring(p); + buf->writeByte(' '); +} + +void ProtDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + protectionToCBuffer(buf, protection); + AttribDeclaration::toCBuffer(buf, hgs); +} + +/********************************* AlignDeclaration ****************************/ + +AlignDeclaration::AlignDeclaration(unsigned sa, Dsymbols *decl) + : AttribDeclaration(decl) +{ + salign = sa; +} + +Dsymbol *AlignDeclaration::syntaxCopy(Dsymbol *s) +{ + AlignDeclaration *ad; + + assert(!s); + ad = new AlignDeclaration(salign, Dsymbol::arraySyntaxCopy(decl)); + return ad; +} + +void AlignDeclaration::setScope(Scope *sc) +{ + //printf("\tAlignDeclaration::setScope '%s'\n",toChars()); + if (decl) + { + setScopeNewSc(sc, sc->stc, sc->linkage, sc->protection, sc->explicitProtection, salign); + } +} + +void AlignDeclaration::semantic(Scope *sc) +{ + //printf("\tAlignDeclaration::semantic '%s'\n",toChars()); + if (decl) + { + semanticNewSc(sc, sc->stc, sc->linkage, sc->protection, sc->explicitProtection, salign); + } +} + + +void AlignDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("align (%d)", salign); + AttribDeclaration::toCBuffer(buf, hgs); +} + +/********************************* AnonDeclaration ****************************/ + +AnonDeclaration::AnonDeclaration(Loc loc, int isunion, Dsymbols *decl) + : AttribDeclaration(decl) +{ + this->loc = loc; + this->isunion = isunion; + this->sem = 0; +} + +Dsymbol *AnonDeclaration::syntaxCopy(Dsymbol *s) +{ + AnonDeclaration *ad; + + assert(!s); + ad = new AnonDeclaration(loc, isunion, Dsymbol::arraySyntaxCopy(decl)); + return ad; +} + +void AnonDeclaration::semantic(Scope *sc) +{ + //printf("\tAnonDeclaration::semantic %s %p\n", isunion ? "union" : "struct", this); + + if (sem == 1) + { //printf("already completed\n"); + scope = NULL; + return; // semantic() already completed + } + + Scope *scx = NULL; + if (scope) + { sc = scope; + scx = scope; + scope = NULL; + } + + unsigned dprogress_save = Module::dprogress; + + assert(sc->parent); + + Dsymbol *parent = sc->parent->pastMixin(); + AggregateDeclaration *ad = parent->isAggregateDeclaration(); + + if (!ad || (!ad->isStructDeclaration() && !ad->isClassDeclaration())) + { + error("can only be a part of an aggregate"); + return; + } + + if (decl) + { + AnonymousAggregateDeclaration aad; + int adisunion; + + if (sc->anonAgg) + { ad = sc->anonAgg; + adisunion = sc->inunion; + } + else + adisunion = ad->isUnionDeclaration() != NULL; + +// printf("\tsc->anonAgg = %p\n", sc->anonAgg); +// printf("\tad = %p\n", ad); +// printf("\taad = %p\n", &aad); + + sc = sc->push(); + sc->anonAgg = &aad; + sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls | STCgshared); + sc->inunion = isunion; + sc->offset = 0; + sc->flags = 0; + aad.structalign = sc->structalign; + aad.parent = ad; + + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + s->semantic(sc); + if (isunion) + sc->offset = 0; + if (aad.sizeok == 2) + { + break; + } + } + sc = sc->pop(); + + // If failed due to forward references, unwind and try again later + if (aad.sizeok == 2) + { + ad->sizeok = 2; + //printf("\tsetting ad->sizeok %p to 2\n", ad); + if (!sc->anonAgg) + { + scope = scx ? scx : new Scope(*sc); + scope->setNoFree(); + scope->module->addDeferredSemantic(this); + } + Module::dprogress = dprogress_save; + //printf("\tforward reference %p\n", this); + return; + } + if (sem == 0) + { Module::dprogress++; + sem = 1; + //printf("\tcompleted %p\n", this); + } + else + ;//printf("\talready completed %p\n", this); + + // 0 sized structs are set to 1 byte + if (aad.structsize == 0) + { + aad.structsize = 1; + aad.alignsize = 1; + } + + // Align size of anonymous aggregate +//printf("aad.structalign = %d, aad.alignsize = %d, sc->offset = %d\n", aad.structalign, aad.alignsize, sc->offset); + ad->alignmember(aad.structalign, aad.alignsize, &sc->offset); + //ad->structsize = sc->offset; +//printf("sc->offset = %d\n", sc->offset); + + // Add members of aad to ad + //printf("\tadding members of aad to '%s'\n", ad->toChars()); + for (unsigned i = 0; i < aad.fields.dim; i++) + { + VarDeclaration *v = aad.fields.tdata()[i]; + + v->offset += sc->offset; + ad->fields.push(v); + } + + // Add size of aad to ad + if (adisunion) + { + if (aad.structsize > ad->structsize) + ad->structsize = aad.structsize; + sc->offset = 0; + } + else + { + ad->structsize = sc->offset + aad.structsize; + sc->offset = ad->structsize; + } + + if (ad->alignsize < aad.alignsize) + ad->alignsize = aad.alignsize; + } +} + + +void AnonDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf(isunion ? "union" : "struct"); + buf->writestring("\n{\n"); + if (decl) + { + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + //buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + } + buf->writestring("}\n"); +} + +const char *AnonDeclaration::kind() +{ + return (isunion ? "anonymous union" : "anonymous struct"); +} + +/********************************* PragmaDeclaration ****************************/ + +PragmaDeclaration::PragmaDeclaration(Loc loc, Identifier *ident, Expressions *args, Dsymbols *decl) + : AttribDeclaration(decl) +{ + this->loc = loc; + this->ident = ident; + this->args = args; +} + +Dsymbol *PragmaDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("PragmaDeclaration::syntaxCopy(%s)\n", toChars()); + PragmaDeclaration *pd; + + assert(!s); + pd = new PragmaDeclaration(loc, ident, + Expression::arraySyntaxCopy(args), Dsymbol::arraySyntaxCopy(decl)); + return pd; +} + +void PragmaDeclaration::setScope(Scope *sc) +{ +#if TARGET_NET + if (ident == Lexer::idPool("assembly")) + { + if (!args || args->dim != 1) + { + error("pragma has invalid number of arguments"); + } + else + { + Expression *e = args->tdata()[0]; + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + args->tdata()[0] = e; + StringExp* se = e->toString(); + if (!se) + { + error("string expected, not '%s'", e->toChars()); + } + PragmaScope* pragma = new PragmaScope(this, sc->parent, se); + + assert(sc); + pragma->setScope(sc); + + //add to module members + assert(sc->module); + assert(sc->module->members); + sc->module->members->push(pragma); + } + } +#endif // TARGET_NET +} + +void PragmaDeclaration::semantic(Scope *sc) +{ // Should be merged with PragmaStatement + + //printf("\tPragmaDeclaration::semantic '%s'\n",toChars()); + if (ident == Id::msg) + { + if (args) + { + for (size_t i = 0; i < args->dim; i++) + { + Expression *e = args->tdata()[i]; + + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + StringExp *se = e->toString(); + if (se) + { + fprintf(stdmsg, "%.*s", (int)se->len, (char *)se->string); + } + else + fprintf(stdmsg, "%s", e->toChars()); + } + fprintf(stdmsg, "\n"); + } + goto Lnodecl; + } + else if (ident == Id::lib) + { + if (!args || args->dim != 1) + error("string expected for library name"); + else + { + Expression *e = args->tdata()[0]; + + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + args->tdata()[0] = e; + if (e->op == TOKerror) + goto Lnodecl; + StringExp *se = e->toString(); + if (!se) + error("string expected for library name, not '%s'", e->toChars()); + else if (global.params.verbose) + { + char *name = (char *)mem.malloc(se->len + 1); + memcpy(name, se->string, se->len); + name[se->len] = 0; + printf("library %s\n", name); + mem.free(name); + } + } + goto Lnodecl; + } +#if IN_GCC + else if (ident == Id::GNU_asm) + { + if (! args || args->dim != 2) + error("identifier and string expected for asm name"); + else + { + Expression *e; + Declaration *d = NULL; + StringExp *s = NULL; + + e = args->tdata()[0]; + e = e->semantic(sc); + if (e->op == TOKvar) + { + d = ((VarExp *)e)->var; + if (! d->isFuncDeclaration() && ! d->isVarDeclaration()) + d = NULL; + } + if (!d) + error("first argument of GNU_asm must be a function or variable declaration"); + + e = args->tdata()[1]; + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + e = e->toString(); + if (e && ((StringExp *)e)->sz == 1) + s = ((StringExp *)e); + else + error("second argument of GNU_asm must be a char string"); + + if (d && s) + d->c_ident = Lexer::idPool((char*) s->string); + } + goto Lnodecl; + } +#endif +#if DMDV2 + else if (ident == Id::startaddress) + { + if (!args || args->dim != 1) + error("function name expected for start address"); + else + { + Expression *e = args->tdata()[0]; + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + args->tdata()[0] = e; + Dsymbol *sa = getDsymbol(e); + if (!sa || !sa->isFuncDeclaration()) + error("function name expected for start address, not '%s'", e->toChars()); + } + goto Lnodecl; + } +#endif +#if TARGET_NET + else if (ident == Lexer::idPool("assembly")) + { + } +#endif // TARGET_NET + else if (global.params.ignoreUnsupportedPragmas) + { + if (global.params.verbose) + { + /* Print unrecognized pragmas + */ + printf("pragma %s", ident->toChars()); + if (args) + { + for (size_t i = 0; i < args->dim; i++) + { + Expression *e = args->tdata()[i]; + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + if (i == 0) + printf(" ("); + else + printf(","); + printf("%s", e->toChars()); + } + if (args->dim) + printf(")"); + } + printf("\n"); + } + goto Lnodecl; + } + else + error("unrecognized pragma(%s)", ident->toChars()); + +Ldecl: + if (decl) + { + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + s->semantic(sc); + } + } + return; + +Lnodecl: + if (decl) + { + error("pragma is missing closing ';'"); + goto Ldecl; // do them anyway, to avoid segfaults. + } +} + +int PragmaDeclaration::oneMember(Dsymbol **ps, Identifier *ident) +{ + *ps = NULL; + return TRUE; +} + +const char *PragmaDeclaration::kind() +{ + return "pragma"; +} + +void PragmaDeclaration::toObjFile(int multiobj) +{ + if (ident == Id::lib) + { + assert(args && args->dim == 1); + + Expression *e = args->tdata()[0]; + + assert(e->op == TOKstring); + + StringExp *se = (StringExp *)e; + char *name = (char *)mem.malloc(se->len + 1); + memcpy(name, se->string, se->len); + name[se->len] = 0; +#if OMFOBJ + /* The OMF format allows library names to be inserted + * into the object file. The linker will then automatically + * search that library, too. + */ + obj_includelib(name); +#elif ELFOBJ || MACHOBJ + /* The format does not allow embedded library names, + * so instead append the library name to the list to be passed + * to the linker. + */ + global.params.libfiles->push(name); +#else + error("pragma lib not supported"); +#endif + } +#if DMDV2 + else if (ident == Id::startaddress) + { + assert(args && args->dim == 1); + Expression *e = args->tdata()[0]; + Dsymbol *sa = getDsymbol(e); + FuncDeclaration *f = sa->isFuncDeclaration(); + assert(f); + Symbol *s = f->toSymbol(); + obj_startaddress(s); + } +#endif + AttribDeclaration::toObjFile(multiobj); +} + +void PragmaDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("pragma (%s", ident->toChars()); + if (args && args->dim) + { + buf->writestring(", "); + argsToCBuffer(buf, args, hgs); + } + buf->writeByte(')'); + AttribDeclaration::toCBuffer(buf, hgs); +} + + +/********************************* ConditionalDeclaration ****************************/ + +ConditionalDeclaration::ConditionalDeclaration(Condition *condition, Dsymbols *decl, Dsymbols *elsedecl) + : AttribDeclaration(decl) +{ + //printf("ConditionalDeclaration::ConditionalDeclaration()\n"); + this->condition = condition; + this->elsedecl = elsedecl; +} + +Dsymbol *ConditionalDeclaration::syntaxCopy(Dsymbol *s) +{ + ConditionalDeclaration *dd; + + assert(!s); + dd = new ConditionalDeclaration(condition->syntaxCopy(), + Dsymbol::arraySyntaxCopy(decl), + Dsymbol::arraySyntaxCopy(elsedecl)); + return dd; +} + + +int ConditionalDeclaration::oneMember(Dsymbol **ps, Identifier *ident) +{ + //printf("ConditionalDeclaration::oneMember(), inc = %d\n", condition->inc); + if (condition->inc) + { + Dsymbols *d = condition->include(NULL, NULL) ? decl : elsedecl; + return Dsymbol::oneMembers(d, ps, ident); + } + *ps = NULL; + return TRUE; +} + +void ConditionalDeclaration::emitComment(Scope *sc) +{ + //printf("ConditionalDeclaration::emitComment(sc = %p)\n", sc); + if (condition->inc) + { + AttribDeclaration::emitComment(sc); + } + else if (sc->docbuf) + { + /* If generating doc comment, be careful because if we're inside + * a template, then include(NULL, NULL) will fail. + */ + Dsymbols *d = decl ? decl : elsedecl; + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + s->emitComment(sc); + } + } +} + +// Decide if 'then' or 'else' code should be included + +Dsymbols *ConditionalDeclaration::include(Scope *sc, ScopeDsymbol *sd) +{ + //printf("ConditionalDeclaration::include()\n"); + assert(condition); + return condition->include(sc, sd) ? decl : elsedecl; +} + +void ConditionalDeclaration::setScope(Scope *sc) +{ + Dsymbols *d = include(sc, NULL); + + //printf("\tConditionalDeclaration::setScope '%s', d = %p\n",toChars(), d); + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { + Dsymbol *s = d->tdata()[i]; + + s->setScope(sc); + } + } +} + +void ConditionalDeclaration::importAll(Scope *sc) +{ + Dsymbols *d = include(sc, NULL); + + //printf("\tConditionalDeclaration::importAll '%s', d = %p\n",toChars(), d); + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { + Dsymbol *s = d->tdata()[i]; + + s->importAll(sc); + } + } +} + +void ConditionalDeclaration::addComment(unsigned char *comment) +{ + /* Because addComment is called by the parser, if we called + * include() it would define a version before it was used. + * But it's no problem to drill down to both decl and elsedecl, + * so that's the workaround. + */ + + if (comment) + { + Dsymbols *d = decl; + + for (int j = 0; j < 2; j++) + { + if (d) + { + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s; + + s = d->tdata()[i]; + //printf("ConditionalDeclaration::addComment %s\n", s->toChars()); + s->addComment(comment); + } + } + d = elsedecl; + } + } +} + +void ConditionalDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + condition->toCBuffer(buf, hgs); + if (decl || elsedecl) + { + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + if (decl) + { + for (unsigned i = 0; i < decl->dim; i++) + { + Dsymbol *s = decl->tdata()[i]; + + buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + } + buf->writeByte('}'); + if (elsedecl) + { + buf->writenl(); + buf->writestring("else"); + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (unsigned i = 0; i < elsedecl->dim; i++) + { + Dsymbol *s = elsedecl->tdata()[i]; + + buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + buf->writeByte('}'); + } + } + else + buf->writeByte(':'); + buf->writenl(); +} + +/***************************** StaticIfDeclaration ****************************/ + +StaticIfDeclaration::StaticIfDeclaration(Condition *condition, + Dsymbols *decl, Dsymbols *elsedecl) + : ConditionalDeclaration(condition, decl, elsedecl) +{ + //printf("StaticIfDeclaration::StaticIfDeclaration()\n"); + sd = NULL; + addisdone = 0; +} + + +Dsymbol *StaticIfDeclaration::syntaxCopy(Dsymbol *s) +{ + StaticIfDeclaration *dd; + + assert(!s); + dd = new StaticIfDeclaration(condition->syntaxCopy(), + Dsymbol::arraySyntaxCopy(decl), + Dsymbol::arraySyntaxCopy(elsedecl)); + return dd; +} + + +int StaticIfDeclaration::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + //printf("StaticIfDeclaration::addMember() '%s'\n",toChars()); + /* This is deferred until semantic(), so that + * expressions in the condition can refer to declarations + * in the same scope, such as: + * + * template Foo(int i) + * { + * const int j = i + 1; + * static if (j == 3) + * const int k; + * } + */ + this->sd = sd; + int m = 0; + + if (memnum == 0) + { m = AttribDeclaration::addMember(sc, sd, memnum); + addisdone = 1; + } + return m; +} + + +void StaticIfDeclaration::importAll(Scope *sc) +{ + // do not evaluate condition before semantic pass +} + +void StaticIfDeclaration::setScope(Scope *sc) +{ + // do not evaluate condition before semantic pass +} + +void StaticIfDeclaration::semantic(Scope *sc) +{ + Dsymbols *d = include(sc, sd); + + //printf("\tStaticIfDeclaration::semantic '%s', d = %p\n",toChars(), d); + if (d) + { + if (!addisdone) + { AttribDeclaration::addMember(sc, sd, 1); + addisdone = 1; + } + + for (unsigned i = 0; i < d->dim; i++) + { + Dsymbol *s = d->tdata()[i]; + + s->semantic(sc); + } + } +} + +const char *StaticIfDeclaration::kind() +{ + return "static if"; +} + + +/***************************** CompileDeclaration *****************************/ + +CompileDeclaration::CompileDeclaration(Loc loc, Expression *exp) + : AttribDeclaration(NULL) +{ + //printf("CompileDeclaration(loc = %d)\n", loc.linnum); + this->loc = loc; + this->exp = exp; + this->sd = NULL; + this->compiled = 0; +} + +Dsymbol *CompileDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("CompileDeclaration::syntaxCopy('%s')\n", toChars()); + CompileDeclaration *sc = new CompileDeclaration(loc, exp->syntaxCopy()); + return sc; +} + +int CompileDeclaration::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + //printf("CompileDeclaration::addMember(sc = %p, sd = %p, memnum = %d)\n", sc, sd, memnum); + this->sd = sd; + if (memnum == 0) + { /* No members yet, so parse the mixin now + */ + compileIt(sc); + memnum |= AttribDeclaration::addMember(sc, sd, memnum); + compiled = 1; + } + return memnum; +} + +void CompileDeclaration::compileIt(Scope *sc) +{ + //printf("CompileDeclaration::compileIt(loc = %d) %s\n", loc.linnum, exp->toChars()); + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + exp = exp->optimize(WANTvalue | WANTinterpret); + StringExp *se = exp->toString(); + if (!se) + { exp->error("argument to mixin must be a string, not (%s)", exp->toChars()); + } + else + { + se = se->toUTF8(sc); + Parser p(sc->module, (unsigned char *)se->string, se->len, 0); + p.loc = loc; + p.nextToken(); + decl = p.parseDeclDefs(0); + if (p.token.value != TOKeof) + exp->error("incomplete mixin declaration (%s)", se->toChars()); + } +} + +void CompileDeclaration::semantic(Scope *sc) +{ + //printf("CompileDeclaration::semantic()\n"); + + if (!compiled) + { + compileIt(sc); + AttribDeclaration::addMember(sc, sd, 0); + compiled = 1; + } + AttribDeclaration::semantic(sc); +} + +void CompileDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("mixin("); + exp->toCBuffer(buf, hgs); + buf->writestring(");"); + buf->writenl(); +} diff --git a/attrib.h b/attrib.h new file mode 100644 index 00000000..ab04c075 --- /dev/null +++ b/attrib.h @@ -0,0 +1,189 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_ATTRIB_H +#define DMD_ATTRIB_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "dsymbol.h" + +struct Expression; +struct Statement; +struct LabelDsymbol; +struct Initializer; +struct Module; +struct Condition; +struct HdrGenState; + +/**************************************************************/ + +struct AttribDeclaration : Dsymbol +{ + Dsymbols *decl; // array of Dsymbol's + + AttribDeclaration(Dsymbols *decl); + virtual Dsymbols *include(Scope *sc, ScopeDsymbol *s); + int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + void setScopeNewSc(Scope *sc, + StorageClass newstc, enum LINK linkage, enum PROT protection, int explictProtection, + unsigned structalign); + void semanticNewSc(Scope *sc, + StorageClass newstc, enum LINK linkage, enum PROT protection, int explictProtection, + unsigned structalign); + void semantic(Scope *sc); + void semantic2(Scope *sc); + void semantic3(Scope *sc); + void inlineScan(); + void addComment(unsigned char *comment); + void emitComment(Scope *sc); + const char *kind(); + int oneMember(Dsymbol **ps, Identifier *ident); + int hasPointers(); + bool hasStaticCtorOrDtor(); + void checkCtorConstInit(); + void addLocalClass(ClassDeclarations *); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toJsonBuffer(OutBuffer *buf); + AttribDeclaration *isAttribDeclaration() { return this; } + + void toObjFile(int multiobj); // compile to .obj file + int cvMember(unsigned char *p); +}; + +struct StorageClassDeclaration: AttribDeclaration +{ + StorageClass stc; + + StorageClassDeclaration(StorageClass stc, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void setScope(Scope *sc); + void semantic(Scope *sc); + int oneMember(Dsymbol **ps, Identifier *ident); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + static void stcToCBuffer(OutBuffer *buf, StorageClass stc); +}; + +struct LinkDeclaration : AttribDeclaration +{ + enum LINK linkage; + + LinkDeclaration(enum LINK p, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void setScope(Scope *sc); + void semantic(Scope *sc); + void semantic3(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + char *toChars(); +}; + +struct ProtDeclaration : AttribDeclaration +{ + enum PROT protection; + + ProtDeclaration(enum PROT p, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void importAll(Scope *sc); + void setScope(Scope *sc); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + static void protectionToCBuffer(OutBuffer *buf, enum PROT protection); +}; + +struct AlignDeclaration : AttribDeclaration +{ + unsigned salign; + + AlignDeclaration(unsigned sa, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void setScope(Scope *sc); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct AnonDeclaration : AttribDeclaration +{ + int isunion; + int sem; // 1 if successful semantic() + + AnonDeclaration(Loc loc, int isunion, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); +}; + +struct PragmaDeclaration : AttribDeclaration +{ + Expressions *args; // array of Expression's + + PragmaDeclaration(Loc loc, Identifier *ident, Expressions *args, Dsymbols *decl); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + void setScope(Scope *sc); + int oneMember(Dsymbol **ps, Identifier *ident); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); + void toObjFile(int multiobj); // compile to .obj file +}; + +struct ConditionalDeclaration : AttribDeclaration +{ + Condition *condition; + Dsymbols *elsedecl; // array of Dsymbol's for else block + + ConditionalDeclaration(Condition *condition, Dsymbols *decl, Dsymbols *elsedecl); + Dsymbol *syntaxCopy(Dsymbol *s); + int oneMember(Dsymbol **ps, Identifier *ident); + void emitComment(Scope *sc); + Dsymbols *include(Scope *sc, ScopeDsymbol *s); + void addComment(unsigned char *comment); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toJsonBuffer(OutBuffer *buf); + void importAll(Scope *sc); + void setScope(Scope *sc); +}; + +struct StaticIfDeclaration : ConditionalDeclaration +{ + ScopeDsymbol *sd; + int addisdone; + + StaticIfDeclaration(Condition *condition, Dsymbols *decl, Dsymbols *elsedecl); + Dsymbol *syntaxCopy(Dsymbol *s); + int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + void semantic(Scope *sc); + void importAll(Scope *sc); + void setScope(Scope *sc); + const char *kind(); +}; + +// Mixin declarations + +struct CompileDeclaration : AttribDeclaration +{ + Expression *exp; + + ScopeDsymbol *sd; + int compiled; + + CompileDeclaration(Loc loc, Expression *exp); + Dsymbol *syntaxCopy(Dsymbol *s); + int addMember(Scope *sc, ScopeDsymbol *sd, int memnum); + void compileIt(Scope *sc); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +#endif /* DMD_ATTRIB_H */ diff --git a/backend/aa.c b/backend/aa.c new file mode 100644 index 00000000..a6d3d38a --- /dev/null +++ b/backend/aa.c @@ -0,0 +1,498 @@ + +// Copyright (c) 2000-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#include +#include +#include +#include + +#include "tinfo.h" +#include "aa.h" + +// Implementation of associative array +// Auto-rehash and pre-allocate - Dave Fladebo + +static unsigned long prime_list[] = +{ + 97UL, 389UL, + 1543UL, 6151UL, + 24593UL, 98317UL, + 393241UL, 1572869UL, + 6291469UL, 25165843UL, + 100663319UL, 402653189UL, + 1610612741UL, 4294967291UL +}; + + +/********************************** + * Align to next pointer boundary, so value + * will be aligned. + */ + +size_t aligntsize(size_t tsize) +{ + // Is pointer alignment on the x64 4 bytes or 8? + return (tsize + sizeof(size_t) - 1) & ~(sizeof(size_t) - 1); +} + +/********************************** + * Constructor. + */ + +AArray::AArray(TypeInfo *keyti, size_t valuesize) +{ + this->keyti = keyti; + this->valuesize = valuesize; + this->nodes = 0; + this->buckets = NULL; + this->buckets_length = 0; +} + + +/********************************** + * Destructor. + */ + +void delnodes(aaA* e) +{ aaA* en; + + do + { + if (e->left) + { if (!e->right) + { en = e; + e = e->left; + delete en; + continue; + } + delnodes(e->left); + } + en = e; + e = e->right; + delete en; + } while (e != NULL); +} + +AArray::~AArray() +{ + if (buckets) + { + for (size_t i = 0; i < buckets_length; i++) + { aaA* e = buckets[i]; + + if (e) + delnodes(e); // recursively free all nodes + } + delete [] buckets; + } +} + + +/************************************************* + * Get pointer to value in associative array indexed by key. + * Add entry for key if it is not already there. + */ + +void* AArray::get(void *pkey) +{ + //printf("AArray::get()\n"); + size_t i; + aaA* e; + size_t keysize = aligntsize(keyti->tsize()); + + if (!buckets_length) + { + typedef aaA* aaAp; + buckets_length = prime_list[0]; + buckets = new aaAp[buckets_length]; + memset(buckets, 0, buckets_length * sizeof(buckets[0])); + } + + hash_t key_hash = keyti->getHash(pkey); + i = key_hash % buckets_length; + //printf("key_hash = %x, buckets_length = %d, i = %d\n", key_hash, buckets_length, i); + aaA** pe = &buckets[i]; + while ((e = *pe) != NULL) + { int c; + + c = key_hash - e->hash; + if (c == 0) + { + c = keyti->compare(pkey, e + 1); + if (c == 0) + goto Lret; + } + + if (c < 0) + pe = &e->left; + else + pe = &e->right; + } + + // Not found, create new elem + //printf("create new one\n"); + e = (aaA *) new char[sizeof(aaA) + keysize + valuesize]; + memcpy(e + 1, pkey, keysize); + memset((unsigned char *)(e + 1) + keysize, 0, valuesize); + e->hash = key_hash; + e->left = NULL; + e->right = NULL; + *pe = e; + + ++nodes; + //printf("length = %d, nodes = %d\n", buckets_length, nodes); + if (nodes > buckets_length * 4) + { + //printf("rehash()\n"); + rehash(); + } + +Lret: + return (void *)((char *)(e + 1) + keysize); +} + + +/************************************************* + * Determine if key is in aa. + * Returns: + * NULL not in aa + * !=NULL in aa, return pointer to value + */ + +void* AArray::in(void *pkey) +{ + //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr); + size_t len = buckets_length; + + if (len) + { + hash_t key_hash = keyti->getHash(pkey); + //printf("hash = %d\n", key_hash); + size_t i = key_hash % len; + aaA *e = buckets[i]; + while (e != NULL) + { int c; + + c = key_hash - e->hash; + if (c == 0) + { + c = keyti->compare(pkey, e + 1); + if (c == 0) + return (char *)(e + 1) + aligntsize(keyti->tsize()); + } + + if (c < 0) + e = e->left; + else + e = e->right; + } + } + + // Not found + return NULL; +} + + +/************************************************* + * Delete key entry in aa[]. + * If key is not in aa[], do nothing. + */ + +void AArray::del(void *pkey) +{ + aaA* e; + + if (buckets_length) + { + hash_t key_hash = keyti->getHash(pkey); + //printf("hash = %d\n", key_hash); + size_t i = key_hash % buckets_length; + aaA** pe = &buckets[i]; + while ((e = *pe) != NULL) // NULL means not found + { int c; + + c = key_hash - e->hash; + if (c == 0) + { + c = keyti->compare(pkey, e + 1); + if (c == 0) + { + if (!e->left && !e->right) + { + *pe = NULL; + } + else if (e->left && !e->right) + { + *pe = e->left; + e->left = NULL; + } + else if (!e->left && e->right) + { + *pe = e->right; + e->right = NULL; + } + else + { + *pe = e->left; + e->left = NULL; + do + pe = &(*pe)->right; + while (*pe); + *pe = e->right; + e->right = NULL; + } + + nodes--; + + delete[] e; + break; + } + } + + if (c < 0) + pe = &e->left; + else + pe = &e->right; + } + } +} + + +/******************************************** + * Produce array of keys from aa. + */ + +void *AArray::keys() +{ + void *p = NULL; + + if (nodes) + { + size_t keysize = keyti->tsize(); + + typedef char* charp; + p = (void *)new charp[nodes * keysize]; + void *q = p; + for (size_t i = 0; i < buckets_length; i++) + { aaA* e = buckets[i]; + + if (e) + q = keys_x(e, q, keysize); + } + } + return p; +} + +void *AArray::keys_x(aaA* e, void *p, size_t keysize) +{ + do + { + memcpy(p, e + 1, keysize); + if (e->left) + { if (!e->right) + { e = e->left; + continue; + } + p = keys_x(e->left, p, keysize); + } + e = e->right; + } while (e != NULL); + return p; +} + +/******************************************** + * Produce array of values from aa. + */ + +void *AArray::values() +{ + void *p = NULL; + + if (nodes) + { + p = (void *)new char[nodes * valuesize]; + void *q = p; + for (size_t i = 0; i < buckets_length; i++) + { aaA *e = buckets[i]; + + if (e) + q = values_x(e, q); + } + } + return p; +} + +void *AArray::values_x(aaA *e, void *p) +{ + size_t keysize = keyti->tsize(); + do + { + memcpy(p, + (char *)(e + 1) + keysize, + valuesize); + p = (void *)((char *)p + valuesize); + if (e->left) + { if (!e->right) + { e = e->left; + continue; + } + p = values_x(e->left, p); + } + e = e->right; + } while (e != NULL); + return p; +} + + +/******************************************** + * Rehash an array. + */ + +void AArray::rehash() +{ + //printf("Rehash\n"); + if (buckets_length) + { + size_t len = nodes; + + if (len) + { size_t i; + aaA** newbuckets; + size_t newbuckets_length; + + for (i = 0; i < sizeof(prime_list)/sizeof(prime_list[0]) - 1; i++) + { + if (len <= prime_list[i]) + break; + } + newbuckets_length = prime_list[i]; + typedef aaA* aaAp; + newbuckets = new aaAp[newbuckets_length]; + memset(newbuckets, 0, newbuckets_length * sizeof(newbuckets[0])); + + for (i = 0; i < buckets_length; i++) + { aaA *e = buckets[i]; + + if (e) + rehash_x(e, newbuckets, newbuckets_length); + } + + delete[] buckets; + buckets = newbuckets; + buckets_length = newbuckets_length; + } + } +} + +void AArray::rehash_x(aaA* olde, aaA** newbuckets, size_t newbuckets_length) +{ + while (1) + { + aaA* left = olde->left; + aaA* right = olde->right; + olde->left = NULL; + olde->right = NULL; + + aaA* e; + + //printf("rehash %p\n", olde); + hash_t key_hash = olde->hash; + size_t i = key_hash % newbuckets_length; + aaA** pe = &newbuckets[i]; + while ((e = *pe) != NULL) + { int c; + + //printf("\te = %p, e->left = %p, e->right = %p\n", e, e->left, e->right); + assert(e->left != e); + assert(e->right != e); + c = key_hash - e->hash; + if (c == 0) + c = keyti->compare(olde + 1, e + 1); + if (c < 0) + pe = &e->left; + else if (c > 0) + pe = &e->right; + else + assert(0); + } + *pe = olde; + + if (right) + { + if (!left) + { olde = right; + continue; + } + rehash_x(right, newbuckets, newbuckets_length); + } + if (!left) + break; + olde = left; + } +} + + +/********************************************* + * For each element in the AArray, + * call dg(void *parameter, void *pkey, void *pvalue) + * If dg returns !=0, stop and return that value. + */ + +typedef int (*dg2_t)(void *, void *, void *); + +int AArray::apply(void *parameter, dg2_t dg) +{ int result = 0; + + //printf("_aaApply(aa = %p, keysize = %d, dg = %p)\n", this, keyti->tsize(), dg); + + if (nodes) + { + size_t keysize = aligntsize(keyti->tsize()); + + for (size_t i = 0; i < buckets_length; i++) + { aaA* e = buckets[i]; + + if (e) + { + result = apply_x(e, dg, keysize, parameter); + if (result) + break; + } + } + } + return result; +} + +int AArray::apply_x(aaA* e, dg2_t dg, size_t keysize, void *parameter) +{ int result; + + do + { + //printf("apply_x(e = %p, dg = %p)\n", e, dg); + result = (*dg)(parameter, e + 1, (char *)(e + 1) + keysize); + if (result) + break; + if (e->right) + { if (!e->left) + { + e = e->right; + continue; + } + result = apply_x(e->right, dg, keysize, parameter); + if (result) + break; + } + e = e->left; + } while (e); + + return result; +} + + diff --git a/backend/aa.h b/backend/aa.h new file mode 100644 index 00000000..d628fb9e --- /dev/null +++ b/backend/aa.h @@ -0,0 +1,109 @@ + +// Copyright (c) 2006-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + + +#ifndef AA_H +#define AA_H + +#include + +#include "tinfo.h" + +struct aaA +{ + aaA *left; + aaA *right; + hash_t hash; + /* key */ + /* value */ +}; + +struct AArray +{ + TypeInfo *keyti; + size_t valuesize; + size_t nodes; + + aaA** buckets; + size_t buckets_length; + + AArray(TypeInfo *keyti, size_t valuesize); + + ~AArray(); + + size_t length() + { + return nodes; + } + + /************************************************* + * Get pointer to value in associative array indexed by key. + * Add entry for key if it is not already there. + */ + + void* get(void *pkey); + + void* get(char *string) { return get(&string); } + + /************************************************* + * Determine if key is in aa. + * Returns: + * null not in aa + * !=null in aa, return pointer to value + */ + + void* in(void *pkey); + + void* in(char *string) { return in(&string); } + + /************************************************* + * Delete key entry in aa[]. + * If key is not in aa[], do nothing. + */ + + void del(void *pkey); + + /******************************************** + * Produce array of keys from aa. + */ + + void *keys(); + + /******************************************** + * Produce array of values from aa. + */ + + void *values(); + + /******************************************** + * Rehash an array. + */ + + void rehash(); + + /********************************************* + * For each element in the AArray, + * call dg(void *parameter, void *pkey, void *pvalue) + * If dg returns !=0, stop and return that value. + */ + + typedef int (*dg2_t)(void *, void *, void *); + + int apply(void *parameter, dg2_t dg); + + private: + void *keys_x(aaA* e, void *p, size_t keysize); + void *values_x(aaA *e, void *p); + void rehash_x(aaA* olde, aaA** newbuckets, size_t newbuckets_length); + int apply_x(aaA* e, dg2_t dg, size_t keysize, void *parameter); +}; + +#endif + diff --git a/backend/backend.txt b/backend/backend.txt new file mode 100644 index 00000000..3956a63d --- /dev/null +++ b/backend/backend.txt @@ -0,0 +1,80 @@ +Files in the Back End +===================== + +aa.c simple hash table +aa.h header for simple hash table +bcomplex.c our own complex number implementation because we can't rely on host C compiler +bcomplex.h header for our own complex numbers +blockopt.c manage and simple optimizations on graphs of basic blocks +cc.h main header file for back end +cdef.h configuration +cdeflnx.h configuration for linux +cg.c global variables for code generator +cg87.c x87 FPU code generation +cgcod.c main loop for code generator +cgcs.c compute common subexpressions for non-optimized code generation +cgcv.c CodeView symbol debug info generation +cgcv.h header for cgcv.c +cgelem.c local optimizations of elem trees +cgen.c generate/manage linked list of code instructions +cgobj.c generate OMF object files +cgreg.c register allocator +cgsched.c instruction scheduler +cod1.c code gen +cod2.c code gen +cod3.c code gen +cod4.c code gen +cod5.c code gen +code.c memory management for code instructions +code.h define registers, register masks, and the CPU instruction linked list +cppman.c C++ name mangling +cv4.h CodeView symbolic debug info declarations +debug.c pretty printing for debug builds +dt.c static data for later output to object file +dt.h API for dt.c +dwarf.c generate DWARF symbolic debug info +dwarf.h API for dwarf.c +dwarf2.h Dwarf 3 spec declarations +ee.c handle IDDE debugger expression evaluation +el.c expression trees (intermediate code) +el.h header for el.c +elfobj.c generate ELF object files +evalu8.c constant folding +exh.h exception handling support +gdag.c Directed acyclic graphs and global optimizer common subexpressions +gflow.c global data flow analysis +global.h declarations for back end +glocal.c global optimizations +gloop.c global loop optimizations +go.c global optimizer main loop +go.h global optimizer declarations +gother.c other global optimizations +html.c support for embedding source code in html +html.h header for html.c +iasm.h declarations for inline assembler +mach.h declarations for Mach-O object file format +machobj.c generate Mach-O object files +md5.c implementation of MD5 message digest +md5.h API for md5.c +melf.h declarations for ELF file format +newman.c "new" C++ name mangling scheme +nteh.c Windows structured exception handling support +oper.h operators for expression tree +optabgen.c generate tables for back end +os.c some operating system specific support +out.c write data definitions to object file +outbuf.c resizeable buffer +outbuf.h API for resizeable buffer +ptrntab.c instruction tables for inline assembler +rtlsym.c initialize for compiler 'helper' runtime functions +rtlsym.h compiler 'helper' runtime functions +strtold.c our own version of strtold() because we cannot rely on C's +symbol.c symbols for the back end +tassert.h our own assert macro (to reduce code size) +tinfo.h specialization of hash table aa.c +ti_achar.c specialization of hash tables for array of chars +token.h C/C++ tokens +ty.h type masks +type.c back end type +type.h header for type.c +var.c global variables diff --git a/backend/bcomplex.c b/backend/bcomplex.c new file mode 100644 index 00000000..ec31a93d --- /dev/null +++ b/backend/bcomplex.c @@ -0,0 +1,292 @@ +// public domain + +#include + +#include "bcomplex.h" + +/*********************************************************/ + +Complex_ld Complex_ld::div(Complex_ld &x, Complex_ld &y) +{ + Complex_ld q; + long double r; + long double den; + + if (fabs(y.re) < fabs(y.im)) + { + r = y.re / y.im; + den = y.im + r * y.re; + q.re = (x.re * r + x.im) / den; + q.im = (x.im * r - x.re) / den; + } + else + { + r = y.im / y.re; + den = y.re + r * y.im; + q.re = (x.re + r * x.im) / den; + q.im = (x.im - r * x.re) / den; + } + return q; +} + +Complex_ld Complex_ld::mul(Complex_ld &x, Complex_ld &y) +{ + Complex_ld p; + + p.re = x.re * y.re - x.im * y.im; + p.im = x.im * y.re + x.re * y.im; + return p; +} + +long double Complex_ld::abs(Complex_ld &z) +{ + long double x,y,ans,temp; + + x = fabs(z.re); + y = fabs(z.im); + if (x == 0) + ans = y; + else if (y == 0) + ans = x; + else if (x > y) + { + temp = y / x; + ans = x * sqrt(1 + temp * temp); + } + else + { + temp = x / y; + ans = y * sqrt(1 + temp * temp); + } + return ans; +} + +Complex_ld Complex_ld::sqrtc(Complex_ld &z) +{ + Complex_ld c; + long double x,y,w,r; + + if (z.re == 0 && z.im == 0) + { + c.re = 0; + c.im = 0; + } + else + { + x = fabs(z.re); + y = fabs(z.im); + if (x >= y) + { + r = y / x; + w = sqrt(x) * sqrt(0.5 * (1 + sqrt(1 + r * r))); + } + else + { + r = x / y; + w = sqrt(y) * sqrt(0.5 * (r + sqrt(1 + r * r))); + } + if (z.re >= 0) + { + c.re = w; + c.im = z.im / (w + w); + } + else + { + c.im = (z.im >= 0) ? w : -w; + c.re = z.im / (c.im + c.im); + } + } + return c; +} + +/*********************************************************/ + +Complex_d Complex_d::div(Complex_d &x, Complex_d &y) +{ + Complex_d q; + long double r; + long double den; + + if (fabs(y.re) < fabs(y.im)) + { + r = y.re / y.im; + den = y.im + r * y.re; + q.re = (x.re * r + x.im) / den; + q.im = (x.im * r - x.re) / den; + } + else + { + r = y.im / y.re; + den = y.re + r * y.im; + q.re = (x.re + r * x.im) / den; + q.im = (x.im - r * x.re) / den; + } + return q; +} + +Complex_d Complex_d::mul(Complex_d &x, Complex_d &y) +{ + Complex_d p; + + p.re = x.re * y.re - x.im * y.im; + p.im = x.im * y.re + x.re * y.im; + return p; +} + +long double Complex_d::abs(Complex_d &z) +{ + long double x,y,ans,temp; + + x = fabs(z.re); + y = fabs(z.im); + if (x == 0) + ans = y; + else if (y == 0) + ans = x; + else if (x > y) + { + temp = y / x; + ans = x * sqrt(1 + temp * temp); + } + else + { + temp = x / y; + ans = y * sqrt(1 + temp * temp); + } + return ans; +} + +Complex_d Complex_d::sqrtc(Complex_d &z) +{ + Complex_d c; + long double x,y,w,r; + + if (z.re == 0 && z.im == 0) + { + c.re = 0; + c.im = 0; + } + else + { + x = fabs(z.re); + y = fabs(z.im); + if (x >= y) + { + r = y / x; + w = sqrt(x) * sqrt(0.5 * (1 + sqrt(1 + r * r))); + } + else + { + r = x / y; + w = sqrt(y) * sqrt(0.5 * (r + sqrt(1 + r * r))); + } + if (z.re >= 0) + { + c.re = w; + c.im = z.im / (w + w); + } + else + { + c.im = (z.im >= 0) ? w : -w; + c.re = z.im / (c.im + c.im); + } + } + return c; +} + +/*********************************************************/ + +Complex_f Complex_f::div(Complex_f &x, Complex_f &y) +{ + Complex_f q; + long double r; + long double den; + + if (fabs(y.re) < fabs(y.im)) + { + r = y.re / y.im; + den = y.im + r * y.re; + q.re = (x.re * r + x.im) / den; + q.im = (x.im * r - x.re) / den; + } + else + { + r = y.im / y.re; + den = y.re + r * y.im; + q.re = (x.re + r * x.im) / den; + q.im = (x.im - r * x.re) / den; + } + return q; +} + +Complex_f Complex_f::mul(Complex_f &x, Complex_f &y) +{ + Complex_f p; + + p.re = x.re * y.re - x.im * y.im; + p.im = x.im * y.re + x.re * y.im; + return p; +} + +long double Complex_f::abs(Complex_f &z) +{ + long double x,y,ans,temp; + + x = fabs(z.re); + y = fabs(z.im); + if (x == 0) + ans = y; + else if (y == 0) + ans = x; + else if (x > y) + { + temp = y / x; + ans = x * sqrt(1 + temp * temp); + } + else + { + temp = x / y; + ans = y * sqrt(1 + temp * temp); + } + return ans; +} + +Complex_f Complex_f::sqrtc(Complex_f &z) +{ + Complex_f c; + long double x,y,w,r; + + if (z.re == 0 && z.im == 0) + { + c.re = 0; + c.im = 0; + } + else + { + x = fabs(z.re); + y = fabs(z.im); + if (x >= y) + { + r = y / x; + w = sqrt(x) * sqrt(0.5 * (1 + sqrt(1 + r * r))); + } + else + { + r = x / y; + w = sqrt(y) * sqrt(0.5 * (r + sqrt(1 + r * r))); + } + if (z.re >= 0) + { + c.re = w; + c.im = z.im / (w + w); + } + else + { + c.im = (z.im >= 0) ? w : -w; + c.re = z.im / (c.im + c.im); + } + } + return c; +} + + diff --git a/backend/bcomplex.h b/backend/bcomplex.h new file mode 100644 index 00000000..bdebb6cf --- /dev/null +++ b/backend/bcomplex.h @@ -0,0 +1,36 @@ +// public domain + +#ifndef BCOMPLEX_H +#define BCOMPLEX_H 1 + +// Avoid interfering with system and other +// such; roll our own for reliable bootstrapping + +struct Complex_f +{ float re, im; + + static Complex_f div(Complex_f &x, Complex_f &y); + static Complex_f mul(Complex_f &x, Complex_f &y); + static long double abs(Complex_f &z); + static Complex_f sqrtc(Complex_f &z); +}; + +struct Complex_d +{ double re, im; + + static Complex_d div(Complex_d &x, Complex_d &y); + static Complex_d mul(Complex_d &x, Complex_d &y); + static long double abs(Complex_d &z); + static Complex_d sqrtc(Complex_d &z); +}; + +struct Complex_ld +{ long double re, im; + + static Complex_ld div(Complex_ld &x, Complex_ld &y); + static Complex_ld mul(Complex_ld &x, Complex_ld &y); + static long double abs(Complex_ld &z); + static Complex_ld sqrtc(Complex_ld &z); +}; + +#endif diff --git a/backend/blockopt.c b/backend/blockopt.c new file mode 100644 index 00000000..320b0b26 --- /dev/null +++ b/backend/blockopt.c @@ -0,0 +1,2204 @@ +// Copyright (C) 1986-1997 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +/**************************************************************** + * Handle basic blocks. + */ + +#if !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "oper.h" +#include "el.h" +#include "type.h" +#include "global.h" +#include "go.h" +#include "code.h" +#if SCPP +#include "parser.h" +#include "iasm.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +STATIC void bropt(void); +STATIC void brrear(void); +STATIC void search(block *b); +STATIC void elimblks(void); +STATIC int mergeblks(void); +STATIC void blident(void); +STATIC void blreturn(void); +STATIC void brmin(void); +STATIC void bltailmerge(void); +STATIC void block_check(); +STATIC void brtailrecursion(); +STATIC elem * assignparams(elem **pe,int *psi,elem **pe2); +STATIC void emptyloops(); +int el_anyframeptr(elem *e); + +unsigned numblks; // number of basic blocks in current function +block *startblock; /* beginning block of function */ + /* (can have no predecessors) */ + +block **dfo = NULL; /* array of depth first order */ +unsigned dfotop; /* # of items in dfo[] */ + +block *curblock; /* current block being read in */ +block *block_last; // last block read in + +static block * block_freelist; + +//////////////////////////// +// Storage allocator. + +static block blkzero; + +__inline block *block_calloc_i() +{ block *b; + + if (block_freelist) + { b = block_freelist; + block_freelist = b->Bnext; + *b = blkzero; + } + else + b = (block *) mem_fcalloc(sizeof(block)); + return b; +} + +block *block_calloc() +{ + return block_calloc_i(); +} + +////////////////////////////////// +// + +unsigned bc_goal[BCMAX]; + +void block_init() +{ int i; + + for (i = 0; i < BCMAX; i++) + bc_goal[i] = GOALvalue; + bc_goal[BCgoto] = GOALnone; + bc_goal[BCret ] = GOALnone; + bc_goal[BCexit] = GOALnone; +} + +////////////////////////////////// +// + +void block_term() +{ +#if TERMCODE + block *b; + + while (block_freelist) + { b = block_freelist->Bnext; + mem_ffree(block_freelist); + block_freelist = b; + } + +#endif +} + +/************************** + * Finish up this block and start the next one. + */ + +#if MARS +void block_next(Blockx *bctx,enum BC bc,block *bn) +{ + bctx->curblock->BC = bc; + block_last = bctx->curblock; + if (!bn) + bn = block_calloc_i(); + bctx->curblock->Bnext = bn; // next block + bctx->curblock = bctx->curblock->Bnext; // new current block +#if NTEXCEPTIONS + bctx->curblock->Btry = bctx->tryblock; +#endif + bctx->curblock->Bflags |= bctx->flags; +} +#else +void block_next(enum BC bc,block *bn) +{ + curblock->BC = bc; + curblock->Bsymend = globsym.top; + block_last = curblock; + if (!bn) + bn = block_calloc_i(); + curblock->Bnext = bn; // next block + curblock = curblock->Bnext; // new current block + curblock->Bsymstart = globsym.top; + curblock->Btry = pstate.STbtry; +} + +void block_next() +{ + block_next((enum BC)curblock->BC,NULL); +} +#endif + +/************************** + * Finish up this block and start the next one. + */ + +#if MARS + +block *block_goto(Blockx *bx,enum BC bc,block *bn) +{ block *b; + + b = bx->curblock; + block_next(bx,bc,bn); + list_append(&b->Bsucc,bx->curblock); + return bx->curblock; +} + +#endif + +/**************************** + * Goto a block named gotolbl. + * Start a new block that is labelled by newlbl. + */ + +#if SCPP + +void block_goto() +{ + block_goto(block_calloc()); +} + +void block_goto(block *bn) +{ + block_goto(bn,bn); +} + +void block_goto(block *bgoto,block *bnew) +{ + enum BC bc; + + assert(bgoto); + list_append(&(curblock->Bsucc),bgoto); + if (curblock->Bcode) // If there is already code in the block + // then this is an ASM block + bc = BCasm; + else + bc = BCgoto; // fall thru to next block + block_next(bc,bnew); +} + +#endif + +/********************************** + * Replace block numbers with block pointers. + * Also compute numblks and maxblks. + */ + +void block_ptr() +{ block *b; + +/* dbg_printf("block_ptr()\n");*/ + + numblks = 0; + for (b = startblock; b; b = b->Bnext) /* for each block */ + { +#if SCPP + b->Bblknum = numblks; +#endif + numblks++; + } + maxblks = 3 * numblks; /* allow for increase in # of blocks */ +} + +/******************************* + * Build predecessor list (Bpred) for each block. + */ + +void block_pred() +{ block *b; + + //dbg_printf("block_pred()\n"); + for (b = startblock; b; b = b->Bnext) /* for each block */ + list_free(&b->Bpred,FPNULL); + + for (b = startblock; b; b = b->Bnext) /* for each block */ + { register list_t bp; + + //printf("b = %p, BC = ",b); WRBC(b->BC); printf("\n"); + for (bp = b->Bsucc; bp; bp = list_next(bp)) + { /* for each successor to b */ + //printf("\tbs = %p\n",list_block(bp)); + assert(list_block(bp)); + list_prepend(&(list_block(bp)->Bpred),b); + } + } + assert(startblock->Bpred == NULL); /* startblock has no preds */ +} + +/******************************************** + * Clear visit. + */ + +void block_clearvisit() +{ block *b; + + for (b = startblock; b; b = b->Bnext) // for each block + b->Bflags &= ~BFLvisited; // mark as unvisited +} + +/******************************************** + * Visit block and each of its predecessors. + */ + +void block_visit(block *b) +{ list_t l; + + b->Bflags |= BFLvisited; + for (l = b->Bsucc; l; l = list_next(l)) // for each successor + { block *bs = list_block(l); + assert(bs); + if ((bs->Bflags & BFLvisited) == 0) // if not visited + block_visit(bs); + } +} + +/***************************** + * Compute number of parents (Bcount) of each basic block. + */ + +void block_compbcount() +{ + block_clearvisit(); + block_visit(startblock); // visit all reachable blocks + elimblks(); // eliminate unvisited blocks +} + +/******************************* + * Free list of blocks. + */ + +void blocklist_free(block **pb) +{ block *b,*bn; + + for (b = *pb; b; b = bn) + { bn = b->Bnext; + block_free(b); + } + *pb = NULL; +} + +/******************************** + * Free optimizer gathered data. + */ + +void block_optimizer_free(block *b) +{ + vec_free(b->Bdom); + vec_free(b->Binrd); + vec_free(b->Boutrd); + vec_free(b->Binlv); + vec_free(b->Boutlv); + vec_free(b->Bin); + vec_free(b->Bout); + vec_free(b->Bgen); + vec_free(b->Bkill); + vec_free(b->Bout2); + vec_free(b->Bgen2); + vec_free(b->Bkill2); + + memset(&b->_BLU,0,sizeof(b->_BLU)); +} + +/**************************** + * Free a block. + */ + +void block_free(block *b) +{ + assert(b); + if (b->Belem) + el_free(b->Belem); + list_free(&b->Bsucc,FPNULL); + list_free(&b->Bpred,FPNULL); + if (OPTIMIZER) + block_optimizer_free(b); + switch (b->BC) + { case BCswitch: + case BCifthen: + case BCjmptab: +#if MARS + free(b->BS.Bswitch); +#else + MEM_PH_FREE(b->BS.Bswitch); +#endif + break; +#if SCPP + case BCcatch: + type_free(b->Bcatchtype); + break; +#endif + case BCasm: + code_free(b->Bcode); + break; + } + b->Bnext = block_freelist; + block_freelist = b; +} + +/**************************** + * Hydrate/dehydrate a list of blocks. + */ + +#if HYDRATE +void blocklist_hydrate(block **pb) +{ block *b; + + while (isdehydrated(*pb)) + { + /*dbg_printf("blocklist_hydrate(*pb = %p) =",*pb);*/ + b = (block *)ph_hydrate(pb); + /*dbg_printf(" %p\n",b);*/ + el_hydrate(&b->Belem); + list_hydrate(&b->Bsucc,FPNULL); + list_hydrate(&b->Bpred,FPNULL); + (void) ph_hydrate(&b->Btry); +#if SCPP + (void) ph_hydrate(&b->Bendscope); + symbol_hydrate(&b->Binitvar); +#endif + switch (b->BC) + { +#if SCPP + case BCtry: + symbol_hydrate(&b->catchvar); + break; + case BCcatch: + type_hydrate(&b->Bcatchtype); + break; +#endif + case BCswitch: + (void) ph_hydrate(&b->BS.Bswitch); + break; + + case BC_finally: + //(void) ph_hydrate(&b->B_ret); + break; + + case BCasm: + code_hydrate(&b->Bcode); + break; + } +#if TX86 + filename_translate(&b->Bsrcpos); + srcpos_hydrate(&b->Bsrcpos); +#endif + pb = &b->Bnext; + } +} +#endif + +#if DEHYDRATE +void blocklist_dehydrate(block **pb) +{ block *b; + + while ((b = *pb) != NULL && !isdehydrated(b)) + { +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(b)) + return; +#endif + /*dbg_printf("blocklist_dehydrate(*pb = %p) =",b);*/ + ph_dehydrate(pb); + /*dbg_printf(" %p\n",*pb);*/ + el_dehydrate(&b->Belem); + list_dehydrate(&b->Bsucc,FPNULL); + list_dehydrate(&b->Bpred,FPNULL); + ph_dehydrate(&b->Btry); +#if SCPP + ph_dehydrate(&b->Bendscope); + symbol_dehydrate(&b->Binitvar); +#endif + switch (b->BC) + { +#if SCPP + case BCtry: + symbol_dehydrate(&b->catchvar); + break; + case BCcatch: + type_dehydrate(&b->Bcatchtype); + break; +#endif + case BCswitch: + ph_dehydrate(&b->BS.Bswitch); + break; + + case BC_finally: + //ph_dehydrate(&b->B_ret); + break; + + case BCasm: + code_dehydrate(&b->Bcode); + break; + } +#if TX86 + srcpos_dehydrate(&b->Bsrcpos); +#endif + pb = &b->Bnext; + } +} +#endif + +/**************************** + * Append elem to the elems comprising the current block. + * Read in an expression and put it in curblock->Belem. + * If there is one already there, create a tree like: + * , + * / \ + * old e + */ + +void block_appendexp(block *b,elem *e) +{ elem *ec; + elem **pe; + + assert(MARS || PARSER); + if (e) + { + assert(b); + elem_debug(e); + pe = &b->Belem; + ec = *pe; + if (ec != NULL) + { + type *t = e->ET; + + if (t) + type_debug(t); + elem_debug(e); +#if MARS + tym_t ty = e->Ety; + + elem_debug(e); + /* Build tree such that (a,b) => (a,(b,e)) */ + while (ec->Eoper == OPcomma) + { + ec->Ety = ty; + ec->ET = t; + pe = &(ec->E2); + ec = *pe; + } + e = el_bin(OPcomma,ty,ec,e); + e->ET = t; +#else + /* Build tree such that (a,b) => (a,(b,e)) */ + while (ec->Eoper == OPcomma) + { + el_settype(ec,t); + pe = &(ec->E2); + ec = *pe; + } + e = el_bint(OPcomma,t,ec,e); +#endif + } + *pe = e; + } +} + +/************************ + * Mark curblock as initializing symbol s. + */ + +#if SCPP + +#undef block_initvar + +void block_initvar(symbol *s) +{ +#ifdef DEBUG + assert(curblock); +#endif + symbol_debug(s); + curblock->Binitvar = s; +} + +#endif + +/******************* + * Mark end of function. + * flag: + * 0 do a "return" + * 1 do a "return 0" + */ + +void block_endfunc(int flag) +{ +#if SCPP + curblock->Bsymend = globsym.top; + curblock->Bendscope = curblock; +#endif + if (flag) + { elem *e; + + e = el_longt(tsint, 0); + block_appendexp(curblock, e); + curblock->BC = BCretexp; // put a return at the end + } + else + curblock->BC = BCret; // put a return at the end + curblock = NULL; // undefined from now on + block_last = NULL; +} + +/****************************** + * Perform branch optimization on basic blocks. + */ + +void blockopt(int iter) +{ block *b; + int count; + + if (OPTIMIZER) + { + int iterationLimit = 200; + if (iterationLimit < numblks) + iterationLimit = numblks; + count = 0; + do + { + //printf("changes = %d, count = %d, dfotop = %d\n",changes,count,dfotop); +#if MARS + util_progress(); +#else + if (controlc_saw) + util_exit(EXIT_BREAK); +#endif + changes = 0; + bropt(); // branch optimization + brrear(); // branch rearrangement + blident(); // combine identical blocks + blreturn(); // split out return blocks + bltailmerge(); // do tail merging + brtailrecursion(); // do tail recursion + brcombine(); // convert graph to expressions + if (iter >= 2) + brmin(); // minimize branching + do + { + compdfo(); /* compute depth first order (DFO) */ + elimblks(); /* remove blocks not in DFO */ + assert(count < iterationLimit); + count++; + } while (mergeblks()); /* merge together blocks */ + } while (changes); +#ifdef DEBUG + if (debugw) + for (b = startblock; b; b = b->Bnext) + WRblock(b); +#endif + } + else + { + /* canonicalize the trees */ + for (b = startblock; b; b = b->Bnext) + { +#ifdef DEBUG + if (debugb) + WRblock(b); +#endif + if (b->Belem) + { b->Belem = doptelem(b->Belem,bc_goal[b->BC] | GOALstruct); + if (b->Belem) + b->Belem = el_convert(b->Belem); + } +#ifdef DEBUG + if (debugb) + { dbg_printf("after optelem():\n"); + WRblock(b); + } +#endif + } + if (localgot) + { // Initialize with: + // localgot = OPgot; + elem *e = el_long(TYnptr, 0); + e->Eoper = OPgot; + e = el_bin(OPeq, TYnptr, el_var(localgot), e); + startblock->Belem = el_combine(e, startblock->Belem); + } + + bropt(); /* branch optimization */ + brrear(); /* branch rearrangement */ + comsubs(); /* eliminate common subexpressions */ +#ifdef DEBUG + if (debugb) + for (b = startblock; b; b = b->Bnext) + WRblock(b); +#endif + } +} + +/*********************************** + * Try to remove control structure. + * That is, try to resolve if-else, goto and return statements + * into &&, || and ?: combinations. + */ + +void brcombine() +{ block *b; + block *b2,*b3; + int op; + int anychanges; + + cmes("brcombine()\n"); + //for (b = startblock; b; b = b->Bnext) + //WRblock(b); + + if (funcsym_p->Sfunc->Fflags3 & (Fcppeh | Fnteh)) + { // Don't mess up extra EH info by eliminating blocks + return; + } + + do + { + anychanges = 0; + for (b = startblock; b; b = b->Bnext) /* for each block */ + { unsigned char bc; + + /* Look for [e1 IFFALSE L3,L2] L2: [e2 GOTO L3] L3: [e3] */ + /* Replace with [(e1 && e2),e3] */ + bc = b->BC; + if (bc == BCiftrue) + { unsigned char bc2; + + b2 = list_block(b->Bsucc); + b3 = list_block(list_next(b->Bsucc)); + + if (list_next(b2->Bpred)) // if more than one predecessor + continue; + if (b2 == b3) + continue; + if (b2 == startblock) + continue; + if (!PARSER && b2->Belem && EOP(b2->Belem)) + continue; + + bc2 = b2->BC; + if (bc2 == BCgoto && + b3 == list_block(b2->Bsucc)) + { + b->BC = BCgoto; + if (b2->Belem) + { + op = OPandand; + b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b2->Belem) + : el_bin(op,TYint,b->Belem,b2->Belem); + b2->Belem = NULL; + } + list_subtract(&(b->Bsucc),b2); + list_subtract(&(b2->Bpred),b); + cmes("brcombine(): if !e1 then e2 => e1 || e2\n"); + anychanges++; + } + else if (list_next(b3->Bpred) || b3 == startblock) + continue; + else if ((bc2 == BCretexp && b3->BC == BCretexp) + //|| (bc2 == BCret && b3->BC == BCret) + ) + { elem *e; + + if (PARSER) + { + type *t = (bc2 == BCretexp) ? b2->Belem->ET : tsvoid; + e = el_bint(OPcolon2,t,b2->Belem,b3->Belem); + b->Belem = el_bint(OPcond,t,b->Belem,e); + } + else + { + if (EOP(b3->Belem)) + continue; + tym_t ty = (bc2 == BCretexp) ? b2->Belem->Ety : TYvoid; + e = el_bin(OPcolon2,ty,b2->Belem,b3->Belem); + b->Belem = el_bin(OPcond,ty,b->Belem,e); + } + b->BC = bc2; + b->Belem->ET = b2->Belem->ET; + b2->Belem = NULL; + b3->Belem = NULL; + list_free(&b->Bsucc,FPNULL); + list_subtract(&(b2->Bpred),b); + list_subtract(&(b3->Bpred),b); + cmes("brcombine(): if e1 return e2 else return e3 => ret e1?e2:e3\n"); + anychanges++; + } + else if (bc2 == BCgoto && + b3->BC == BCgoto && + list_block(b2->Bsucc) == list_block(b3->Bsucc)) + { elem *e; + block *bsucc; + + bsucc = list_block(b2->Bsucc); + if (b2->Belem) + { + if (PARSER) + { + if (b3->Belem) + { + e = el_bint(OPcolon2,b2->Belem->ET, + b2->Belem,b3->Belem); + e = el_bint(OPcond,e->ET,b->Belem,e); + } + else + { + op = OPandand; + e = el_bint(op,tsint,b->Belem,b2->Belem); + } + } + else + { + if (b3->Belem) + { + if (EOP(b3->Belem)) + continue; + e = el_bin(OPcolon2,b2->Belem->Ety, + b2->Belem,b3->Belem); + e = el_bin(OPcond,e->Ety,b->Belem,e); + e->ET = b2->Belem->ET; + } + else + { + op = OPandand; + e = el_bin(op,TYint,b->Belem,b2->Belem); + } + } + b2->Belem = NULL; + b->Belem = e; + } + else if (b3->Belem) + { + op = OPoror; + b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b3->Belem) + : el_bin(op,TYint,b->Belem,b3->Belem); + } + b->BC = BCgoto; + b3->Belem = NULL; + list_free(&b->Bsucc,FPNULL); + + list_append(&b->Bsucc,bsucc); + list_append(&bsucc->Bpred,b); + + list_free(&(b2->Bpred),FPNULL); + list_free(&(b2->Bsucc),FPNULL); + list_free(&(b3->Bpred),FPNULL); + list_free(&(b3->Bsucc),FPNULL); + b2->BC = BCret; + b3->BC = BCret; + list_subtract(&(bsucc->Bpred),b2); + list_subtract(&(bsucc->Bpred),b3); + cmes("brcombine(): if e1 goto e2 else goto e3 => ret e1?e2:e3\n"); + anychanges++; + } + } + else if (bc == BCgoto && PARSER) + { + b2 = list_block(b->Bsucc); + if (!list_next(b2->Bpred) && b2->BC != BCasm // if b is only parent + && b2 != startblock +#if SCPP + && b2->BC != BCtry +#endif + && b2->BC != BC_try + && b->Btry == b2->Btry + ) + { list_t bl; + + if (b2->Belem) + { + if (PARSER) + { + block_appendexp(b,b2->Belem); + } + else if (b->Belem) + b->Belem = el_bin(OPcomma,b2->Belem->Ety,b->Belem,b2->Belem); + else + b->Belem = b2->Belem; + b2->Belem = NULL; + } + list_subtract(&b->Bsucc,b2); + list_subtract(&b2->Bpred,b); + + /* change predecessor of successors of b2 from b2 to b */ + for (bl = b2->Bsucc; bl; bl = list_next(bl)) + { list_t bp; + + for (bp = list_block(bl)->Bpred; bp; bp = list_next(bp)) + { + if (list_block(bp) == b2) + list_ptr(bp) = (void *)b; + } + } + + b->BC = b2->BC; + b->BS = b2->BS; + b->Bsucc = b2->Bsucc; + b2->Bsucc = NULL; + b2->BC = BCret; /* a harmless one */ + cmes3("brcombine(): %p goto %p eliminated\n",b,b2); + anychanges++; + } + } + } + if (anychanges) + { changes++; + continue; + } + } while (0); +} + +/*********************** + * Branch optimization. + */ + +STATIC void bropt() +{ block *b,*db; + elem *n,**pn; + + cmes("bropt()\n"); + assert(!PARSER); + for (b = startblock; b; b = b->Bnext) /* for each block */ + { + pn = &(b->Belem); + if (OPTIMIZER && *pn) + while ((*pn)->Eoper == OPcomma) + pn = &((*pn)->E2); + + n = *pn; + if (b->BC == BCiftrue) + { + assert(n); + /* Replace IF (!e) GOTO ... with */ + /* IF OPnot (e) GOTO ... */ + if (n->Eoper == OPnot) + { + tym_t tym; + + tym = n->E1->Ety; + *pn = el_selecte1(n); + (*pn)->Ety = tym; + for (n = b->Belem; n->Eoper == OPcomma; n = n->E2) + n->Ety = tym; + b->Bsucc = list_reverse(b->Bsucc); + cmes("CHANGE: if (!e)\n"); + changes++; + } + + /* Take care of IF (constant) */ + if (iftrue(n)) /* if elem is TRUE */ + { + // select first succ + db = list_block(list_next(b->Bsucc)); + goto L1; + } + else if (iffalse(n)) + { + // select second succ + db = list_block(b->Bsucc); + + L1: list_subtract(&(b->Bsucc),db); + list_subtract(&(db->Bpred),b); + b->BC = BCgoto; + /* delete elem if it has no side effects */ + b->Belem = doptelem(b->Belem,GOALnone | GOALagain); + cmes("CHANGE: if (const)\n"); + changes++; + } + + /* Look for both destinations being the same */ + else if (list_block(b->Bsucc) == + list_block(list_next(b->Bsucc))) + { b->BC = BCgoto; + db = list_block(b->Bsucc); + list_subtract(&(b->Bsucc),db); + list_subtract(&(db->Bpred),b); + cmes("CHANGE: if (e) goto L1; else goto L1;\n"); + changes++; + } + } + else if (b->BC == BCswitch) + { /* see we can evaluate this switch now */ + register unsigned i,ncases; + targ_llong *p,value; + register list_t bl; + + while (n->Eoper == OPcomma) + n = n->E2; + if (n->Eoper != OPconst) + continue; + assert(tyintegral(n->Ety)); + value = el_tolong(n); + p = b->BS.Bswitch; /* ptr to switch data */ + assert(p); + ncases = *p++; /* # of cases */ + i = 1; /* first case */ + while (1) + { + if (i > ncases) + { i = 0; /* select default */ + break; + } + if (*p++ == value) + break; /* found it */ + i++; /* next case */ + } + /* the ith entry in Bsucc is the one we want */ + db = list_block(list_nth(b->Bsucc,i)); + /* delete predecessors of successors (!) */ + for (bl = b->Bsucc; bl; bl = list_next(bl)) + if (i--) // if not ith successor + { void *p; + p = list_subtract( + &(list_block(bl)->Bpred),b); + assert(p == b); + } + + /* dump old successor list and create a new one */ + list_free(&b->Bsucc,FPNULL); + list_append(&b->Bsucc,db); + b->BC = BCgoto; + b->Belem = doptelem(b->Belem,GOALnone | GOALagain); + cmes("CHANGE: switch (const)\n"); + changes++; + } + } +} + +/********************************* + * Do branch rearrangement. + */ + +STATIC void brrear() +{ register block *b; + + cmes("brrear()\n"); + for (b = startblock; b; b = b->Bnext) /* for each block */ + { register list_t bl; + + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { /* For each transfer of control block pointer */ + block *bt; + int iter = 0; + + bt = list_block(bl); + + /* If it is a transfer to a block that consists */ + /* of nothing but an unconditional transfer, */ + /* Replace transfer address with that */ + /* transfer address. */ + /* Note: There are certain kinds of infinite */ + /* loops which we avoid by putting a lid on */ + /* the number of iterations. */ + + while (bt->BC == BCgoto && !bt->Belem && +#if SCPP || NTEXCEPTIONS + b->Btry == bt->Btry && +#endif +#if NTEXCEPTIONS + bt->Btry == list_block(bt->Bsucc)->Btry && +#endif + + ++iter < 10) + { + list_ptr(bl) = list_ptr(bt->Bsucc); + if (bt->Bsrcpos.Slinnum && !b->Bsrcpos.Slinnum) + b->Bsrcpos = bt->Bsrcpos; + b->Bflags |= bt->Bflags; + list_append(&(list_block(bl)->Bpred),b); + list_subtract(&(bt->Bpred),b); + cmes("goto->goto\n"); + bt = list_block(bl); + } + + // Bsucc after the first are the targets of + // jumps, calls and loops, and as such to do this right + // we need to traverse the Bcode list and fix up + // the IEV2.Vblock pointers. + if (b->BC == BCasm) + break; + } +#if 0 + /* Replace cases of */ + /* IF (e) GOTO L1 ELSE L2 */ + /* L1: */ + /* with */ + /* IF OPnot (e) GOTO L2 ELSE L1 */ + /* L1: */ + + if (b->BC == BCiftrue || b->BC == BCiffalse) + { register block *bif,*belse; + + bif = list_block(b->Bsucc); + belse = list_block(list_next(b->Bsucc)); + + if (bif == b->Bnext) + { b->BC ^= BCiffalse ^ BCiftrue; /* toggle */ + list_ptr(b->Bsucc) = belse; + list_ptr(list_next(b->Bsucc)) = bif; + b->Bflags |= bif->Bflags & BFLvisited; + cmes("if (e) L1 else L2\n"); + } + } +#endif + } /* for */ +} + +/************************* + * Compute depth first order (DFO). + * Equivalent to Aho & Ullman Fig. 13.8. + * Blocks not in dfo[] are unreachable. + */ + +void compdfo() +{ + register int i; + + cmes("compdfo()\n"); + assert(OPTIMIZER); + block_clearvisit(); +#ifdef DEBUG + if (maxblks == 0 || maxblks < numblks) + dbg_printf("maxblks = %d, numblks = %d\n",maxblks,numblks); +#endif + assert(maxblks && maxblks >= numblks); + debug_assert(!PARSER); + if (!dfo) +#if TX86 + dfo = (block **) util_calloc(sizeof(block *),maxblks); +#else + dfo = (block **) MEM_PARF_CALLOC(sizeof(block *) * maxblks); +#endif + dfotop = numblks; /* assign numbers backwards */ + search(startblock); + assert(dfotop <= numblks); + /* Ripple data to the bottom of the array */ + if (dfotop) /* if not at bottom */ + { for (i = 0; i < numblks - dfotop; i++) + { dfo[i] = dfo[i + dfotop]; + dfo[i]->Bdfoidx = i; + } + } + dfotop = numblks - dfotop; +#if 0 + for (i = 0; i < dfotop; i++) + dbg_printf("dfo[%d] = 0x%x\n",i,dfo[i]); +#endif +} + +/****************************** + * Add block to dfo[], then its successors. + */ + +STATIC void search(block *b) +{ list_t l; + + assert(b); + b->Bflags |= BFLvisited; // executed at least once + for (l = b->Bsucc; l; l = list_next(l)) // for each successor + { block *bs = list_block(l); + + assert(bs); + if ((bs->Bflags & BFLvisited) == 0) // if not visited + search(bs); // search it + } + dfo[--dfotop] = b; // add to dfo[] + b->Bdfoidx = dfotop; // link back +} + +/************************* + * Remove blocks not marked as visited (they aren't in dfo[]). + * A block is not in dfo[] if not visited. + */ + +STATIC void elimblks() +{ block **pb,*b; + list_t s; + block *bf; + +#ifdef DEBUG + if (OPTIMIZER) + { int n; + + n = 0; + for (b = startblock; b; b = b->Bnext) + n++; + //dbg_printf("1 n = %d, numblks = %d, dfotop = %d\n",n,numblks,dfotop); + assert(numblks == n); + } +#endif + + cmes("elimblks()\n"); + bf = NULL; + for (pb = &startblock; (b = *pb) != NULL;) + { + if (((b->Bflags & BFLvisited) == 0) /* if block is not visited */ + && ((b->Bflags & BFLlabel) == 0) /* need label offset */ + ) + { + /* for each marked successor S to b */ + /* remove b from S.Bpred. */ + /* Presumably all predecessors to b are unmarked also. */ + for (s = b->Bsucc; s; s = list_next(s)) + { assert(list_block(s)); + if (list_block(s)->Bflags & BFLvisited) /* if it is marked */ + list_subtract(&(list_block(s)->Bpred),b); + } + if (b->Balign && b->Bnext && b->Balign > b->Bnext->Balign) + b->Bnext->Balign = b->Balign; + *pb = b->Bnext; /* remove from linked list */ + + b->Bnext = bf; + bf = b; /* prepend to deferred list to free */ + cmes2("CHANGE: block %p deleted\n",b); + changes++; + } + else + pb = &((*pb)->Bnext); + } + + // Do deferred free's of the blocks + for ( ; bf; bf = b) + { b = bf->Bnext; + block_free(bf); + numblks--; + } + + cmes("elimblks done\n"); + assert(!OPTIMIZER || numblks == dfotop); +} + +/********************************** + * Merge together blocks where the first block is a goto to the next + * block and the next block has only the first block as a predecessor. + * Example: + * e1; GOTO L2; + * L2: return e2; + * becomes: + * L2: return (e1 , e2); + * Returns: + * # of merged blocks + */ + +STATIC int mergeblks() +{ int merge = 0,i; + + assert(OPTIMIZER); + cmes("mergeblks()\n"); + for (i = 0; i < dfotop; i++) + { block *b; + + b = dfo[i]; + if (b->BC == BCgoto) + { block *bL2 = list_block(b->Bsucc); + + if (b == bL2) + { + Lcontinue: + continue; + } + assert(bL2->Bpred); + if (!list_next(bL2->Bpred) && bL2 != startblock) + { list_t bl; + elem *e; + + if (b == bL2 || bL2->BC == BCasm) + continue; + + if ( +#if SCPP + bL2->BC == BCtry || +#endif + bL2->BC == BC_try || + b->Btry != bL2->Btry) + continue; +#if SCPP + // If any predecessors of b are BCasm, don't merge. + for (bl = b->Bpred; bl; bl = list_next(bl)) + { + if (list_block(bl)->BC == BCasm) + goto Lcontinue; + } +#endif + + /* JOIN the elems */ + e = el_combine(b->Belem,bL2->Belem); + if (b->Belem && bL2->Belem) + e = doptelem(e,bc_goal[bL2->BC] | GOALagain); + bL2->Belem = e; + b->Belem = NULL; + + /* Remove b from predecessors of bL2 */ + list_free(&(bL2->Bpred),FPNULL); + bL2->Bpred = b->Bpred; + b->Bpred = NULL; + /* Remove bL2 from successors of b */ + list_free(&b->Bsucc,FPNULL); + + /* fix up successor list of predecessors */ + for (bl = bL2->Bpred; bl; bl = list_next(bl)) + { register list_t bs; + + for (bs=list_block(bl)->Bsucc; bs; bs=list_next(bs)) + if (list_block(bs) == b) + list_ptr(bs) = (void *)bL2; + } + + merge++; + cmes3("block %p merged with %p\n",b,bL2); + + if (b == startblock) + { /* bL2 is the new startblock */ + block **pb; + + cmes("bL2 is new startblock\n"); + /* Remove bL2 from list of blocks */ + for (pb = &startblock; 1; pb = &(*pb)->Bnext) + { assert(*pb); + if (*pb == bL2) + { *pb = bL2->Bnext; + break; + } + } + + /* And relink bL2 at the start */ + bL2->Bnext = startblock->Bnext; + startblock = bL2; /* new start */ + + block_free(b); + numblks--; + break; /* dfo[] is now invalid */ + } + } + } + } + return merge; +} + +/******************************* + * Combine together blocks that are identical. + */ + +STATIC void blident() +{ block *bn; + block *bnext; + + cmes("blident()\n"); + assert(startblock); + +#if SCPP + // Determine if any asm blocks + int anyasm = 0; + for (bn = startblock; bn; bn = bn->Bnext) + { if (bn->BC == BCasm) + { anyasm = 1; + break; + } + } +#endif + + for (bn = startblock; bn; bn = bnext) + { block *b; + + bnext = bn->Bnext; + if (bn->Bflags & BFLnomerg) + continue; + + for (b = bnext; b; b = b->Bnext) + { + /* Blocks are identical if: */ + /* BC match */ + /* not optimized for time or it's a return */ + /* (otherwise looprotate() is undone) */ + /* successors match */ + /* elems match */ + if (b->BC == bn->BC && + //(!OPTIMIZER || !(mfoptim & MFtime) || !b->Bsucc) && + (!OPTIMIZER || !(b->Bflags & BFLnomerg) || !b->Bsucc) && + list_equal(b->Bsucc,bn->Bsucc) && +#if SCPP || NTEXCEPTIONS + b->Btry == bn->Btry && +#endif + el_match(b->Belem,bn->Belem) + ) + { /* Eliminate block bn */ + list_t bl; + + switch (b->BC) + { + case BCswitch: + if (memcmp(b->BS.Bswitch,bn->BS.Bswitch,list_nitems(bn->Bsucc) * sizeof(*bn->BS.Bswitch))) + continue; + break; + +#if SCPP + case BCtry: + case BCcatch: +#endif +#if MARS + case BCjcatch: +#endif + case BC_try: + case BC_finally: + case BCasm: + Lcontinue: + continue; + } + assert(!b->Bcode); + + for (bl = bn->Bpred; bl; bl = list_next(bl)) + { block *bp; + + bp = list_block(bl); + if (bp->BC == BCasm) + // Can't do this because of jmp's and loop's + goto Lcontinue; + } + +#if 0 && SCPP + // Predecessors must all be at the same btry level. + if (bn->Bpred) + { block *bp; + + bp = list_block(bn->Bpred); + btry = bp->Btry; + if (bp->BC == BCtry) + btry = bp; + } + else + btry = NULL; + + for (bl = b->Bpred; bl; bl = list_next(bl)) + { block *bp; + + bp = list_block(bl); + if (bp->BC != BCtry) + bp = bp->Btry; + if (btry != bp) + goto Lcontinue; + } +#endif + + // if bn is startblock, eliminate b instead of bn + if (bn == startblock) + { + goto Lcontinue; // can't handle predecessors to startblock + bn = b; + b = startblock; /* swap b and bn */ + } + +#if SCPP + // Don't do it if any predecessors are ASM blocks, since + // we'd have to walk the code list to fix up any jmps. + if (anyasm) + { + for (bl = bn->Bpred; bl; bl = list_next(bl)) + { list_t bls; + block *bp; + + bp = list_block(bl); + if (bp->BC == BCasm) + goto Lcontinue; + for (bls=bp->Bsucc; bls; bls=list_next(bls)) + if (list_block(bls) == bn && + list_block(bls)->BC == BCasm) + goto Lcontinue; + } + } +#endif + + /* Change successors to predecessors of bn to point to */ + /* b instead of bn */ + for (bl = bn->Bpred; bl; bl = list_next(bl)) + { list_t bls; + block *bp; + + bp = list_block(bl); + for (bls=bp->Bsucc; bls; bls=list_next(bls)) + if (list_block(bls) == bn) + { list_ptr(bls) = (void *)b; + list_prepend(&b->Bpred,bp); + } + } + + /* Entirely remove predecessor list from bn. */ + /* elimblks() will delete bn entirely. */ + list_free(&(bn->Bpred),FPNULL); + +#ifdef DEBUG + assert(bn->BC != BCcatch); + if (debugc) + dbg_printf("block B%d (%p) removed, it was same as B%d (%p)\n", + bn->Bdfoidx,bn,b->Bdfoidx,b); +#endif + changes++; + break; + } + } + } +} + +/********************************** + * Split out return blocks so the returns can be combined into a + * single block by blident(). + */ + +STATIC void blreturn() +{ + if (!(mfoptim & MFtime)) /* if optimized for space */ + { + int retcount; /* number of return counts */ + block *b; + + retcount = 0; + + /* Find last return block */ + for (b = startblock; b; b = b->Bnext) + { if (b->BC == BCret) + retcount++; + if (b->BC == BCasm) + return; // mucks up blident() + } + + if (retcount < 2) /* quit if nothing to combine */ + return; + + /* Split return blocks */ + for (b = startblock; b; b = b->Bnext) + { if (b->BC != BCret) + continue; +#if SCPP || NTEXCEPTIONS + // If no other blocks with the same Btry, don't split +#if SCPP + if (config.flags3 & CFG3eh) +#endif + { + for (block *b2 = startblock; b2; b2 = b2->Bnext) + { + if (b2->BC == BCret && b != b2 && b->Btry == b2->Btry) + goto L1; + } + continue; + } + L1: ; +#endif + if (b->Belem) + { /* Split b into a goto and a b */ + block *bn; + +#ifdef DEBUG + if (debugc) + dbg_printf("blreturn: splitting block B%d\n",b->Bdfoidx); +#endif + numblks++; + bn = block_calloc(); + bn->BC = BCret; + bn->Bnext = b->Bnext; +#if SCPP || NTEXCEPTIONS + bn->Btry = b->Btry; +#endif + b->BC = BCgoto; + b->Bnext = bn; + list_append(&b->Bsucc,bn); + list_append(&bn->Bpred,b); + + b = bn; + } + } + + blident(); /* combine return blocks */ + } +} + +/***************************************** + * Convert expression into a list. + * Construct the list in reverse, that is, so that the right-most + * expression occurs first in the list. + */ + +STATIC list_t bl_enlist(elem *e) +{ list_t el = NULL; + + if (e) + { + elem_debug(e); + if (e->Eoper == OPcomma) + { list_t el2; + list_t pl; + + el2 = bl_enlist(e->E1); + el = bl_enlist(e->E2); + e->E1 = e->E2 = NULL; + el_free(e); + + /* Append el2 list to el */ + assert(el); + for (pl = el; list_next(pl); pl = list_next(pl)) + ; + list_next(pl) = el2; + } + else + list_prepend(&el,e); + } + return el; +} + +/***************************************** + * Take a list of expressions and convert it back into an expression tree. + */ + +STATIC elem * bl_delist(list_t el) +{ elem *e; + list_t elstart = el; + + for (e = NULL; el; el = list_next(el)) + e = el_combine(list_elem(el),e); + list_free(&elstart,FPNULL); + return e; +} + +/***************************************** + * Do tail merging. + */ + +STATIC void bltailmerge() +{ + cmes("bltailmerge()\n"); + assert(!PARSER && OPTIMIZER); + if (!(mfoptim & MFtime)) /* if optimized for space */ + { + block *b; + block *bn; + list_t bl; + elem *e; + elem *en; + + /* Split each block into a reversed linked list of elems */ + for (b = startblock; b; b = b->Bnext) + b->Blist = bl_enlist(b->Belem); + + /* Search for two blocks that have the same successor list. + If the first expressions both lists are the same, split + off a new block with that expression in it. + */ + for (b = startblock; b; b = b->Bnext) + { + if (!b->Blist) + continue; + e = list_elem(b->Blist); + elem_debug(e); + for (bn = b->Bnext; bn; bn = bn->Bnext) + { + if (b->BC == bn->BC && + list_equal(b->Bsucc,bn->Bsucc) && + bn->Blist && + el_match(e,(en = list_elem(bn->Blist))) +#if SCPP || NTEXCEPTIONS + && b->Btry == bn->Btry +#endif + ) + { + switch (b->BC) + { + case BCswitch: + if (memcmp(b->BS.Bswitch,bn->BS.Bswitch,list_nitems(bn->Bsucc) * sizeof(*bn->BS.Bswitch))) + continue; + break; + +#if SCPP + case BCtry: + case BCcatch: +#endif +#if MARS + case BCjcatch: +#endif + case BC_try: + case BC_finally: + case BCasm: + continue; + } + + /* We've got a match */ + block *bnew; + + /* Create a new block, bnew, which will be the + merged block. Physically locate it just after bn. + */ +#ifdef DEBUG + if (debugc) + dbg_printf("tail merging: %p and %p\n", b, bn); +#endif + numblks++; + bnew = block_calloc(); + bnew->Bnext = bn->Bnext; + bnew->BC = b->BC; +#if SCPP || NTEXCEPTIONS + bnew->Btry = b->Btry; +#endif + if (bnew->BC == BCswitch) + { + bnew->BS.Bswitch = b->BS.Bswitch; + b->BS.Bswitch = NULL; + bn->BS.Bswitch = NULL; + } + bn->Bnext = bnew; + + /* The successor list to bnew is the same as b's was */ + bnew->Bsucc = b->Bsucc; + b->Bsucc = NULL; + list_free(&bn->Bsucc,FPNULL); + + /* Update the predecessor list of the successor list + of bnew, from b to bnew, and removing bn + */ + for (bl = bnew->Bsucc; bl; bl = list_next(bl)) + { + list_subtract(&list_block(bl)->Bpred,b); + list_subtract(&list_block(bl)->Bpred,bn); + list_append(&list_block(bl)->Bpred,bnew); + } + + /* The predecessors to bnew are b and bn */ + list_append(&bnew->Bpred,b); + list_append(&bnew->Bpred,bn); + + /* The successors to b and bn are bnew */ + b->BC = BCgoto; + bn->BC = BCgoto; + list_append(&b->Bsucc,bnew); + list_append(&bn->Bsucc,bnew); + + changes++; + + /* Find all the expressions we can merge */ + do + { + list_append(&bnew->Blist,e); + el_free(en); + list_pop(&b->Blist); + list_pop(&bn->Blist); + if (!b->Blist) + goto nextb; + e = list_elem(b->Blist); + if (!bn->Blist) + break; + en = list_elem(bn->Blist); + } while (el_match(e,en)); + } + } + nextb: ; + } + + /* Recombine elem lists into expression trees */ + for (b = startblock; b; b = b->Bnext) + b->Belem = bl_delist(b->Blist); + } +} + +/********************************** + * Rearrange blocks to minimize jmp's. + */ + +STATIC void brmin() +{ block *b; + block *bnext; + list_t bl,blp; + +#if SCPP + // Dunno how this may mess up generating EH tables. + if (config.flags3 & CFG3eh) // if EH turned on + return; +#endif + + cmes("brmin()\n"); + debug_assert(startblock); + for (b = startblock->Bnext; b; b = b->Bnext) + { + bnext = b->Bnext; + if (!bnext) + break; + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { block *bs; + + bs = list_block(bl); + if (bs == bnext) + goto L1; + } + + // b is a block which does not have bnext as a successor. + // Look for a successor of b for which everyone must jmp to. + + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { block *bs; + block *bn; + + bs = list_block(bl); + for (blp = bs->Bpred; blp; blp = list_next(blp)) + { block *bsp; + + bsp = list_block(blp); + if (bsp->Bnext == bs) + goto L2; + } + + // Move bs so it is the Bnext of b + for (bn = bnext; 1; bn = bn->Bnext) + { + if (!bn) + goto L2; + if (bn->Bnext == bs) + break; + } +#if 1 + bn->Bnext = NULL; + b->Bnext = bs; + for (bn = bs; bn->Bnext; bn = bn->Bnext) + ; + bn->Bnext = bnext; +#else + bn->Bnext = bs->Bnext; + bs->Bnext = bnext; + b->Bnext = bs; +#endif + cmes3("Moving block %p to appear after %p\n",bs,b); + changes++; + break; + + L2: ; + } + + + L1: ; + } +} + +/******************************** + * Check integrity of blocks. + */ + +#if 0 + +STATIC void block_check() +{ block *b; + list_t bl; + + for (b = startblock; b; b = b->Bnext) + { int nsucc; + int npred; + + nsucc = list_nitems(b->Bsucc); + npred = list_nitems(b->Bpred); + switch (b->BC) + { + case BCgoto: + assert(nsucc == 1); + break; + case BCiftrue: + assert(nsucc == 2); + break; + } + + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { block *bs = list_block(bl); + list_t bls; + + for (bls = bs->Bpred; 1; bls = list_next(bls)) + { + assert(bls); + if (list_block(bls) == b) + break; + } + } + } +} + +#endif + +/*************************************** + * Do tail recursion. + */ + +STATIC void brtailrecursion() +{ block *b; + block *bs; + elem **pe; + +#if SCPP +// if (tyvariadic(funcsym_p->Stype)) + return; + return; // haven't dealt with struct params, and ctors/dtors +#endif + if (funcsym_p->Sfunc->Fflags3 & Fnotailrecursion) + return; + if (localgot) + { /* On OSX, tail recursion will result in two OPgot's: + int status5; + struct MyStruct5 { } + void rec5(int i, MyStruct5 s) + { + if( i > 0 ) + { status5++; + rec5(i-1, s); + } + } + */ + + return; + } + for (b = startblock; b; b = b->Bnext) + { + if (b->BC == BC_try) + return; + pe = &b->Belem; + block *bn = NULL; + if (*pe && + (b->BC == BCret || + b->BC == BCretexp || + (b->BC == BCgoto && (bn = list_block(b->Bsucc))->Belem == NULL && + bn->BC == BCret) + ) + ) + { elem *e; + + if (el_anyframeptr(*pe)) + return; + while ((*pe)->Eoper == OPcomma) + pe = &(*pe)->E2; + e = *pe; + if (OTcall(e->Eoper) && + e->E1->Eoper == OPvar && + e->E1->EV.sp.Vsym == funcsym_p) + { +//printf("before:\n"); +//elem_print(*pe); + if (OTunary(e->Eoper)) + { *pe = el_long(TYint,0); + } + else + { int si = 0; + elem *e2 = NULL; + *pe = assignparams(&e->E2,&si,&e2); + *pe = el_combine(*pe,e2); + } + el_free(e); +//printf("after:\n"); +//elem_print(*pe); + + if (b->BC == BCgoto) + { list_subtract(&b->Bsucc,bn); + list_subtract(&bn->Bpred,b); + } + b->BC = BCgoto; + list_append(&b->Bsucc,startblock); + list_append(&startblock->Bpred,b); + + // Create a new startblock, bs, because startblock cannot + // have predecessors. + numblks++; + bs = block_calloc(); + bs->BC = BCgoto; + bs->Bnext = startblock; + list_append(&bs->Bsucc,startblock); + list_append(&startblock->Bpred,bs); + startblock = bs; + + cmes("tail recursion\n"); + changes++; + return; + } + } + } +} + +/***************************************** + * Convert parameter expression to assignment statements. + */ + +STATIC elem * assignparams(elem **pe,int *psi,elem **pe2) +{ + elem *e = *pe; + + if (e->Eoper == OPparam) + { elem *ea = NULL; + elem *eb = NULL; + elem *e2 = assignparams(&e->E2,psi,&eb); + elem *e1 = assignparams(&e->E1,psi,&ea); + e->E1 = NULL; + e->E2 = NULL; + e = el_combine(e1,e2); + *pe2 = el_combine(eb,ea); + } + else + { int si = *psi; + Symbol *sp; + Symbol *s; + int op; + elem *es; + type *t; + + assert(si < globsym.top); + sp = globsym.tab[si]; + s = symbol_genauto(sp->Stype); + s->Sfl = FLauto; + op = OPeq; + if (e->Eoper == OPstrpar) + { + op = OPstreq; + t = e->ET; + elem *ex = e; + e = e->E1; + ex->E1 = NULL; + el_free(ex); + } + es = el_var(s); + es->Ety = e->Ety; + e = el_bin(op,TYvoid,es,e); + if (op == OPstreq) + e->ET = t; + *pe2 = el_bin(op,TYvoid,el_var(sp),el_copytree(es)); + (*pe2)->E1->Ety = es->Ety; + if (op == OPstreq) + (*pe2)->ET = t; + *psi = ++si; + *pe = NULL; + } + return e; +} + +/**************************************************** + * Eliminate empty loops. + */ + +STATIC void emptyloops() +{ + block *b; + + cmes("emptyloops()\n"); + for (b = startblock; b; b = b->Bnext) + { + if (b->BC == BCiftrue && + list_block(b->Bsucc) == b && + list_nitems(b->Bpred) == 2) + { block *bpred; + elem *einit; + elem *erel; + elem *einc; + + // Find predecessor to b + bpred = list_block(b->Bpred); + if (bpred == b) + bpred = list_block(list_next(b->Bpred)); + if (!bpred->Belem) + continue; + + // Find einit + for (einit = bpred->Belem; einit->Eoper == OPcomma; einit = einit->E2) + ; + if (einit->Eoper != OPeq || + einit->E2->Eoper != OPconst || + einit->E1->Eoper != OPvar) + continue; + +#if 1 + // Look for ((i += 1) < limit) + erel = b->Belem; + if (erel->Eoper != OPlt || + erel->E2->Eoper != OPconst || + erel->E1->Eoper != OPaddass) + continue; + + einc = erel->E1; + if (einc->E2->Eoper != OPconst || + einc->E1->Eoper != OPvar || + !el_match(einc->E1,einit->E1)) + continue; + + if (!tyintegral(einit->E1->Ety) || + el_tolong(einc->E2) != 1 || + el_tolong(einit->E2) >= el_tolong(erel->E2) + ) + continue; + + { + erel->Eoper = OPeq; + erel->Ety = erel->E1->Ety; + erel->E1 = el_selecte1(erel->E1); + b->BC = BCgoto; + list_subtract(&b->Bsucc,b); + list_subtract(&b->Bpred,b); +#ifdef DEBUG + if (debugc) + { WReqn(erel); + dbg_printf(" eliminated loop\n"); + } +#endif + changes++; + } +#else + // Find einc and erel + if (b->Belem->Eoper != OPcomma) + continue; + einc = b->Belem->E1; + erel = b->Belem->E2; + if (einc->Eoper != OPaddass || + einc->E1->Eoper != OPvar || + einc->E2->Eoper != OPconst || + erel->Eoper != OPlt || + erel->E1->Eoper != OPvar || + erel->E2->Eoper != OPconst || + !el_match(einit->E1,einc->E1) || + !el_match(einit->E1,erel->E1) + ) + continue; + + if (!tyintegral(einit->E1->Ety) || + el_tolong(einc->E2) != 1 || + el_tolong(einit->E2) >= el_tolong(erel->E2) + ) + continue; + + { + erel->Eoper = OPeq; + erel->Ety = erel->E1->Ety; + b->BC = BCgoto; + list_subtract(&b->Bsucc,b); + list_subtract(&b->Bpred,b); +#ifdef DEBUG + if (debugc) + { WReqn(erel); + dbg_printf(" eliminated loop\n"); + } +#endif + changes++; + } +#endif + } + } +} + +/****************************************** + * Determine if function has any side effects. + * This means, determine if all the function does is return a value; + * no extraneous definitions or effects or exceptions. + * A function with no side effects can be CSE'd. It does not reference + * statics or indirect references. + */ + +STATIC int funcsideeffect_walk(elem *e); + +void funcsideeffects() +{ +#if MARS + block *b; + + //printf("funcsideeffects('%s')\n",funcsym_p->Sident); + for (b = startblock; b; b = b->Bnext) + { + if (b->Belem && funcsideeffect_walk(b->Belem)) + goto Lside; + } + +Lnoside: + funcsym_p->Sfunc->Fflags3 |= Fnosideeff; + //printf(" function '%s' has no side effects\n",funcsym_p->Sident); + //return; + +Lside: + //printf(" function '%s' has side effects\n",funcsym_p->Sident); + ; +#endif +} + +#if MARS + +STATIC int funcsideeffect_walk(elem *e) +{ int op; + Symbol *s; + + assert(e); + elem_debug(e); + if (typemask(e) & mTYvolatile) + goto Lside; + op = e->Eoper; + switch (op) + { + case OPcall: + case OPucall: + if (e->E1->Eoper == OPvar && + tyfunc((s = e->E1->EV.sp.Vsym)->Stype->Tty) && + ((s->Sfunc && s->Sfunc->Fflags3 & Fnosideeff) || s == funcsym_p) + ) + break; + goto Lside; + + case OParray: + case OPfield: + goto Lside; // these can throw exceptions + + // Note: we should allow assignments to local variables as + // not being a 'side effect'. + + default: + assert(op < OPMAX); + return OTsideff(op) || + (OTunary(op) && funcsideeffect_walk(e->E1)) || + (OTbinary(op) && (funcsideeffect_walk(e->E1) || + funcsideeffect_walk(e->E2))); + } + return 0; + + Lside: + return 1; +} + +#endif + +/******************************* + * Determine if there are any OPframeptr's in the tree. + */ + +int el_anyframeptr(elem *e) +{ + while (1) + { + if (OTunary(e->Eoper)) + e = e->E1; + else if (OTbinary(e->Eoper)) + { if (el_anyframeptr(e->E2)) + return 1; + e = e->E1; + } + else if (e->Eoper == OPframeptr) + return 1; + else + break; + } + return 0; +} + + +#endif //!SPP diff --git a/backend/cc.h b/backend/cc.h new file mode 100644 index 00000000..b5278972 --- /dev/null +++ b/backend/cc.h @@ -0,0 +1,1557 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if __SC__ +#pragma once +#endif + +#ifndef CC_H +#define CC_H 1 + +#ifdef SCPP +#define CPP (config.flags3 & CFG3cpp) // if compiling for C++ +#else +#if !SPP +#define SCPP 0 +#endif +#endif + +#ifndef CPP +#define CPP 0 +#endif + +#ifndef SPP +#define SPP 0 +#endif + +#ifndef MARS +#define MARS 0 // not compiling MARS code +#endif + +#ifndef HTOD +#define HTOD 0 +#endif + +#define GENOBJ 1 // generating .obj file + +#define mskl(i) (1L << (i)) /* convert int to mask */ + +#ifndef STATIC +#define STATIC static +#endif + +#ifndef CEXTERN +#define CEXTERN extern +#endif + +// Warnings +enum WM +{ + WM_no_inline = 1, //function '%s' is too complicated to inline + WM_assignment = 2, //possible unintended assignment + WM_nestcomment = 3, //comments do not nest + WM_assignthis = 4, //assignment to 'this' is obsolete, use X::operator new/delete + WM_notagname = 5, //no tag name for struct or enum + WM_valuenotused = 6, //value of expression is not used + WM_extra_semi = 7, //possible extraneous ';' + WM_large_auto = 8, //very large automatic + WM_obsolete_del = 9, //use delete[] rather than delete[expr], expr ignored + WM_obsolete_inc = 10, //using operator++() (or --) instead of missing operator++(int) + WM_init2tmp = 11, //non-const reference initialized to temporary + WM_used_b4_set = 12, //variable '%s' used before set + WM_bad_op = 13, //Illegal type/size of operands for the %s instruction + WM_386_op = 14, //Reference to '%s' caused a 386 instruction to be generated + WM_ret_auto = 15, //returning address of automatic '%s' + WM_ds_ne_dgroup = 16, //DS is not equal to DGROUP + WM_unknown_pragma = 17, //unrecognized pragma + WM_implied_ret = 18, //implied return at closing '}' does not return value + WM_num_args = 19, //%d actual arguments expected for %s, had %d + WM_before_pch = 20, //symbols or macros defined before #include of precompiled header + WM_pch_first = 21, //precompiled header must be first #include when -H is used + WM_pch_config = 22, + WM_divby0 = 23, + WM_badnumber = 24, + WM_ccast = 25, + WM_obsolete = 26, +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + WM_skip_attribute = 27, // skip GNUC attribute specification + WM_warning_message = 28, // preprocessor warning message + WM_bad_vastart = 29, // args for builtin va_start bad + WM_undefined_inline = 30, // static inline not expanded or defined +#endif +}; + +// Language for error messages +enum LANG +{ LANGenglish, + LANGgerman, + LANGfrench, + LANGjapanese, +}; + +#include "cdef.h" // host and target compiler definition + +#define INITIALIZED_STATIC_DEF static + +#if MEMMODELS == 1 +#define LARGEDATA 0 /* don't want 48 bit pointers */ +#define LARGECODE 0 +#endif + +#ifndef __INTSIZE +#define __INTSIZE 4 // host ints are 4 bytes +#endif + +#if SPP || SCPP +#include "msgs2.h" +#endif +#include "ty.h" +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#include "../tk/mem.h" +#else +#include "mem.h" +#endif +#include "list.h" +#include "vec.h" + +#if SPP +#define COMPILER "Preprocessor" +#define ACTIVITY "preprocessing..." +#elif HTOD +#define COMPILER ".h to D Migration Tool" +#define ACTIVITY "migrating..." +#else +#define COMPILER "C/C++ Compiler" +#define ACTIVITY "compiling..." +#endif + +#ifdef DEBUG +# define debug(a) (a) +# define debugx(a) (a) +# define debug_assert assert +#else +# define debug(a) +# define debugx(a) +# define debug_assert(e) +#endif + + +/*************************** + * Print out debugging information. + */ + +#ifdef DEBUG +#define debugmes(s) (debugw && dbg_printf(s)) +#define cmes(s) (debugc && dbg_printf(s)) +#define cmes2(s,b) (debugc && dbg_printf((s),(b))) +#define cmes3(s,b,c) (debugc && dbg_printf((s),(b),(c))) +#else +#define debugmes(s) +#define cmes(s) +#define cmes2(s,b) +#define cmes3(s,b,c) +#endif + +#define TRUE 1 +#define FALSE 0 + +#ifndef ARG_TRUE +#define ARG_TRUE ,TRUE +#define ARG_FALSE ,FALSE +#endif + +#define arraysize(array) (sizeof(array) / sizeof(array[0])) + +#define IDMAX 900 //467 //254 // identifier max (excluding terminating 0) +#define IDOHD (4+1+sizeof(int)*3) // max amount of overhead to ID added by +#define STRMAX 65000 // max length of string (determined by + // max ph size) + +enum SC; +struct Thunk; +struct token_t; +struct PARAM; +typedef struct PARAM param_t; +struct block; +struct Classsym; +struct Nspacesym; +struct Outbuffer; +struct Aliassym; +struct dt_t; +typedef struct TYPE type; +typedef struct Symbol symbol; +typedef Symbol Funcsym; +//typedef Symbol Classsym; // a Symbol that is an SCclass, SCstruct or SCunion +struct elem; +#if !MARS +typedef struct MACRO macro_t; +typedef struct BLKLST blklst; +#endif +typedef list_t symlist_t; /* list of pointers to Symbols */ +typedef struct SYMTAB_S symtab_t; +struct code; + +extern Config config; + +/////////// Position in source file + +typedef struct Srcpos +{ + unsigned Slinnum; // 0 means no info available +#if SPP || SCPP + struct Sfile **Sfilptr; // file + #define srcpos_sfile(p) (**(p).Sfilptr) + #define srcpos_name(p) (srcpos_sfile(p).SFname) +#endif +#if MARS + const char *Sfilename; + #define srcpos_name(p) ((p)->Sfilename) +#endif +#if M_UNIX + short Sfilnum; // file number +#endif +#if SOURCE_OFFSETS + unsigned long Sfiloff; // byte offset +#endif + + void print(const char *func); +} Srcpos; + +#ifndef TOKEN_H +#include "token.h" +#endif + +/********************************** + * Current 'state' of the compiler. + * Used to gather together most global variables. + * This struct is saved/restored during function body parsing. + */ + +typedef struct Pstate +{ + char STinopeq; // if in n2_createopeq() + char STinarglist; // if !=0, then '>' is the end of a template + // argument list, not an operator + char STinsizeof; // !=0 if in a sizeof expression. Useful to + // prevent being converted to + // . + char STintemplate; // if !=0, then expanding a function template + // (do not expand template Symbols) + char STdeferDefaultArg; // defer parsing of default arg for parameter + char STnoexpand; // if !=0, don't expand template symbols + char STignoretal; // if !=0 ignore template argument list + char STexplicitInstantiation; // if !=0, then template explicit instantiation + char STexplicitSpecialization; // if !=0, then template explicit specialization + char STinconstexp; // if !=0, then parsing a constant expression + char STisaddr; // is this a possible pointer to member expression? + unsigned STinexp; // if !=0, then in an expression +#if NTEXCEPTIONS + char STinfilter; // if !=0 then in exception filter + char STinexcept; // if !=0 then in exception handler + block *STbfilter; // current exception filter +#endif +#if !MARS + int STinitseg; // segment for static constructor function pointer +#endif + Funcsym *STfuncsym_p; // if inside a function, then this is the + // function Symbol. + +# define funcsym_p (pstate.STfuncsym_p) + + unsigned STflags; +# define PFLpreprocessor 1 // in preprocessor +# define preprocessor (pstate.STflags & PFLpreprocessor) +# define PFLmasm 2 // in Microsoft-style inline assembler +# define PFLbasm 4 // in Borland-style inline assembler +# define inline_asm (pstate.STflags & (PFLmasm | PFLbasm)) +# define PFLsemi 8 // ';' means start of comment +//# define PFLautogen 0x10 // automatically generate HX ph file +# define PFLmftemp 0x20 // if expanding member function template +# define PFLextdef 0x40 // we had an external def +# define PFLhxwrote 0x80 // already generated HX ph file +# define PFLhxdone 0x100 // done with HX ph file +#if TX86 +# define PFLhxread 0x200 // have read in an HX ph file +# define PFLhxgen 0x400 // need to generate HX ph file +# define PFLphread 0x800 // read a ph file +# define PFLcomdef 0x1000 // had a common block +# define PFLmacdef 0x2000 // defined a macro in the source code +# define PFLsymdef 0x4000 // declared a global Symbol in the source +# define PFLinclude 0x8000 // read a .h file +# define PFLmfc 0x10000 // something will affect MFC compatibility +#endif +#if !MARS + int STinparamlist; // if != 0, then parser is in + // function parameter list + int STingargs; // in template argument list + list_t STincalias; // list of include aliases + list_t STsysincalias; // list of system include aliases +#endif + +#if TX86 + // should probably be inside #if HYDRATE, but unclear for the dmc source + char SThflag; // FLAG_XXXX: hydration flag +#define FLAG_INPLACE 0 // in place hydration +#define FLAG_HX 1 // HX file hydration +#define FLAG_SYM 2 // .SYM file hydration +#endif + + Classsym *STclasssym; // if in the scope of this class + symlist_t STclasslist; // list of classes that have deferred inline + // functions to parse + Classsym *STstag; // returned by struct_searchmember() and with_search() + SYMIDX STmarksi; // to determine if temporaries are created + char STnoparse; // add to classlist instead of parsing + char STdeferparse; // defer member func parse + enum SC STgclass; // default function storage class + int STdefertemps; // defer allocation of temps + int STdeferaccesscheck; // defer access check for members (BUG: it + // never does get done later) + int STnewtypeid; // parsing new-type-id + int STdefaultargumentexpression; // parsing default argument expression + block *STbtry; // current try block + block *STgotolist; // threaded goto scoping list + long STtdbtimestamp; // timestamp of tdb file + Symbol *STlastfunc; // last function symbol parsed by ext_def() + + // For "point of definition" vs "point of instantiation" template name lookup + unsigned STsequence; // sequence number (Ssequence) of next Symbol + unsigned STmaxsequence; // won't find Symbols with STsequence larger + // than STmaxsequence +} Pstate; + +extern Pstate pstate; + +/**************************** + * Global variables. + */ + +typedef struct Cstate +{ + struct BLKLST *CSfilblk; // current source file we are parsing + Symbol *CSlinkage; // table of forward referenced linkage pragmas + list_t CSlist_freelist; // free list for list package + symtab_t *CSpsymtab; // pointer to current Symbol table +#if MEMORYHX + void **CSphx; // pointer to HX data block +#endif + char *modname; // module unique identifier +} Cstate; + +extern Cstate cstate; + +/* Bits for sytab[] that give characteristics of storage classes */ +#define SCEXP 1 // valid inside expressions +#define SCKEP 2 // Symbol should be kept even when function is done +#define SCSCT 4 // storage class is valid for use in static ctor +#define SCSS 8 // storage class is on the stack +#define SCRD 0x10 // we can do reaching definitions on these + +// Determine if Symbol has a Ssymnum associated with it. +// (That is, it is allocated on the stack or has live variable analysis +// done on it, so it is stack and register variables.) +#define symbol_isintab(s) (sytab[(s)->Sclass] & SCSS) + +#if defined(__SC__) || defined(_MSC_VER) +typedef char enum_SC; +#else +typedef enum SC enum_SC; +#endif + +/****************************************** + * Basic blocks: + * Basic blocks are a linked list of all the basic blocks + * in a function. startblock heads the list. + */ + +#if MARS +struct ClassDeclaration; +struct Declaration; +struct Module; +#endif + +struct Blockx +{ +#if MARS + block *startblock; + block *curblock; + Funcsym *funcsym; + Symbol *context; // eh frame context variable + int scope_index; // current scope index + int next_index; // value for next scope index + unsigned flags; // value to OR into Bflags + block *tryblock; // current enclosing try block + elem *init; // static initializer + ClassDeclaration *classdec; + Declaration *member; // member we're compiling for + Module *module; // module we're in +#endif +}; + +typedef struct block +{ + union + { + elem *Belem; // pointer to elem tree + list_t Blist; // list of expressions + }; + + block *Bnext; // pointer to next block in list + list_t Bsucc; // linked list of pointers to successors + // of this block + list_t Bpred; // and the predecessor list + int Bindex; // into created object stack + int Bendindex; // index at end of block + block *Btry; // BCtry,BC_try: enclosing try block, if any + // BC???: if in try-block, points to BCtry or BC_try + // note that can't have a BCtry and BC_try in + // the same function. + union + { targ_llong *Bswitch; // BCswitch: pointer to switch data + struct { + regm_t usIasmregs; // Registers modified + unsigned char bIasmrefparam; // References parameters? + #define usIasmregs BS.BIASM.usIasmregs + #define bIasmrefparam BS.BIASM.bIasmrefparam + } BIASM; // BCasm + + struct + { Symbol *catchvar; // __throw() fills in this + #define catchvar BS.BITRY.catchvar + } BITRY; // BCtry + +#if SCPP + struct + { type *catchtype; // one type for each catch block + #define Bcatchtype BS.BICATCH.catchtype + } BICATCH; // BCcatch +#endif +#if MARS + struct + { Symbol *catchtype; // one type for each catch block + #define Bcatchtype BS.BIJCATCH.catchtype + } BIJCATCH; // BCjcatch +#endif +#if NTEXCEPTIONS || MARS + struct + { +#if MARS + Symbol *jcatchvar; // __j_throw() fills in this + #define jcatchvar BS.BI_TRY.jcatchvar +#endif + int Bscope_index; // index into scope table + #define Bscope_index BS.BI_TRY.Bscope_index + int Blast_index; // enclosing index into scope table + #define Blast_index BS.BI_TRY.Blast_index + } BI_TRY; // BC_try +#endif + + } BS; + Srcpos Bsrcpos; // line number (0 if not known) + unsigned char BC; // exit condition (enum BC) +// NEW + unsigned char Balign; // alignment + + unsigned short Bflags; // flags (BFLxxxx) + #define BFLvisited 1 // set if block is visited + #define BFLmark 2 // set if block is visited + #define BFLjmpoptdone 4 // set when no more jump optimizations + // are possible for this block + #define BFLnostackopt 8 // set when stack elimination should not + // be done +#if NTEXCEPTIONS + #define BFLehcode 0x10 // set when we need to load exception code + #define BFLunwind 0x1000 // do local_unwind following block +#endif + #define BFLnomerg 0x20 // do not merge with other blocks + #define BFLprolog 0x80 // generate function prolog + #define BFLepilog 0x100 // generate function epilog + #define BFLrefparam 0x200 // referenced parameter + #define BFLreflocal 0x400 // referenced local + #define BFLoutsideprolog 0x800 // outside function prolog/epilog + #define BFLlabel 0x2000 // block preceded by label + #define BFLvolatile 0x4000 // block is volatile + code *Bcode; // code generated for this block + + unsigned Bweight; // relative number of times this block + // is executed (optimizer and codegen) + + unsigned Bdfoidx; // index of this block in dfo[] + union + { + // CPP + struct + { + SYMIDX symstart; // (symstart <= symnum < symend) Symbols + SYMIDX symend; // are declared in this block + block *endscope; // block that forms the end of the + // scope for the declared Symbols + unsigned blknum; // position of block from startblock + Symbol *Binitvar; // !=NULL points to an auto variable with + // an explicit or implicit initializer + block *gotolist; // BCtry, BCcatch: backward list of try scopes + block *gotothread; // BCgoto: threaded list of goto's to + // unknown labels + + #define Bsymstart _BLU._UP.symstart + #define Bsymend _BLU._UP.symend + #define Bendscope _BLU._UP.endscope + #define Bblknum _BLU._UP.blknum + #define Binitvar _BLU._UP.Binitvar + #define Bgotolist _BLU._UP.gotolist + #define Bgotothread _BLU._UP.gotothread + }_UP; + + // OPTIMIZER + struct + { + vec_t Bdom; // mask of dominators for this block + vec_t Binrd; + vec_t Boutrd; // IN and OUT for reaching definitions + vec_t Binlv; + vec_t Boutlv; // IN and OUT for live variables + vec_t Bin; + vec_t Bout; // IN and OUT for other flow analyses + vec_t Bgen; + vec_t Bkill; // pointers to bit vectors used by data + // flow analysis + + // BCiftrue can have different vectors for the 2nd successor: + vec_t Bout2; + vec_t Bgen2; + vec_t Bkill2; + + #define Bdom _BLU._UO.Bdom + #define Binrd _BLU._UO.Binrd + #define Boutrd _BLU._UO.Boutrd + #define Binlv _BLU._UO.Binlv + #define Boutlv _BLU._UO.Boutlv + #define Bin _BLU._UO.Bin + #define Bout _BLU._UO.Bout + #define Bgen _BLU._UO.Bgen + #define Bkill _BLU._UO.Bkill + #define Bout2 _BLU._UO.Bout2 + #define Bgen2 _BLU._UO.Bgen2 + #define Bkill2 _BLU._UO.Bkill2 + }_UO; + + // CODGEN + struct + { + targ_size_t Btablesize; // BCswitch, BCjmptab + targ_size_t Btableoffset; // BCswitch, BCjmptab + targ_size_t Boffset; // code offset of start of this block + targ_size_t Bsize; // code size of this block + con_t Bregcon; // register state at block exit + targ_size_t Btryoff; // BCtry: offset of try block data + + #define Btablesize _BLU._UD.Btablesize + #define Btableoffset _BLU._UD.Btableoffset + #define Boffset _BLU._UD.Boffset + #define Bsize _BLU._UD.Bsize +// #define Bcode _BLU._UD.Bcode + #define Bregcon _BLU._UD.Bregcon + #define Btryoff _BLU._UD.Btryoff + } _UD; + } _BLU; +} block; + +#define list_block(l) ((block *) list_ptr(l)) + +/** Basic block control flow operators. **/ + +enum BC { + BCgoto = 1, // goto Bsucc block + BCiftrue = 2, // if (Belem) goto Bsucc[0] else Bsucc[1] + BCret = 3, // return (no return value) + BCretexp = 4, // return with return value + BCexit = 5, // never reaches end of block (like exit() was called) + BCasm = 6, // inline assembler block (Belem is NULL, Bcode + // contains code generated). + // These blocks have one or more successors in Bsucc, + // never 0 + BCswitch = 7, // switch statement + // Bswitch points to switch data + // Default is Bsucc + // Cases follow in linked list + BCifthen = 8, // a BCswitch is converted to if-then + // statements + BCjmptab = 9, // a BCswitch is converted to a jump + // table (switch value is index into + // the table) + BCtry = 10, // C++ try block + // first block in a try-block. The first block in + // Bsucc is the next one to go to, subsequent + // blocks are the catch blocks + BCcatch = 11, // C++ catch block + BCjump = 12, // Belem specifies (near) address to jump to + BC_try = 13, // SEH: first block of try-except or try-finally + // Jupiter, Mars: try-catch or try-finally + BC_filter = 14, // SEH exception-filter (always exactly one block) + BC_finally = 15, // first block of SEH termination-handler, + // or finally block + BC_ret = 16, // last block of SEH termination-handler or finally block + BC_except = 17, // first block of SEH exception-handler + BCjcatch = 18, // first block of Jupiter or Mars catch-block + BCjplace = 19, // Jupiter: placeholder + BCMAX +}; + +/********************************** + * Functions + */ + +typedef struct SYMTAB_S +{ + SYMIDX top; // 1 past end + SYMIDX symmax; // max # of entries in tab[] possible + Symbol **tab; // local Symbol table +} symtab_t; + +typedef struct FUNC_S +{ + symlist_t Fsymtree; // local Symbol table + block *Fstartblock; // list of blocks comprising function + symtab_t Flocsym; // local Symbol table + Srcpos Fstartline; // starting line # of function + Srcpos Fendline; // line # of closing brace of function + Symbol *F__func__; // symbol for __func__[] string + unsigned Fflags; +# define Fpending 1 // if function has been queued for being written +# define Foutput 2 /* if function has been written out */ +# define Finline 0x10 /* if SCinline, and function really is inline */ +# define Foverload 0x20 /* if function can be overloaded */ +# define Ftypesafe 0x40 /* if function name needs type appended */ +# define Fmustoutput 0x80 /* set for forward ref'd functions that */ + /* must be output */ +# define Finlinenest 0x1000 /* used as a marker to prevent nested */ + /* inlines from expanding */ +# define Flinkage 0x2000 /* linkage is already specified */ +# define Fstatic 0x4000 /* static member function (no this) */ +# define Foperator 4 /* if operator overload */ +# define Fcast 8 /* if cast overload */ +# define Fvirtual 0x100 /* if function is a virtual function */ +# define Fctor 0x200 /* if function is a constructor */ +# define Fdtor 0x400 /* if function is a destructor */ +# define Fnotparent 0x800 /* if function is down Foversym chain */ +# define Fbitcopy 0x8000 /* it's a simple bitcopy (op=() or X(X&)) */ +# define Fpure 0x10000 // pure function +# define Finstance 0x20000 // function is an instance of a template +# define Ffixed 0x40000 // ctor has had cpp_fixconstructor() run on it, + // dtor has had cpp_fixdestructor() +# define Fintro 0x80000 // function doesn't hide a previous virtual function +//# define unused 0x100000 // unused bit +# define Fkeeplink 0x200000 // don't change linkage to default +# define Fnodebug 0x400000 // do not generate debug info for this function +# define Fgen 0x800000 // compiler generated function +# define Finvariant 0x1000000 // __invariant function +# define Fexplicit 0x2000000 // explicit constructor +# define Fsurrogate 0x4000000 // surrogate call function + unsigned Fflags3; + #define Fvtblgen 0x01 // generate vtbl[] when this function is defined + #define Femptyexc 0x02 // empty exception specification (obsolete, use Tflags & TFemptyexc) + #define Fcppeh 0x04 // uses C++ EH + #define Fdeclared 0x10 // already declared function Symbol + #define Fmark 0x20 // has unbalanced OPctor's + #define Fnteh 0x08 // uses NT Structured EH + #define Fdoinline 0x40 // do inline walk + #define Foverridden 0x80 // ignore for overriding purposes +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + #define Fnowrite 0x100 // SCinline should never output definition +#else + #define Fjmonitor 0x100 // Jupiter synchronized function +#endif + #define Fnosideeff 0x200 // function has no side effects + #define F3badoparrow 0x400 // bad operator->() + #define Fmain 0x800 // function is main() or wmain() + #define Fnested 0x1000 // D nested function with 'this' + #define Fmember 0x2000 // D member function with 'this' + #define Fnotailrecursion 0x4000 // no tail recursion optimizations + #define Ffakeeh 0x8000 // allocate space for NT EH context sym anyway + unsigned char Foper; // operator number (OPxxxx) if Foperator + + Symbol *Fparsescope; // use this scope to parse friend functions + // which are defined within a class, so the + // class is in scope, but are not members + // of the class + + Classsym *Fclass; // if member of a class, this is the class + // (I think this is redundant with Sscope) + Funcsym *Foversym; // overloaded function at same scope + symlist_t Fclassfriends; /* Symbol list of classes of which this */ + /* function is a friend */ + block *Fbaseblock; // block where base initializers get attached + block *Fbaseendblock; // block where member destructors get attached + elem *Fbaseinit; /* list of member initializers (meminit_t) */ + /* this field has meaning only for */ + /* functions which are constructors */ + struct token_t *Fbody; /* if deferred parse, this is the list */ + /* of tokens that make up the function */ + /* body */ + // also used if SCfunctempl, SCftexpspec + unsigned Fsequence; // sequence number at point of definition + union + { + Symbol *Ftempl; // if Finstance this is the template that generated it + struct Thunk *Fthunk; // !=NULL if this function is actually a thunk + }; + Funcsym *Falias; // SCfuncalias: function Symbol referenced + // by using-declaration + symlist_t Fthunks; // list of thunks off of this function + param_t *Farglist; // SCfunctempl: the template-parameter-list + param_t *Fptal; // Finstance: this is the template-argument-list + // SCftexpspec: for explicit specialization, this + // is the template-argument-list + list_t Ffwdrefinstances; // SCfunctempl: list of forward referenced instances + list_t Fexcspec; // List of types in the exception-specification + // (NULL if none or empty) + Funcsym *Fexplicitspec; // SCfunctempl, SCftexpspec: threaded list + // of SCftexpspec explicit specializations + Funcsym *Fsurrogatesym; // Fsurrogate: surrogate cast function + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + char *Fredirect; // redirect function name to this name in object +#endif +} func_t; + +#define func_calloc() ((func_t *) mem_fcalloc(sizeof(func_t))) +#define func_free(f) mem_ffree(f) + +/************************** + * Item in list for member initializer. + */ + +typedef struct MEMINIT +{ + list_t MIelemlist; /* arg list for initializer */ + Symbol *MIsym; /* if NULL, then this initializer is */ + /* for the base class. Otherwise, this */ + /* is the member that needs the ctor */ + /* called for it */ +} meminit_t; + + +/************************************ + * Base classes are a list of these. + */ + +typedef struct BASECLASS +{ + Classsym *BCbase; // base class Symbol + struct BASECLASS *BCnext; // next base class + targ_size_t BCoffset; // offset from start of derived class to this +#if VBTABLES + unsigned short BCvbtbloff; // for BCFvirtual, offset from start of + // vbtbl[] to entry for this virtual base. + // Valid in Sbase list +#else + targ_size_t memoffset; /* for BCFvirtual, offset from this to + pointer to virtual base class. + Valid in Sbase list + */ + Symbol *param; /* parameter for this Symbol (in */ + /* Svirtbase list only) */ +#endif + symlist_t BCpublics; // public members of base class (list is freeable) + list_t BCmptrlist; // (in Smptrbase only) this is the vtbl + // (NULL if not different from base class's vtbl + Symbol *BCvtbl; // Symbol for vtbl[] array (in Smptrbase list) + // Symbol for vbtbl[] array (in Svbptrbase list) + unsigned BCflags; // base class flags +#define BCFpublic 1 // base class is public +#define BCFprotected 2 // base class is protected +#define BCFprivate 4 // base class is private +#define BCFpmask (BCFpublic | BCFprotected | BCFprivate) + +#define BCFvirtual 8 // base class is virtual +#define BCFvfirst 0x10 // virtual base class, and this is the + // first virtual appearance of it +#define BCFnewvtbl 0x20 // new vtbl generated for this base class +#define BCFvirtprim 0x40 // Primary base class of a virtual base class +#define BCFdependent 0x80 // base class is a dependent type + Classsym *BCparent; // immediate parent of this base class + // in Smptrbase +#if TX86 + struct BASECLASS *BCpbase; // parent base, NULL if did not come from a parent +#endif +} baseclass_t; + +#define baseclass_malloc() ((baseclass_t *)mem_fmalloc(sizeof(baseclass_t))) +#define baseclass_free(b) ((void)(b)) + +/************************* + * For virtual tables. + */ + +typedef struct MPTR +{ targ_short MPd; + targ_short MPi; + Symbol *MPf; + Symbol *MPparent; // immediate parent of this base class + // in Smptrbase + unsigned char MPflags; +#define MPTRvirtual 1 // it's an offset to a virtual base +#define MPTRcovariant 2 // need covariant return pointer adjustment +} mptr_t; + +#define list_mptr(l) ((mptr_t *) list_ptr(l)) + + +/*********************************** + * Information gathered about externally defined template member functions, + * member data, and member classes. + */ + +struct TMF +{ + Classsym *stag; // if !=NULL, this is the enclosing class + token_t *tbody; // tokens making it up + token_t *to; // pointer within tbody where we left off in + // template_function_decl() + param_t *temp_arglist; // template parameter list + int member_class; // 1: it's a member class + + // These are for member templates + int castoverload; // 1: it's a user defined cast + char *name; // name of template (NULL if castoverload) + int member_template; // 0: regular template + // 1: member template + param_t *temp_arglist2; // if member template, + // then member's template parameter list + + param_t *ptal; // if explicit specialization, this is the + // explicit template-argument-list + Symbol *sclassfriend; // if member function is a friend of class X, + // this is class X + unsigned access_specifier; +}; + +/*********************************** + * Information gathered about primary member template explicit specialization. + */ + +struct TME +{ + /* Given: + * template<> template struct A::B { }; + * temp_arglist2 = + * name = "B" + * ptal = + */ + param_t *ptal; // explicit template-argument-list for enclosing + // template A + symbol *stempl; // template symbol for B +}; + +/*********************************** + * Information gathered about nested explicit specializations. + */ + +struct TMNE +{ + /* For: + * template<> template<> struct A::B { }; + */ + + enum_TK tk; // TKstruct / TKclass / TKunion + char *name; // name of template, i.e. "B" + param_t *ptal; // explicit template-argument-list for enclosing + // template A, i.e. "short" + token_t *tdecl; // the tokens " { }" +}; + +/*********************************** + * Information gathered about nested class friends. + */ + +struct TMNF +{ + /* Given: + * template struct A { struct B { }; }; + * class C { template friend struct A::B; + */ + token_t *tdecl; // the tokens "A::B;" + param_t *temp_arglist; // + Classsym *stag; // the class symbol C + symbol *stempl; // the template symbol A +}; + +/*********************************** + * Special information for class templates. + */ + +typedef struct TEMPLATE +{ + symlist_t TMinstances; // list of Symbols that are instances + param_t *TMptpl; // template-parameter-list + struct token_t *TMbody; // tokens making up class body + unsigned TMsequence; // sequence number at point of definition + list_t TMmemberfuncs; // templates for member functions (list of TMF's) + list_t TMexplicit; // list of TME's: primary member template explicit specializations + list_t TMnestedexplicit; // list of TMNE's: primary member template nested explicit specializations + Symbol *TMnext; // threaded list of template classes headed + // up by template_class_list + enum_TK TMtk; // TKstruct, TKclass or TKunion + int TMflags; // STRxxx flags + + symbol *TMprimary; // primary class template + symbol *TMpartial; // next class template partial specialization + param_t *TMptal; // template-argument-list for partial specialization + // (NULL for primary class template) + list_t TMfriends; // list of Classsym's for which any instantiated + // classes of this template will be friends of + list_t TMnestedfriends; // list of TMNF's + int TMflags2; // !=0 means dummy template created by template_createargtab() +} template_t; + +/*********************************** + * Special information for enums. + */ + +typedef struct ENUM +{ + unsigned SEflags; +#define SENnotagname 1 // no tag name for enum +#define SENforward 2 // forward referenced enum + + Symbol *SEalias; // pointer to identifier E to use if + /* enum was defined as: */ + /* typedef enum { ... } E; */ + symlist_t SEenumlist; // all members of enum +} enum_t; + +/*********************************** + * Special information for structs. + */ + +typedef struct STRUCT +{ + targ_size_t Sstructsize; // size of struct + symlist_t Sfldlst; // all members of struct (list freeable) + Symbol *Sroot; // root of binary tree Symbol table + unsigned Salignsize; // size of struct for alignment purposes + unsigned char Sstructalign; // struct member alignment in effect + unsigned long Sflags; +#define STRanonymous 0x01 // set for unions with no tag names +#define STRglobal 0x02 // defined at file scope +#define STRnotagname 0x04 // struct/class with no tag name +#define STRoutdef 0x08 // we've output the debug definition +#define STRbitfields 0x10 // set if struct contains bit fields +#define STRpredef 0x1000 // a predefined struct +#define STRunion 0x4000 // actually, it's a union + +#define STRabstract 0x20 // abstract class +#define STRbitcopy 0x40 // set if operator=() is merely a bit copy +#define STRanyctor 0x80 // set if any constructors were defined + // by the user +#define STRnoctor 0x100 // no constructors allowed +#define STRgen 0x200 // if struct is an instantiation of a + // template class, and was generated by + // that template +#define STRvtblext 0x400 // generate vtbl[] only when first member function + // definition is encountered (see Fvtblgen) +#define STRexport 0x800 // all member functions are to be _export +#define STRclass 0x8000 // it's a class, not a struct +#if TX86 +#define STRimport 0x40000 // imported class +#define STRstaticmems 0x80000 // class has static members +#endif +#define STR0size 0x100000 // zero sized struct +#define STRinstantiating 0x200000 // if currently being instantiated +#define STRexplicit 0x400000 // if explicit template instantiation +#define STRgenctor0 0x800000 // need to gen X::X() + tym_t ptrtype; // type of pointer to refer to classes by + unsigned short access; // current access privilege, here so + // enum declarations can get at it + targ_size_t Snonvirtsize; // size of struct excluding virtual classes + list_t Svirtual; // freeable list of mptrs + // that go into vtbl[] +#if TX86 + list_t *Spvirtder; // pointer into Svirtual that points to start + // of virtual functions for this (derived) class + symlist_t Sopoverload; // overloaded operator funcs (list freeable) +#endif + symlist_t Scastoverload; // overloaded cast funcs (list freeable) + symlist_t Sclassfriends; // list of classes of which this is a friend + // (list is freeable) + symlist_t Sfriendclass; // classes which are a friend to this class + // (list is freeable) + symlist_t Sfriendfuncs; // functions which are a friend to this class + // (list is freeable) + symlist_t Sinlinefuncs; // list of tokenized functions + baseclass_t *Sbase; // list of direct base classes + baseclass_t *Svirtbase; // list of all virtual base classes + baseclass_t *Smptrbase; // list of all base classes that have + // their own vtbl[] + baseclass_t *Sprimary; // if not NULL, then points to primary + // base class + Funcsym *Svecctor; // constructor for use by vec_new() + Funcsym *Sctor; // constructor function + + Funcsym *Sdtor; // basic destructor +#if VBTABLES + Funcsym *Sprimdtor; // primary destructor + Funcsym *Spriminv; // primary invariant + Funcsym *Sscaldeldtor; // scalar deleting destructor +#endif + + Funcsym *Sinvariant; // basic invariant function + + Symbol *Svptr; // Symbol of vptr + Symbol *Svtbl; // Symbol of vtbl[] +#if VBTABLES + Symbol *Svbptr; // Symbol of pointer to vbtbl[] + Symbol *Svbptr_parent; // base class for which Svbptr is a member. + // NULL if Svbptr is a member of this class + targ_size_t Svbptr_off; // offset of Svbptr member + Symbol *Svbtbl; // virtual base offset table + baseclass_t *Svbptrbase; // list of all base classes in canonical + // order that have their own vbtbl[] +#endif + Funcsym *Sopeq; // X& X::operator =(X&) + Funcsym *Sopeq2; // Sopeq, but no copy of virtual bases + Funcsym *Scpct; // copy constructor + Funcsym *Sveccpct; // vector copy constructor + Symbol *Salias; // pointer to identifier S to use if + // struct was defined as: + // typedef struct { ... } S; + + Symbol *Stempsym; // if this struct is an instantiation + // of a template class, this is the + // template class Symbol + + /* For: + * template struct A { }; + * template struct A { }; + * + * A a; // primary + * Gives: + * Sarglist = + * Spr_arglist = NULL; + * + * A a; // specialization + * Gives: + * Sarglist = + * Spr_arglist = ; + */ + + param_t *Sarglist; // if this struct is an instantiation + // of a template class, this is the + // actual arg list used + param_t *Spr_arglist; // if this struct is an instantiation + // of a specialized template class, this is the + // actual primary arg list used. + // It is NULL for the + // primary template class (since it would be + // identical to Sarglist). +} struct_t; + +#define struct_calloc() ((struct_t *) mem_fcalloc(sizeof(struct_t))) +#define struct_free(st) ((void)(st)) + +/********************************** + * Symbol Table + */ + +#define list_symbol(l) ((Symbol *) list_ptr(l)) +#define list_setsymbol(l,s) list_ptr(l) = (s) +#define list_Classsym(l) ((Classsym *) list_ptr(l)) + +struct Symbol +{ +#ifdef DEBUG + unsigned short id; +#define IDsymbol 0x5678 +#define symbol_debug(s) assert((s)->id == IDsymbol) +#define class_debug(s) assert((s)->id == IDsymbol) +#else +#define symbol_debug(s) +#define class_debug(s) +#endif + + Symbol *Sl,*Sr; // left, right child + Symbol *Snext; // next in threaded list + dt_t *Sdt; // variables: initializer + type *Stype; // type of Symbol + #define ty() Stype->Tty + + union // variants for different Symbol types + { + enum_t *Senum_; // SCenum + #define Senum _SU.Senum_ + struct + { func_t *Sfunc_; // tyfunc + #define Sfunc _SU._SF.Sfunc_ + list_t Spath1_; // SCfuncalias member functions: same as Spath + #define Spath1 _SU._SF.Spath1_ + // and in same position + // SCadl: list of associated functions for ADL lookup + }_SF; + struct // SClabel + { int Slabel_; // TRUE if label was defined + #define Slabel _SU._SL.Slabel_ + block *Slabelblk_; // label block + #define Slabelblk _SU._SL.Slabelblk_ + }_SL; + #define Senumlist Senum->SEenumlist + +#if !MARS + struct // SClinkage + { + long Slinkage_; // tym linkage bits + #define Slinkage _SU._SLK.Slinkage_ + unsigned Smangle_; + #define Smangle _SU._SLK.Smangle_ + }_SLK; +#else + long Slinkage; // SClinkage, tym linkage bits +#endif + + struct + { + char Sbit_; // SCfield: bit position of start of bit field + #define Sbit _SU._SB.Sbit_ + char Swidth_; // SCfield: width in bits of bit field + #define Swidth _SU._SB.Swidth_ + targ_size_t Smemoff_; // SCmember,SCfield: offset from start of struct + #define Smemoff _SU._SB.Smemoff_ + }_SB; + + elem *Svalue_; /* SFLvalue: value of const + SFLdtorexp: for objects with destructor, + conditional expression to precede dtor call + */ + #define Svalue _SU.Svalue_ + + struct_t *Sstruct_; // SCstruct + #define Sstruct _SU.Sstruct_ + template_t *Stemplate_; // SCtemplate + #define Stemplate _SU.Stemplate_ +#if SCPP + struct // SCnamespace + { Symbol *Snameroot_; // the Symbol table for the namespace + #define Snameroot _SU._SN.Snameroot_ + list_t Susing_; // other namespaces from using-directives + #define Susing _SU._SN.Susing_ + }_SN; + struct + { Symbol *Smemalias_; // SCalias: pointer to Symbol to use instead + // (generated by using-declarations and + // namespace-alias-definitions) + // SCmemalias: pointer to member of base class + // to use instead (using-declarations) + #define Smemalias _SU._SA.Smemalias_ + symlist_t Spath_; // SCmemalias: path of classes to get to base + // class of which Salias is a member + #define Spath _SU._SA.Spath_ + }_SA; +#endif +#if !MARS + Symbol *Simport_; // SCextern: if dllimport Symbol, this is the + #define Simport _SU.Simport_ + // Symbol it was imported from +#endif + unsigned char Spreg_; // SCfastpar: register parameter is passed in + #define Spreg _SU.Spreg_ + }_SU; + +#if SCPP || MARS + Symbol *Sscope; // enclosing scope (could be struct tag, + // enclosing inline function for statics, + // or namespace) +#define isclassmember(s) ((s)->Sscope && (s)->Sscope->Sclass == SCstruct) +#endif + +#if SCPP + Symbol *Scover; // if there is a tag name and a regular name + // of the same identifier, Scover is the tag + // Scover can be SCstruct, SCenum, SCtemplate + // or an SCalias to them. +#define isscover(s) ((s)->Sclass == SCstruct || (s)->Sclass == SCenum || (s)->Sclass == SCtemplate) + unsigned Ssequence; // sequence number (used for 2 level lookup) + // also used as 'parameter number' for SCTtemparg +#elif MARS + const char *prettyIdent; // the symbol identifer as the user sees it +#elif AUTONEST + unsigned char Spush; // # of pushes followed by # of + unsigned char Spop; // pops of scope level +#endif + +#if ELFOBJ || MACHOBJ + long obj_si; // Symbol index of coff or elf symbol + unsigned long dwarf_off; // offset into .debug section + targ_size_t code_off; // rel. offset from start of block where var is initialized + targ_size_t last_off; // last offset using var +#endif +#if TARGET_OSX + targ_size_t Slocalgotoffset; +#endif + + enum_SC Sclass; // storage class (SCxxxx) + char Sfl; // flavor (FLxxxx) + SYMFLGS Sflags; // flag bits (SFLxxxx) + #define SFLmark 0x08 // temporary marker + #define SFLvalue 0x01 // Svalue contains const expression + #define SFLimplem 0x02 // if seen implementation of Symbol + // (function body for functions, + // initializer for variables) + #define SFLdouble 0x02 // SCregpar or SCparameter, where float + // is really passed as a double + #define SFLfree 0x04 // if we can symbol_free() a Symbol in + // a Symbol table[] + #define SFLexit 0x10 // tyfunc: function does not return + // (ex: exit,abort,_assert,longjmp) + #define SFLtrue 0x200 // value of Symbol != 0 + #define SFLreplace SFLmark // variable gets replaced in inline expansion + #define SFLskipinit 0x10000 // SCfield, SCmember: initializer is skipped + #define SFLnodebug 0x20000 // don't generate debug info + #define SFLwasstatic 0x800000 // was an uninitialized static + #define SFLweak 0x1000000 // resolve to NULL if not found + + // CPP + #define SFLnodtor 0x10 // set if destructor for Symbol is already called + #define SFLdtorexp 0x80 // Svalue has expression to tack onto dtor + #define SFLmutable 0x100000 // SCmember or SCfield is mutable + #define SFLdyninit 0x200000 // symbol has dynamic initializer + #define SFLtmp 0x400000 // symbol is a generated temporary +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + #define SFLthunk 0x40000 // symbol is temporary for thunk +#endif + + // Possible values for protection bits + #define SFLprivate 0x60 + #define SFLprotected 0x40 + #define SFLpublic 0x20 + #define SFLnone 0x00 + #define SFLpmask 0x60 // mask for the protection bits +#if VEC_VTBL_LIST + #define SFLvtbl 0x2000 // Symbol is a vtable or vbtable +#endif + + // OPTIMIZER and CODGEN + #define GTregcand 0x100 // if Symbol is a register candidate + #define SFLdead 0x800 // this variable is dead + #define GTunregister 0x2000000 // 'unregister' a previous register assignment + + // OPTIMIZER only + #define SFLunambig 0x400 // only accessible by unambiguous reference, + // i.e. cannot be addressed via pointer + // (GTregcand is a subset of this) + // P.S. code generator turns off this + // flag if any reads are done from it. + // This is to eliminate stores to it + // that are never read. + #define SFLlivexit 0x1000 // live on exit from function + #define SFLnotbasiciv 0x4000 // not a basic induction variable + #define SFLnord SFLdouble // SCauto,SCregister,SCtmp: disallow redundant warnings + + // CODGEN only + #define GTtried SFLmark // tried to place in register + #define GTbyte 0x8000 // variable is sometimes accessed as + #define SFLread 0x40000 // variable is actually read from + // (to eliminate dead stores) + #define SFLspill 0x80000 // only in register part of the time + + vec_t Srange; // live range, if any + vec_t Slvreg; // when symbol is in register + targ_size_t Ssize; // tyfunc: size of function + targ_size_t Soffset; // variables: offset of Symbol in its storage class + + // CPP || OPTIMIZER + SYMIDX Ssymnum; // Symbol number (index into globsym.tab[]) + // SCauto,SCparameter,SCtmp,SCregpar,SCregister + // CODGEN + int Sseg; // segment index + int Sweight; // usage count, the higher the number, + // the more worthwhile it is to put in + // a register + union + { + unsigned Sxtrnnum_; // SCcomdef,SCextern,SCcomdat: external symbol # (starting from 1) + #define Sxtrnnum _SXR.Sxtrnnum_ + unsigned long Stypidx_; // SCstruct,SCunion,SCclass,SCenum,SCtypedef: debug info type index + #define Stypidx _SXR.Stypidx_ + struct + { unsigned char Sreglsw_; + #define Sreglsw _SXR._SR.Sreglsw_ + unsigned char Sregmsw_; + #define Sregmsw _SXR._SR.Sregmsw_ + regm_t Sregm_; // mask of registers + #define Sregm _SXR._SR.Sregm_ + }_SR; // SCregister,SCregpar,SCpseudo: register number + }_SXR; + regm_t Sregsaved; // mask of registers not affected by this func + +#if SOURCE_4SYMS + Srcpos Ssrcpos; // file position for definition +#endif + + char Sident[SYM_PREDEF_SZ]; // identifier string (dynamic array) + // (the size is for static Symbols) + + int needThis(); // !=0 if symbol needs a 'this' pointer +}; + +#if __DMC__ +#pragma SC align +#endif + +// Class, struct or union + +struct Classsym : Symbol { }; + +// Namespace Symbol +struct Nspacesym : Symbol { }; + +// Alias for another Symbol +struct Aliassym : Symbol { }; + +// Function symbol +//struct Funcsym : Symbol { }; + +// Determine if this Symbol is stored in a COMDAT +#if MARS +#define symbol_iscomdat(s) ((s)->Sclass == SCcomdat || \ + config.flags2 & CFG2comdat && (s)->Sclass == SCinline || \ + config.flags4 & CFG4allcomdat && ((s)->Sclass == SCglobal)) +#else +#define symbol_iscomdat(s) ((s)->Sclass == SCcomdat || \ + config.flags2 & CFG2comdat && (s)->Sclass == SCinline || \ + config.flags4 & CFG4allcomdat && ((s)->Sclass == SCglobal || (s)->Sclass == SCstatic)) +#endif + +/* Format the identifier for presentation to the user */ +char *cpp_prettyident (Symbol *s); + +inline char *prettyident(Symbol *s) { return CPP ? cpp_prettyident(s) : s->Sident; } + +/********************************** + * Function parameters: + * Pident identifier of parameter + * Ptype type of argument + * Pelem default value for argument + * Psym symbol corresponding to Pident when using the + * parameter list as a symbol table + * For template-parameter-list: + * Pident identifier of parameter + * Ptype if NULL, this is a type-parameter + * else the type for a parameter-declaration value argument + * Pelem default value for value argument + * Pdeftype default value for type-parameter + * Pptpl template-parameter-list for template-template-parameter + * Psym default value for template-template-parameter + * For template-arg-list: (actual arguments) + * Pident NULL + * Ptype type-name + * Pelem expression (either Ptype or Pelem is NULL) + * Psym SCtemplate for template-template-argument + */ + +struct PARAM +{ +#ifdef DEBUG + unsigned short id; +#define IDparam 0x7050 +#define param_debug(s) assert((s)->id == IDparam) +#else +#define param_debug(s) +#endif + + char *Pident; // identifier + type *Ptype; // type of parameter (NULL if not known yet) + elem *Pelem; // default value + token_t *PelemToken; // tokens making up default elem + type *Pdeftype; // Ptype==NULL: default type for type-argument + param_t *Pptpl; // template-parameter-list for template-template-parameter + Symbol *Psym; + PARAM *Pnext; // next in list + unsigned Pflags; + #define PFexplicit 1 // this template argument was explicit, i.e. in < > +#if SOURCE_4PARAMS + Srcpos Psrcpos; // parameter source definition +#endif + + PARAM *createTal(PARAM *); // create template-argument-list blank from + // template-parameter-list + PARAM *search(char *id); // look for Pident matching id + int searchn(char *id); // look for Pident matching id, return index + unsigned length(); // number of parameters in list + void print(); // print this param_t + void print_list(); // print this list of param_t's +}; + +/************************************** + * Element types. + * These should be combined with storage classes. + */ + +enum FL +{ + FLunde, + FLconst, // numerical constant + FLoper, // operator node + FLfunc, // function symbol + FLdata, // ref to data segment variable + FLreg, // ref to register variable + FLpseudo, // pseuodo register variable + FLauto, // ref to automatic variable + FLpara, // ref to function parameter variable + FLextern, // ref to external variable + FLtmp, // ref to a stack temporary, int contains temp number + FLcode, // offset to code + FLblock, // offset to block + FLudata, // ref to udata segment variable + FLcs, // ref to common subexpression number + FLswitch, // ref to offset of switch data block + FLfltreg, // ref to floating reg on stack, int contains offset + FLoffset, // offset (a variation on constant, needed so we + // can add offsets (different meaning for FLconst)) + FLdatseg, // ref to data segment offset + FLctor, // constructed object + FLdtor, // destructed object + FLregsave, // ref to saved register on stack, int contains offset + FLasm, // (code) an ASM code +#if TX86 + FLndp, // saved 8087 register +#endif +#if TARGET_SEGMENTED + FLfardata, // ref to far data segment + FLcsdata, // ref to code segment variable +#endif + FLlocalsize, // replaced with # of locals in the stack frame + FLtlsdata, // thread local storage + FLbprel, // ref to variable at fixed offset from frame pointer + FLframehandler, // ref to C++ frame handler for NT EH + FLblockoff, // address of block + FLallocatmp, // temp for built-in alloca() + FLstack, // offset from ESP rather than EBP + FLdsymbol, // it's a Dsymbol +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + // Change this, update debug.c too + FLgot, // global offset table entry outside this object file + FLgotoff, // global offset table entry inside this object file + //FLoncedata, // link once data + //FLoncecode, // link once code +#endif + FLMAX +}; + +////////// Srcfiles + +#if !MARS +// Collect information about a source file. +typedef struct Sfile +{ +#ifdef DEBUG + unsigned short id; +#define IDsfile (('f' << 8) | 's') +#define sfile_debug(sf) assert((sf)->id == IDsfile) +#else +#define sfile_debug(sf) +#endif + + char *SFname; // name of file + unsigned SFflags; + #define SFonce 0x01 // file is to be #include'd only once + #define SFhx 0x02 // file is in an HX file and has not been loaded + #define SFtop 0x04 // file is a top level source file + #define SFloaded 0x08 // read from PH file + list_t SFfillist; // file pointers of Sfile's that this Sfile is + // dependent on (i.e. they were #include'd). + // Does not include nested #include's + macro_t *SFmacdefs; // threaded list of macros #defined by this file + macro_t **SFpmacdefs; // end of macdefs list + Symbol *SFsymdefs; // threaded list of global symbols declared by this file + symlist_t SFcomdefs; // comdefs defined in PH + symlist_t SFtemp_ft; // template_ftlist + symlist_t SFtemp_class; // template_class_list + Symbol *SFtagsymdefs; // list of tag names (C only) + unsigned SFhashval; // hash of file name +} Sfile; + +// Source files are referred to by a pointer into pfiles[]. This is so that +// when PH files are hydrated, only pfiles[] needs updating. Of course, this +// means that pfiles[] cannot be reallocated to larger numbers, its size is +// fixed at SRCFILES_MAX. + +typedef struct Srcfiles +{ +// Sfile *arr; // array of Sfiles + Sfile **pfiles; // parallel array of pointers into arr[] + #define SRCFILES_MAX (2*512) + unsigned dim; // dimension of array + unsigned idx; // # used in array +} Srcfiles; + +#define sfile(fi) (*srcfiles.pfiles[fi]) +#define srcfiles_name(fi) (sfile(fi).SFname) +#endif + +/************************************************** + * This is to support compiling expressions within the context of a function. + */ + +struct EEcontext +{ + unsigned EElinnum; // line number to insert expression + char *EEexpr; // expression + char *EEtypedef; // typedef identifier + char EEpending; // !=0 means we haven't compiled it yet + char EEimminent; // we've installed it in the source text + char EEcompile; // we're compiling for the EE expression + char EEin; // we are parsing an EE expression + elem *EEelem; // compiled version of EEexpr + Symbol *EEfunc; // function expression is in + code *EEcode; // generated code +}; + +extern EEcontext eecontext; + +#include "rtlsym.h" + +#undef SYMBOL_Z +#define SYMBOL_Z(e,fl,saved,n,flags,ty) RTLSYM_##e, + +enum +{ + RTLSYMS + + RTLSYM_MAX +}; + +extern Symbol *rtlsym[RTLSYM_MAX]; + +// Different goals for el_optimize() +#define GOALnone 0 // evaluate for side effects only +#define GOALvalue 1 // evaluate for value +#define GOALflags 2 // evaluate for flags +#define GOALagain 4 +#define GOALstruct 8 +#define GOALhandle 0x10 // don't replace handle'd objects + +/* Globals returned by declar() */ +struct Declar +{ + Classsym *class_sym; + Nspacesym *namespace_sym; + int oper; + bool constructor; + bool destructor; + bool invariant; + param_t *ptal; + bool explicitSpecialization; + int hasExcSpec; // has exception specification +}; + +extern Declar gdeclar; + +#endif diff --git a/backend/cdef.h b/backend/cdef.h new file mode 100644 index 00000000..5a73153a --- /dev/null +++ b/backend/cdef.h @@ -0,0 +1,1104 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +/* Macros defined by the compiler, not the code: + + Compiler: + __SC__ Symantec compiler + __DMC__ Digital Mars compiler + _MSC_VER Microsoft compiler + __GNUC__ Gnu compiler + __clang__ Clang compiler + __llvm__ Compiler using LLVM as backend (LLVM-GCC/Clang) + + Host operating system: + _WIN32 Microsoft NT, Windows 95, Windows 98, Win32s, Windows 2000 + _WIN64 Windows for AMD64 + linux Linux + __APPLE__ Mac OSX + __FreeBSD__ FreeBSD + __OpenBSD__ OpenBSD + __sun&&__SVR4 Solaris, OpenSolaris (yes, both macros are necessary) + __OS2__ IBM OS/2 + DOS386 32 bit DOS extended executable + DOS16RM Rational Systems 286 DOS extender + + Compiler executable type: + _WINDLL if building a _WIN32 DLL + + Host CPU: + _M_I86 Intel processor + _M_AMD64 AMD 64 processor + + Hosts no longer supported: + __INTSIZE==2 16 bit compilations + __OS2__ IBM OS/2 + DOS386 32 bit DOS extended executable + DOS16RM Rational Systems 286 DOS extender + _MSDOS MSDOS + +One and only one of these macros must be set by the makefile: + + SPP Build C/C++ preprocessor + SCPP Build C/C++ compiler + MARS Build Mars compiler + */ + +/* Windows/DOS/DOSX Version + * ------------------------ + * There are two main issues: hosting the compiler on windows, + * and generating (targetting) windows/dos/dosx executables. + * The "_WIN32" and "__DMC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target linux executables, use OMFOBJ for things specific to the + * OMF object file format, and TARGET_WINDOS for things specific to + * the windows/dos/dosx memory model. + * If this is all done right, one could generate a win/dos/dosx object file + * even when compiling on linux, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +/* Linux Version + * ------------- + * There are two main issues: hosting the compiler on linux, + * and generating (targetting) linux executables. + * The "linux" and "__GNUC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target linux executables, use ELFOBJ for things specific to the + * ELF object file format, and TARGET_LINUX for things specific to + * the linux memory model. + * If this is all done right, one could generate a linux object file + * even when compiling on win32, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +/* OSX Version + * ------------- + * There are two main issues: hosting the compiler on OSX, + * and generating (targetting) OSX executables. + * The "__APPLE__" and "__GNUC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target OSX executables, use MACHOBJ for things specific to the + * MACH-O object file format, and TARGET_OSX for things specific to + * the OSX memory model. + * If this is all done right, one could generate an OSX object file + * even when compiling on win32, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +/* FreeBSD Version + * ------------- + * There are two main issues: hosting the compiler on FreeBSD, + * and generating (targetting) FreeBSD executables. + * The "__FreeBSD__" and "__GNUC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target FreeBSD executables, use ELFOBJ for things specific to the + * ELF object file format, and TARGET_FREEBSD for things specific to + * the FreeBSD memory model. + * If this is all done right, one could generate a FreeBSD object file + * even when compiling on win32, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +/* OpenBSD Version + * ------------- + * There are two main issues: hosting the compiler on OpenBSD, + * and generating (targetting) OpenBSD executables. + * The "__OpenBSD__" and "__GNUC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target OpenBSD executables, use ELFOBJ for things specific to the + * ELF object file format, and TARGET_FREEBSD for things specific to + * the OpenBSD memory model. + * If this is all done right, one could generate a OpenBSD object file + * even when compiling on win32, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +/* Solaris Version + * ------------- + * There are two main issues: hosting the compiler on Solaris, + * and generating (targetting) Solaris executables. + * The "__sun", "__SVR4" and "__GNUC__" macros control hosting issues + * for operating system and compiler dependencies, respectively. + * To target Solaris executables, use ELFOBJ for things specific to the + * ELF object file format, and TARGET_SOLARIS for things specific to + * the Solaris memory model. + * If this is all done right, one could generate a Solaris object file + * even when compiling on win32, and vice versa. + * The compiler source code currently uses these macros very inconsistently + * with these goals, and should be fixed. + */ + +#ifndef CDEF_H +#define CDEF_H 1 + +#define VERSION "8.54.0" // for banner and imbedding in .OBJ file +#define VERSIONHEX "0x854" // for __DMC__ macro +#define VERSIONINT 0x854 // for precompiled headers and DLL version + + +/*********************************** + * Target machine types: + */ + +#define TX86 1 // target is Intel 80X86 processor + +// Set to 1 using the makefile +#ifndef TARGET_LINUX +#define TARGET_LINUX 0 // target is a linux executable +#endif + +// Set to 1 using the makefile +#ifndef TARGET_OSX +#define TARGET_OSX 0 // target is an OSX executable +#endif + +// Set to 1 using the makefile +#ifndef TARGET_FREEBSD +#define TARGET_FREEBSD 0 // target is a FreeBSD executable +#endif + +// Set to 1 using the makefile +#ifndef TARGET_OPENBSD +#define TARGET_OPENBSD 0 // target is an OpenBSD executable +#endif + +// Set to 1 using the makefile +#ifndef TARGET_SOLARIS +#define TARGET_SOLARIS 0 // target is a Solaris executable +#endif + +// This is the default +#ifndef TARGET_WINDOS +#define TARGET_WINDOS (!(TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS)) +#endif + +#if __GNUC__ +#include "cdeflnx.h" +#endif + +#if _WINDLL +#define SUFFIX "nd" +#elif _WIN64 +#define SUFFIX "a" +#elif _WIN32 +#define SUFFIX "n" +#elif DOS386 +#define SUFFIX "x" +#elif DOS16RM +#define SUFFIX "r" +#else +#define SUFFIX "" +#endif + +// C++ Language Features +#define ANGLE_BRACKET_HACK 0 // >> means two template arglist closes + +// C Language Features +#define CPP_COMMENT 1 // allow C++ style comments + +// C/C++ Language Features +#define PSEUDO_REGS 1 +#define INLINE_ASM 1 // support inline assembler +#define HIDDENPARAM_1ST_ARG 1 +#define HEADER_LIST 1 +#define PASCAL_STRINGS 0 +#define KEYWORD_WITH 1 +#define EECONTEXT 1 +#define LOCALE 0 // locale support for Unicode conversion +#define HEXFLOATS 1 // support hex floating point constants +#define OVERLOAD_CV_PARAM 1 // if int foo(int i) and int foo(const int i) + // are different +#define CPP0X 1 // support C++0x features + +// Support generating code for 16 bit memory models +#define SIXTEENBIT (SCPP && TARGET_WINDOS) + +/* Set for supporting the FLAT memory model. + * This is not quite the same as !SIXTEENBIT, as one could + * have near/far with 32 bit code. + */ +#define TARGET_SEGMENTED (!MARS && TARGET_WINDOS) + + +#define STATEMENT_SCOPES CPP + +#if __GNUC__ +#define LONGLONG 1 +#elif __SC__ < 0x700 || _MSC_VER +#define LONGLONG 0 +#else +#define LONGLONG 1 // add in code to support 64 bit integral types +#endif + +#if __GNUC__ +#define LDOUBLE 0 // no support for true long doubles +#else +#define LDOUBLE (config.exe == EX_NT) // support true long doubles +#endif + +// Precompiled header variations +#define MEMORYHX (_WINDLL && _WIN32) // HX and SYM files are cached in memory +#define MMFIO (_WIN32 || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4) // if memory mapped files +#define LINEARALLOC _WIN32 // if we can reserve address ranges + +// H_STYLE takes on one of these precompiled header methods +#define H_NONE 1 // no hydration/dehydration necessary +#define H_BIT0 2 // bit 0 of the pointer determines if pointer + // is dehydrated, an offset is added to + // hydrate it +#define H_OFFSET 4 // the address range of the pointer determines + // if pointer is dehydrated, and an offset is + // added to hydrate it. No dehydration necessary. +#define H_COMPLEX 8 // dehydrated pointers have bit 0 set, hydrated + // pointers are in non-contiguous buffers + +// Do we need hydration code +#define HYDRATE (H_STYLE & (H_BIT0 | H_OFFSET | H_COMPLEX)) + +// Do we need dehydration code +#define DEHYDRATE (H_STYLE & (H_BIT0 | H_COMPLEX)) + +// Determine hydration style +// NT console: H_NONE +// NT DLL: H_OFFSET +// DOSX: H_COMPLEX +#if MARS +#define H_STYLE H_NONE // precompiled headers only used for C/C++ compiler +#else +#if MMFIO +#if _WINDLL +#define H_STYLE H_OFFSET +#else +#define H_STYLE H_OFFSET //H_NONE +#endif +#elif LINEARALLOC +#define H_STYLE H_BIT0 +#else +#define H_STYLE H_COMPLEX +#endif +#endif + +// NT structured exception handling +// 0: no support +// 1: old style +// 2: new style +#define NTEXCEPTIONS 2 + +// indivisible file I/O +#define INDIVFILEIO 1 + +#define NEWSTATICDTOR 1 // support new style static destructors + +// For Shared Code Base +#define TARGET_INLINEFUNC_NAMES +#define PASCAL pascal +#define HINT int +#define UHINT unsigned int +#if _WINDLL +#define dbg_printf dll_printf +#else +#define dbg_printf printf +#endif + +#ifndef ERRSTREAM +#define ERRSTREAM stdout +#endif +#define err_printf printf +#define err_vprintf vfprintf +#define err_fputc fputc +#define dbg_fputc fputc +#define LF '\n' +#define LF_STR "\n" +#define CR '\r' +#define ANSI config.ansi_c +#define ANSI_STRICT config.ansi_c +#define ANSI_RELAX config.ansi_c +#ifndef TRIGRAPHS +#define TRIGRAPHS ANSI +#endif +#define ARG_TRUE +#define ARG_FALSE +#define T68000(x) +#define T80x86(x) x + +// For Share MEM_ macros - default to mem_xxx package +// PH precompiled header +// PARF parser, life of function +// PARC parser, life of compilation +// BEF back end, function +// BEC back end, compilation + +#define MEM_PH_FREE mem_free +#define MEM_PARF_FREE mem_free +#define MEM_PARC_FREE mem_free +#define MEM_BEF_FREE mem_free +#define MEM_BEC_FREE mem_free + +#define MEM_PH_CALLOC mem_calloc +#define MEM_PARC_CALLOC mem_calloc +#define MEM_PARF_CALLOC mem_calloc +#define MEM_BEF_CALLOC mem_calloc +#define MEM_BEC_CALLOC mem_calloc + +#define MEM_PH_MALLOC mem_malloc +#define MEM_PARC_MALLOC mem_malloc +#define MEM_PARF_MALLOC mem_malloc +#define MEM_BEF_MALLOC mem_malloc +#define MEM_BEC_MALLOC mem_malloc + +#define MEM_PH_STRDUP mem_strdup +#define MEM_PARC_STRDUP mem_strdup +#define MEM_PARF_STRDUP mem_strdup +#define MEM_BEF_STRDUP mem_strdup +#define MEM_BEC_STRDUP mem_strdup + +#define MEM_PH_REALLOC mem_realloc +#define MEM_PARC_REALLOC mem_realloc +#define MEM_PARF_REALLOC mem_realloc +#define MEM_PERM_REALLOC mem_realloc +#define MEM_BEF_REALLOC mem_realloc +#define MEM_BEC_REALLOC mem_realloc + +#define MEM_PH_FREEFP mem_freefp +#define MEM_PARC_FREEFP mem_freefp +#define MEM_PARF_FREEFP mem_freefp +#define MEM_BEF_FREEFP mem_freefp +#define MEM_BEC_FREEFP mem_freefp + + +// If we can use 386 instruction set (possible in 16 bit code) +#define I386 (config.target_cpu >= TARGET_80386) + +// If we are generating 32 bit code +#if MARS +#define I16 0 // no 16 bit code for D +#define I32 (NPTRSIZE == 4) +#define I64 (NPTRSIZE == 8) // 1 if generating 64 bit code +#else +#define I16 (NPTRSIZE == 2) +#define I32 (NPTRSIZE == 4) +#define I64 (NPTRSIZE == 8) // 1 if generating 64 bit code +#endif + +/********************************** + * Limits & machine dependent stuff. + */ + +/* Define stuff that's different between VAX and IBMPC. + * HOSTBYTESWAPPED TRUE if on the host machine the bytes are + * swapped (TRUE for 6809, 68000, FALSE for 8088 + * and VAX). + */ + + +#define EXIT_BREAK 255 // aborted compile with ^C + +/* Take advantage of machines that can store a word, lsb first */ +#if _M_I86 // if Intel processor +#define TOWORD(ptr,val) (*(unsigned short *)(ptr) = (unsigned short)(val)) +#define TOLONG(ptr,val) (*(unsigned *)(ptr) = (unsigned)(val)) +#else +#define TOWORD(ptr,val) (((ptr)[0] = (unsigned char)(val)),\ + ((ptr)[1] = (unsigned char)((val) >> 8))) +#define TOLONG(ptr,val) (((ptr)[0] = (unsigned char)(val)),\ + ((ptr)[1] = (unsigned char)((val) >> 8)),\ + ((ptr)[2] = (unsigned char)((val) >> 16)),\ + ((ptr)[3] = (unsigned char)((val) >> 24))) +#endif + +#define TOOFFSET(a,b) (I32 ? TOLONG(a,b) : TOWORD(a,b)) + +/*************************** + * Target machine data types as they appear on the host. + */ + +typedef signed char targ_char; +typedef unsigned char targ_uchar; +typedef signed char targ_schar; +typedef short targ_short; +typedef unsigned short targ_ushort; +typedef int targ_long; +typedef unsigned targ_ulong; +#if LONGLONG +typedef long long targ_llong; +typedef unsigned long long targ_ullong; +#else +#define targ_llong targ_long +#define targ_ullong targ_ulong +#endif +typedef float targ_float; +typedef double targ_double; +typedef long double targ_ldouble; + +// Extract most significant register from constant +#define MSREG(p) ((REGSIZE == 2) ? (p) >> 16 : ((sizeof(targ_llong) == 8) ? (p) >> 32 : 0)) + +typedef int targ_int; +typedef unsigned targ_uns; + +/* Sizes of base data types in bytes */ + +#define CHARSIZE 1 +#define SHORTSIZE 2 +#define WCHARSIZE 2 // 2 for WIN32, 4 for linux/OSX/FreeBSD/OpenBSD/Solaris +#define LONGSIZE 4 +#define LLONGSIZE 8 +#define FLOATSIZE 4 +#define DOUBLESIZE 8 +#if TARGET_OSX +#define LNGDBLSIZE 16 // 80 bit reals +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define LNGDBLSIZE 12 // 80 bit reals +#else +#define LNGDBLSIZE 10 // 80 bit reals +#endif +#define TMAXSIZE LNGDBLSIZE // largest size a constant can be + +#if 0 +#define NDPSAVESIZE DOUBLESIZE +#else +#define NDPSAVESIZE LNGDBLSIZE +#endif + +#define intsize tysize[TYint] +#define REGSIZE tysize[TYnptr] +#define NPTRSIZE tysize[TYnptr] +#define FPTRSIZE tysize[TYfptr] +#define REGMASK 0xFFFF + +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS || TARGET_OSX +typedef targ_llong targ_ptrdiff_t; /* ptrdiff_t for target machine */ +typedef targ_ullong targ_size_t; /* size_t for the target machine */ +#else +typedef targ_int targ_ptrdiff_t; /* ptrdiff_t for target machine */ +typedef targ_uns targ_size_t; /* size_t for the target machine */ +#endif + +/* Enable/disable various features + (Some features may no longer work the old way when compiled out, + I don't test the old ways once the new way is set.) + */ +#define THUNKS 1 /* use thunks for virtual functions */ +#define SEPNEWDEL 1 // new/delete are not called within the ctor/dtor, + // they are separate +#define VBTABLES 1 // use Microsoft object model +#define UNICODE 1 // support Unicode (wchar_t is unsigned short) +#define DLCMSGS 0 // if 1, have all messages in a file +#define NEWMANGLE TARGET_WINDOS // use MS name mangling scheme +#define NEWTEMPMANGLE (!(config.flags4 & CFG4oldtmangle)) // do new template mangling +#define USEDLLSHELL _WINDLL +#define FARCLASSES 1 // support near/far classes +#define MFUNC (I32) //0 && config.exe == EX_NT) // member functions are TYmfunc +#define AUTONEST 0 // overlap storage of nested auto's +#define CV3 0 // 1 means support CV3 debug format + +/* Object module format + */ +#ifndef OMFOBJ +#define OMFOBJ TARGET_WINDOS +#endif +#ifndef ELFOBJ +#define ELFOBJ (TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS) +#endif +#ifndef MACHOBJ +#define MACHOBJ TARGET_OSX +#endif + +#define TOOLKIT_H + +/* Masks so we can easily check size */ +#define CHARMASK (0xFFL) +#define SHORTMASK (0xFFFFL) +#define INTMASK SHORTMASK +#define LONGMASK 0xFFFFFFFF + +/* Common constants often checked for */ +#if LONGLONG +#define LLONGMASK 0xFFFFFFFFFFFFFFFFLL +#define ZEROLL 0LL +#define MINLL 0x8000000000000000LL +#define MAXLL 0x7FFFFFFFFFFFFFFFLL +#else +#define LLONGMASK 0xFFFFFFFFLL +#define ZEROLL 0L +#define MINLL 0x80000000 +#define MAXLL 0x7FFFFFFF +#endif + +#ifndef MEMMODELS +#define LARGEDATA (config.memmodel & 6) +#define LARGECODE (config.memmodel & 5) + +#define Smodel 0 /* 64k code, 64k data */ +#define Mmodel 1 /* large code, 64k data */ +#define Cmodel 2 /* 64k code, large data */ +#define Lmodel 3 /* large code, large data */ +#define Vmodel 4 /* large code, large data, vcm */ +#define MEMMODELS 5 /* number of memory models */ +#endif + +/* Segments */ +#define CODE 1 /* code segment */ +#define DATA 2 /* initialized data */ +#define CDATA 3 /* constant data */ +#define UDATA 4 /* uninitialized data */ +#define UNKNOWN 0x7FFF // unknown segment +#define DGROUPIDX 1 /* group index of DGROUP */ + +#define KEEPBITFIELDS 0 /* 0 means code generator cannot handle bit fields, */ + /* so replace them with shifts and masks */ + +#define REGMAX 29 // registers are numbered 0..10 + +typedef unsigned tym_t; // data type big enough for type masks +typedef int SYMIDX; // symbol table index + +#if 0 +#if defined(__DMC__) && __DMC__ < 0x81e +typedef int bool; +#endif +#define bool int +#endif + +#define _chkstack() (void)0 + +/* For 32 bit compilations, we don't need far keyword */ +#if 1 +#define far +#define _far +#define __far +#define __cs +#define __ss +#define near +#define _near +#define __near +#endif + +// gcc defines this for us, dmc doesn't, so look for it's __I86__ +#if ! (defined(LITTLE_ENDIAN) || defined(BIG_ENDIAN) ) +#if defined(__I86__) || defined(i386) || defined(__x86_64__) +#define LITTLE_ENDIAN 1 +#else +#error unknown platform, so unknown endianness +#endif +#endif + +#if _WINDLL +#define COPYRIGHT "Copyright © 2001 Digital Mars" +#else +#ifdef DEBUG +#define COPYRIGHT "Copyright (C) Digital Mars 2000-2010. All Rights Reserved.\n\ +Written by Walter Bright\n\ +*****BETA TEST VERSION*****" +#else +#if linux +#define COPYRIGHT "Copyright (C) Digital Mars 2000-2010. All Rights Reserved.\n\ +Written by Walter Bright, Linux version by Pat Nelson" +#else +#define COPYRIGHT "Copyright (C) Digital Mars 2000-2010. All Rights Reserved.\n\ +Written by Walter Bright" +#endif +#endif +#endif + +/********************************** + * Configuration + */ + +/* Linkage type */ +typedef enum LINKAGE +{ + LINK_C, /* C style */ + LINK_CPP, /* C++ style */ + LINK_PASCAL, /* Pascal style */ + LINK_FORTRAN, + LINK_SYSCALL, + LINK_STDCALL, + LINK_D, // D code + LINK_MAXDIM /* array dimension */ +} linkage_t; + + +// This part of the configuration is saved in the precompiled header for use +// in comparing to make sure it hasn't changed. + +struct Config +{ + char language; // 'C' = C, 'D' = C++ +//#define CPP (config.language == 'D') + char version[8]; // = VERSION + char exetype[3]; // distinguish exe types so PH + // files are distinct (= SUFFIX) + + char target_cpu; // instruction selection + char target_scheduler; // instruction scheduling (normally same as selection) +#define TARGET_8086 0 +#define TARGET_80286 2 +#define TARGET_80386 3 +#define TARGET_80486 4 +#define TARGET_Pentium 5 +#define TARGET_PentiumMMX 6 +#define TARGET_PentiumPro 7 +#define TARGET_PentiumII 8 +#define TARGET_AMD64 9 (32 or 64 bit mode) + + short versionint; // intermediate file version (= VERSIONINT) + int defstructalign; // struct alignment specified by command line + short hxversion; // HX version number + char fulltypes; +#define CVNONE 0 // No symbolic info +#define CVOLD 1 // Codeview 1 symbolic info +#define CV4 2 // Codeview 4 symbolic info +#define CVSYM 3 // Symantec format +#define CVTDB 4 // Symantec format written to file +#define CVDWARF_C 5 // Dwarf in C format +#define CVDWARF_D 6 // Dwarf in D format +#define CVSTABS 7 // Elf Stabs in C format + + unsigned wflags; // flags for Windows code generation +# define WFwindows 1 // generating code for Windows app or DLL +# define WFdll 2 // generating code for Windows DLL +# define WFincbp 4 // mark far stack frame with inc BP / dec BP +# define WFloadds 8 // assume __loadds for all functions +# define WFexpdef 0x10 // generate export definition records for + // exported functions +# define WFss 0x20 // load DS from SS +# define WFreduced 0x40 // skip DS load for non-exported functions +# define WFdgroup 0x80 // load DS from DGROUP +# define WFexport 0x100 // assume __export for all far functions +# define WFds 0x200 // load DS from DS +# define WFmacros 0x400 // define predefined windows macros +# define WFssneds 0x800 // SS != DS +# define WFthunk 0x1000 // use fixups instead of direct ref to CS +# define WFsaveds 0x2000 // use push/pop DS for far functions +# define WFdsnedgroup 0x4000 // DS != DGROUP +# define WFexe 0x8000 // generating code for Windows EXE + + bool fpxmmregs; // use XMM registers for floating point + char inline8087; /* 0: emulator + 1: IEEE 754 inline 8087 code + 2: fast inline 8087 code + */ + short memmodel; // 0:S,X,N,F, 1:M, 2:C, 3:L, 4:V + unsigned exe; // target operating system +#define EX_DOSX 1 // DOSX 386 program +#define EX_ZPM 2 // ZPM 286 program +#define EX_RATIONAL 4 // RATIONAL 286 program +#define EX_PHARLAP 8 // PHARLAP 386 program +#define EX_COM 0x10 // MSDOS .COM program +//#define EX_WIN16 0x20 // Windows 3.x 16 bit program +#define EX_OS2 0x40 // OS/2 2.0 32 bit program +#define EX_OS1 0x80 // OS/2 1.x 16 bit program +#define EX_NT 0x100 // NT +#define EX_MZ 0x200 // MSDOS real mode program +#define EX_XENIX 0x400 +#define EX_SCOUNIX 0x800 +#define EX_UNIXSVR4 0x1000 +#define EX_LINUX 0x2000 +#define EX_WIN64 0x4000 // AMD64 and Windows (64 bit mode) +#define EX_LINUX64 0x8000 // AMD64 and Linux (64 bit mode) +#define EX_OSX 0x10000 +#define EX_OSX64 0x20000 +#define EX_FREEBSD 0x40000 +#define EX_FREEBSD64 0x80000 +#define EX_SOLARIS 0x100000 +#define EX_SOLARIS64 0x200000 +#define EX_OPENBSD 0x400000 +#define EX_OPENBSD64 0x800000 + +#define EX_flat (EX_OS2 | EX_NT | EX_LINUX | EX_WIN64 | EX_LINUX64 | \ + EX_OSX | EX_OSX64 | EX_FREEBSD | EX_FREEBSD64 | \ + EX_OPENBSD | EX_OPENBSD64 | \ + EX_SOLARIS | EX_SOLARIS64) +#define EX_dos (EX_DOSX | EX_ZPM | EX_RATIONAL | EX_PHARLAP | \ + EX_COM | EX_MZ /*| EX_WIN16*/) + +/* CFGX: flags ignored in precompiled headers + * CFGY: flags copied from precompiled headers into current config + */ + unsigned flags; +#define CFGuchar 1 // chars are unsigned +#define CFGsegs 2 // new code seg for each far func +#define CFGtrace 4 // output trace functions +#define CFGglobal 8 // make all static functions global +#define CFGstack 0x20 // add stack overflow checking +#define CFGalwaysframe 0x40 // always generate stack frame +#define CFGnoebp 0x80 // do not use EBP as general purpose register +#define CFGromable 0x100 // put switch tables in code segment +#define CFGeasyomf 0x200 // generate Pharlap Easy-OMF format +#define CFGfarvtbls 0x800 // store vtables in far segments +#define CFGnoinlines 0x1000 // do not inline functions +#define CFGnowarning 0x8000 // disable warnings +#define CFGX (CFGnowarning) + unsigned flags2; +#define CFG2comdat 1 // use initialized common blocks +#define CFG2nodeflib 2 // no default library imbedded in OBJ file +#define CFG2browse 4 // generate browse records +#define CFG2dyntyping 8 // generate dynamic typing information +#define CFG2fulltypes 0x10 // don't optimize CV4 class info +#define CFG2warniserr 0x20 // treat warnings as errors +#define CFG2phauto 0x40 // automatic precompiled headers +#define CFG2phuse 0x80 // use precompiled headers +#define CFG2phgen 0x100 // generate precompiled header +#define CFG2once 0x200 // only include header files once +#define CFG2hdrdebug 0x400 // generate debug info for header +#define CFG2phautoy 0x800 // fast build precompiled headers +#define CFG2noobj 0x1000 // we are not generating a .OBJ file +#define CFG2noerrmax 0x4000 // no error count maximum +#define CFG2expand 0x8000 // expanded output to list file +#define CFG2seh 0x10000 // use Win32 SEH to support any exception handling +#define CFGX2 (CFG2warniserr | CFG2phuse | CFG2phgen | CFG2phauto | \ + CFG2once | CFG2hdrdebug | CFG2noobj | CFG2noerrmax | \ + CFG2expand | CFG2nodeflib) + unsigned flags3; +#define CFG3ju 1 // char == unsigned char +#define CFG3eh 4 // generate exception handling stuff +#define CFG3strcod 8 // strings are placed in code segment +#define CFG3eseqds 0x10 // ES == DS at all times +#define CFG3ptrchk 0x20 // generate pointer validation code +#define CFG3strictproto 0x40 // strict prototyping +#define CFG3autoproto 0x80 // auto prototyping +#define CFG3rtti 0x100 // add RTTI support +#define CFG3relax 0x200 // relaxed type checking (C only) +#define CFG3cpp 0x400 // C++ compile +#define CFG3igninc 0x800 // ignore standard include directory +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define CFG3mars 0x1000 // use mars libs and headers +#define NO_FAR (TRUE) // always ignore __far and __huge keywords +#else +#define CFG3nofar 0x1000 // ignore __far and __huge keywords +#define NO_FAR (config.flags3 & CFG3nofar) +#endif +#define CFG3noline 0x2000 // do not output #line directives +#define CFG3comment 0x4000 // leave comments in preprocessed output +#define CFG3cppcomment 0x8000 // allow C++ style comments +#define CFG3wkfloat 0x10000 // make floating point references weak externs +#define CFG3digraphs 0x20000 // support ANSI C++ digraphs +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define CFG3semirelax 0x40000 // moderate relaxed type checking +#endif +#define CFG3pic 0x80000 // position independent code +#define CFGX3 (CFG3strcod | CFG3ptrchk) + + unsigned flags4; +#define CFG4speed 1 // optimized for speed +#define CFG4space 2 // optimized for space +#define CFG4optimized (CFG4speed | CFG4space) +#define CFG4allcomdat 4 // place all functions in COMDATs +#define CFG4fastfloat 8 // fast floating point (-ff) +#define CFG4fdivcall 0x10 // make function call for FDIV opcodes +#define CFG4tempinst 0x20 // instantiate templates for undefined functions +#define CFG4oldstdmangle 0x40 // do stdcall mangling without @ +#define CFG4pascal 0x80 // default to pascal linkage +#define CFG4stdcall 0x100 // default to std calling convention +#define CFG4cacheph 0x200 // cache precompiled headers in memory +#define CFG4alternate 0x400 // if alternate digraph tokens +#define CFG4bool 0x800 // support 'bool' as basic type +#define CFG4wchar_t 0x1000 // support 'wchar_t' as basic type +#define CFG4notempexp 0x2000 // no instantiation of template functions +#define CFG4anew 0x4000 // allow operator new[] and delete[] overloading +#define CFG4oldtmangle 0x8000 // use old template name mangling +#define CFG4dllrtl 0x10000 // link with DLL RTL +#define CFG4noemptybaseopt 0x40000 // turn off empty base class optimization +#define CFG4stackalign CFG4speed // align stack to 8 bytes +#define CFG4nowchar_t 0x80000 // use unsigned short name mangling for wchar_t +#define CFG4forscope 0x100000 // new C++ for scoping rules +#define CFG4warnccast 0x200000 // warn about C style casts +#define CFG4adl 0x400000 // argument dependent lookup +#define CFG4enumoverload 0x800000 // enum overloading +#define CFG4implicitfromvoid 0x1000000 // allow implicit cast from void* to T* +#define CFG4dependent 0x2000000 // dependent / non-dependent lookup +#define CFG4wchar_is_long 0x4000000 // wchar_t is 4 bytes +#define CFG4underscore 0x8000000 // prepend _ for C mangling +#define CFGX4 (CFG4optimized | CFG4fastfloat | CFG4fdivcall | \ + CFG4tempinst | CFG4cacheph | CFG4notempexp | \ + CFG4stackalign | CFG4dependent) +#define CFGY4 (CFG4nowchar_t | CFG4noemptybaseopt | CFG4adl | \ + CFG4enumoverload | CFG4implicitfromvoid | \ + CFG4wchar_is_long | CFG4underscore) + + unsigned flags5; +#define CFG5debug 1 // compile in __debug code +#define CFG5in 2 // compile in __in code +#define CFG5out 4 // compile in __out code +#define CFG5invariant 8 // compile in __invariant code + +#if HTOD + unsigned htodFlags; // configuration for htod +#define HTODFinclude 1 // -hi drill down into #include files +#define HTODFsysinclude 2 // -hs drill down into system #include files +#define HTODFtypedef 4 // -ht drill down into typedefs +#define HTODFcdecl 8 // -hc skip C declarations as comments +#endif + char ansi_c; // strict ANSI C + // 89 for ANSI C89, 99 for ANSI C99 + char asian_char; /* 0: normal, 1: Japanese, 2: Chinese */ + /* and Taiwanese, 3: Korean */ + unsigned threshold; // data larger than threshold is assumed to + // be far (16 bit models only) +#define THRESHMAX 0xFFFF // if threshold == THRESHMAX, all data defaults + // to near + enum LINKAGE linkage; // default function call linkage +}; + +// Configuration that is not saved in precompiled header + +typedef struct Configv +{ + char addlinenumbers; // put line number info in .OBJ file + char verbose; // 0: compile quietly (no messages) + // 1: show progress to DLL (default) + // 2: full verbosity + char *csegname; // code segment name + char *deflibname; // default library name + enum LANG language; // message language + int errmax; // max error count +} Configv; + +struct Classsym; +struct Symbol; +struct LIST; +struct elem; + +typedef unsigned regm_t; // Register mask type +struct immed_t +{ targ_size_t value[REGMAX]; // immediate values in registers + regm_t mval; // Mask of which values in regimmed.value[] are valid +}; + + +struct cse_t +{ elem *value[REGMAX]; // expression values in registers + regm_t mval; // mask of which values in value[] are valid + regm_t mops; // subset of mval that contain common subs that need + // to be stored in csextab[] if they are destroyed +}; + +struct con_t +{ cse_t cse; // CSEs in registers + immed_t immed; // immediate values in registers + regm_t mvar; // mask of register variables + regm_t mpvar; // mask of SCfastpar register variables + regm_t indexregs; // !=0 if more than 1 uncommitted index register + regm_t used; // mask of registers used + regm_t params; // mask of registers which still contain register + // function parameters +}; + +/********************************* + * Bootstrap complex types. + */ + +#include "bcomplex.h" + +/********************************* + * Union of all data types. Storage allocated must be the right + * size of the data on the TARGET, not the host. + */ + +struct Cent +{ + targ_ullong lsw; + targ_ullong msw; +}; + +union eve +{ + targ_char Vchar; + targ_schar Vschar; + targ_uchar Vuchar; + targ_short Vshort; + targ_ushort Vushort; + targ_int Vint; // also used for tmp numbers (FLtmp) + targ_uns Vuns; + targ_long Vlong; + targ_ulong Vulong; + targ_llong Vllong; + targ_ullong Vullong; + Cent Vcent; + targ_float Vfloat; + targ_double Vdouble; + targ_ldouble Vldouble; + Complex_f Vcfloat; // 2x float + Complex_d Vcdouble; // 2x double + Complex_ld Vcldouble; // 2x long double + targ_size_t Vpointer; + targ_ptrdiff_t Vptrdiff; + targ_uchar Vreg; // register number for OPreg elems + struct // 48 bit 386 far pointer + { targ_long Voff; + targ_ushort Vseg; + } Vfp; + struct + { + targ_size_t Voffset;// offset from symbol + Symbol *Vsym; // pointer to symbol table + union + { struct PARAM *Vtal; // template-argument-list for SCfunctempl, + // used only to transmit it to cpp_overload() + LIST *Erd; // OPvar: reaching definitions + } spu; + } sp; + struct + { + targ_size_t Voffset;// member pointer offset + Classsym *Vsym; // struct tag + elem *ethis; // OPrelconst: 'this' for member pointer + } sm; + struct + { + targ_size_t Voffset;// offset from string + char *Vstring; // pointer to string (OPstring or OPasm) + targ_size_t Vstrlen;// length of string + } ss; + struct + { + elem *Eleft; // left child for unary & binary nodes + elem *Eright; // right child for binary nodes + Symbol *Edtor; // OPctor: destructor + } eop; +#if MARS + struct + { + elem *Eleft; // left child for OPddtor + void *Edecl; // VarDeclaration being constructed + } ed; // OPdctor,OPddtor +#endif +}; // variants for each type of elem + +// Symbols + +#ifdef DEBUG +#define IDSYMBOL IDsymbol, +#else +#define IDSYMBOL +#endif + +#if SCPP +#define SYMBOLZERO 0,0,0, +#elif MARS +#define SYMBOLZERO 0,0, +#elif AUTONEST +#define SYMBOLZERO 0,0, +#else +#define SYMBOLZERO +#endif + +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define UNIXFIELDS (unsigned)-1,(unsigned)-1,0,0, +#elif TARGET_OSX +#define UNIXFIELDS (unsigned)-1,(unsigned)-1,0,0,0, +#else +#define UNIXFIELDS +#endif + +typedef unsigned SYMFLGS; +#if MARS +#define SYM_PREDEF_SZ 40 +#else +#define SYM_PREDEF_SZ 22 +#endif + +#define SYMBOLY(fl,regsaved,name,flags) \ + {IDSYMBOL \ + (symbol *)0,(symbol *)0,(symbol *)0,(dt_t *)0,(type *)0,{0},\ + SYMBOLZERO\ + UNIXFIELDS\ + SCextern,(fl),(flags),0,0,0,0,0,0,0,{0},(regsaved),{name}} + +/********************************** + * Storage classes + * This macro is used to generate parallel tables and the enum values. + */ + +#define ENUMSCMAC \ + X(unde, SCEXP|SCKEP|SCSCT) /* undefined */ \ + X(auto, SCEXP|SCSS|SCRD ) /* automatic (stack) */ \ + X(static, SCEXP|SCKEP|SCSCT) /* statically allocated */ \ + X(thread, SCEXP|SCKEP ) /* thread local */ \ + X(extern, SCEXP|SCKEP|SCSCT) /* external */ \ + X(register, SCEXP|SCSS|SCRD ) /* registered variable */ \ + X(pseudo, SCEXP ) /* pseudo register variable */ \ + X(global, SCEXP|SCKEP|SCSCT) /* top level global definition */ \ + X(comdat, SCEXP|SCKEP|SCSCT) /* initialized common block */ \ + X(parameter,SCEXP|SCSS ) /* function parameter */ \ + X(regpar, SCEXP|SCSS ) /* function register parameter */ \ + X(fastpar, SCEXP|SCSS ) /* function parameter passed in register */ \ + X(typedef, 0 ) /* type definition */ \ + X(explicit, 0 ) /* explicit */ \ + X(mutable, 0 ) /* mutable */ \ + X(tmp, SCEXP|SCSS|SCRD ) /* compiler generated temporary (just like SCauto \ + but doesn't overlay other SCauto's in scoping) */ \ + X(label, 0 ) /* goto label */ \ + X(struct, SCKEP ) /* struct/class/union tag name */ \ + X(enum, 0 ) /* enum tag name */ \ + X(field, SCEXP|SCKEP ) /* bit field of struct or union */ \ + X(const, SCEXP|SCSCT ) /* constant integer */ \ + X(member, SCEXP|SCKEP|SCSCT) /* member of struct or union */ \ + X(anon, 0 ) /* member of anonymous union */ \ + X(inline, SCEXP|SCKEP ) /* for inline functions */ \ + X(sinline, SCEXP|SCKEP ) /* for static inline functions */ \ + X(einline, SCEXP|SCKEP ) /* for extern inline functions */ \ + X(overload, SCEXP ) /* for overloaded function names */ \ + X(friend, 0 ) /* friend of a class */ \ + X(virtual, 0 ) /* virtual function */ \ + X(locstat, SCEXP|SCSCT ) /* static, but local to a function */ \ + X(template, 0 ) /* class template */ \ + X(functempl,0 ) /* function template */ \ + X(ftexpspec,0 ) /* function template explicit specialization */ \ + X(linkage, 0 ) /* function linkage symbol */ \ + X(public, SCEXP|SCKEP|SCSCT) /* generate a pubdef for this */ \ + X(comdef, SCEXP|SCKEP|SCSCT) /* uninitialized common block */ \ + X(bprel, SCEXP|SCSS ) /* variable at fixed offset from frame pointer */ \ + X(namespace,0 ) /* namespace */ \ + X(alias, 0 ) /* alias to another symbol */ \ + X(funcalias,0 ) /* alias to another function symbol */ \ + X(memalias,0 ) /* alias to base class member */ \ + X(stack, SCEXP|SCSS ) /* offset from stack pointer (not frame pointer) */ \ + X(adl, 0 ) /* list of ADL symbols for overloading */ \ + + //X(union,SCKEP) /* union tag name */ + //X(class,SCKEP) /* class tag name */ + +#define ClassInline(c) ((c) == SCinline || (c) == SCsinline || (c) == SCeinline) +#define SymInline(s) ClassInline((s)->Sclass) + +enum SC { + #define X(a,b) SC##a, + ENUMSCMAC // generate the enum values + SCMAX // array dimension + #undef X +}; + +#define TAG_ARGUMENTS + +/******************************* + * Swap two integers. + */ + +inline void swap(int *a,int *b) +{ int tmp; + + tmp = *a; + *a = *b; + *b = tmp; +} + + +#endif /* CDEF_H */ diff --git a/backend/cdeflnx.h b/backend/cdeflnx.h new file mode 100644 index 00000000..5d1bd12e --- /dev/null +++ b/backend/cdeflnx.h @@ -0,0 +1,85 @@ +// Copyright (C) ?-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include + +#define M_UNIX 1 +#define IMPLIED_PRAGMA_ONCE 1 +#define MEMMODELS 1 +#if __GNUC__ +#define __SC__ 0 +#define _MSC_VER 0 +#endif + +#define ERRSTREAM stderr + +#define isleadbyte(c) 0 + +#define __cdecl __attribute__ ((__cdecl__)) +#define _cdecl __attribute__ ((__cdecl__)) +#define __stdcall __attribute__ ((__stdcall__)) + +#define __pascal +#define __near +#define _near +#define __far +#define _far +#define __ss +#define __cs + +#if SCPP +// Need to define the token enum before any refs +#define TOKENS_ONLY 1 +#include "token.h" +#undef TOKEN_H +#undef TOKENS_ONLY +#define TOKENS_ONLY 0 +#endif + +// +// Error messages generated by msgsx.c +// + +//#include "msgs2.h" + +char * strupr(char *); + +// +// Attributes +// + +// Types of attributes +#define ATTR_LINKMOD 0x0001 // link modifier +#define ATTR_TYPEMOD 0x0002 // basic type modifier +#define ATTR_FUNCINFO 0x0004 // function information +#define ATTR_DATAINFO 0x0008 // data information +#define ATTR_TRANSU 0x0010 // transparent union +#define ATTR_IGNORED 0x0020 // attribute can be ignored +#define ATTR_WARNING 0x0040 // attribute was ignored +#define ATTR_SEGMENT 0x0080 // segment secified + + +// attribute location in code +#define ALOC_DECSTART 0x001 // start of declaration +#define ALOC_SYMDEF 0x002 // symbol defined +#define ALOC_PARAM 0x004 // follows function parameter +#define ALOC_FUNC 0x008 // follows function declaration + +#define ATTR_LINK_MODIFIERS (mTYconst|mTYvolatile|mTYcdecl|mTYstdcall) +#define ATTR_CAN_IGNORE(a) \ + (((a) & (ATTR_LINKMOD|ATTR_TYPEMOD|ATTR_FUNCINFO|ATTR_DATAINFO|ATTR_TRANSU)) == 0) +#define LNX_CHECK_ATTRIBUTES(a,x) assert(((a) & ~(x|ATTR_IGNORED|ATTR_WARNING)) == 0) + +#if SCPP +#include "optdata.h" +#endif + +#define TRIGRAPHS (ANSI || OPT_IS_SET(OPTtrigraphs)) diff --git a/backend/cg.c b/backend/cg.c new file mode 100644 index 00000000..4fdde086 --- /dev/null +++ b/backend/cg.c @@ -0,0 +1,61 @@ +// Copyright (C) 1984-1995 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include +#include +#include +#include + +#include "cc.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "filespec.h" + +///////////////////// GLOBALS ///////////////////// + +#include "fltables.c" + +targ_size_t Poffset; /* size of func parameter variables */ +targ_size_t framehandleroffset; // offset of C++ frame handler +#if TARGET_OSX +targ_size_t localgotoffset; // offset of where localgot refers to +#endif + +int cseg = CODE; // current code segment + // (negative values mean it is the negative + // of the public name index of a COMDAT) + +/* Stack offsets */ +targ_size_t localsize, /* amt subtracted from SP for local vars */ + Toff, /* base for temporaries */ + Poff,Aoff; // comsubexps, params, regs, autos + +/* The following are initialized for the 8088. cod3_set32() or cod3_set64() + * will change them as appropriate. + */ +int BPRM = 6; /* R/M value for [BP] or [EBP] */ +regm_t fregsaved = mBP | mSI | mDI; // mask of registers saved across + // function calls + // (add in mBX for I32) +regm_t FLOATREGS = FLOATREGS_16; +regm_t FLOATREGS2 = FLOATREGS2_16; +regm_t DOUBLEREGS = DOUBLEREGS_16; + +symbol *localgot; // reference to GOT for this function +symbol *tls_get_addr_sym; // function __tls_get_addr + +#if TARGET_OSX +int STACKALIGN = 16; +#else +int STACKALIGN = 0; +#endif diff --git a/backend/cg87.c b/backend/cg87.c new file mode 100644 index 00000000..67c0cbe1 --- /dev/null +++ b/backend/cg87.c @@ -0,0 +1,3638 @@ +// Copyright (C) 1987-1995 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "global.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +// Constants that the 8087 supports directly +// BUG: rewrite for 80 bit long doubles +#define PI 3.14159265358979323846 +#define LOG2 0.30102999566398119521 +#define LN2 0.6931471805599453094172321 +#define LOG2T 3.32192809488736234787 +#define LOG2E 1.4426950408889634074 /* 1/LN2 */ + +#define FWAIT 0x9B /* FWAIT opcode */ + +/* Mark variable referenced by e as not a register candidate */ +#define notreg(e) ((e)->EV.sp.Vsym->Sflags &= ~GTregcand) + +/* Generate the appropriate ESC instruction */ +#define ESC(MF,b) (0xD8 + ((MF) << 1) + (b)) +enum MF +{ // Values for MF + MFfloat = 0, + MFlong = 1, + MFdouble = 2, + MFword = 3 +}; + +NDP _8087elems[8]; // 8087 stack +NDP ndp_zero; + +int stackused = 0; /* number of items on the 8087 stack */ + +/********************************* + */ + +struct Dconst +{ + int round; + symbol *roundto0; + symbol *roundtonearest; +}; + +static Dconst oldd; + +#define NDPP 0 // print out debugging info +#define NOSAHF (I64 || config.fpxmmregs) // can't use SAHF instruction + +code *loadComplex(elem *e); +code *opmod_complex87(elem *e,regm_t *pretregs); +code *opass_complex87(elem *e,regm_t *pretregs); +code * genf2(code *c,unsigned op,unsigned rm); + +#define CW_roundto0 0xFBF +#define CW_roundtonearest 0x3BF + +STATIC code *genrnd(code *c, short cw); + +/********************************** + * When we need to temporarilly save 8087 registers, we record information + * about the save into an array of NDP structs: + */ + +NDP *NDP::save = NULL; +int NDP::savemax = 0; /* # of entries in NDP::save[] */ +int NDP::savetop = 0; /* # of entries used in NDP::save[] */ + +#ifdef DEBUG +#define NDPSAVEINC 2 /* flush reallocation bugs */ +#else +#define NDPSAVEINC 8 /* allocation chunk sizes */ +#endif + +/**************************************** + * Store/load to ndp save location i + */ + +code *ndp_fstp(code *c, int i, tym_t ty) +{ unsigned grex = I64 ? (REX_W << 16) : 0; + switch (tybasic(ty)) + { + case TYfloat: + case TYifloat: + case TYcfloat: + c = genc1(c,0xD9,grex | modregrm(2,3,BPRM),FLndp,i); // FSTP m32real i[BP] + break; + + case TYdouble: + case TYdouble_alias: + case TYidouble: + case TYcdouble: + c = genc1(c,0xDD,grex | modregrm(2,3,BPRM),FLndp,i); // FSTP m64real i[BP] + break; + + case TYldouble: + case TYildouble: + case TYcldouble: + c = genc1(c,0xDB,grex | modregrm(2,7,BPRM),FLndp,i); // FSTP m80real i[BP] + break; + + default: + assert(0); + } + return c; +} + +code *ndp_fld(code *c, int i, tym_t ty) +{ unsigned grex = I64 ? (REX_W << 16) : 0; + switch (tybasic(ty)) + { + case TYfloat: + case TYifloat: + case TYcfloat: + c = genc1(c,0xD9,grex | modregrm(2,0,BPRM),FLndp,i); + break; + + case TYdouble: + case TYdouble_alias: + case TYidouble: + case TYcdouble: + c = genc1(c,0xDD,grex | modregrm(2,0,BPRM),FLndp,i); + break; + + case TYldouble: + case TYildouble: + case TYcldouble: + c = genc1(c,0xDB,grex | modregrm(2,5,BPRM),FLndp,i); // FLD m80real i[BP] + break; + + default: + assert(0); + } + return c; +} + +/************************** + * Return index of empty slot in NDP::save[]. + */ + +STATIC int getemptyslot() +{ int i; + + for (i = 0; i < NDP::savemax; i++) + if (NDP::save[i].e == NULL) + goto L1; + /* Out of room, reallocate NDP::save[] */ + NDP::save = (NDP *)mem_realloc(NDP::save, + (NDP::savemax + NDPSAVEINC) * sizeof(*NDP::save)); + /* clear out new portion of NDP::save[] */ + memset(NDP::save + NDP::savemax,0,NDPSAVEINC * sizeof(*NDP::save)); + i = NDP::savemax; + NDP::savemax += NDPSAVEINC; + + L1: if (i >= NDP::savetop) + NDP::savetop = i + 1; + return i; +} + +/********************************* + * Pop 8087 stack. + */ + +#undef pop87 + +void pop87( +#ifdef DEBUG + int line, const char *file +#endif + ) +#ifdef DEBUG +#define pop87() pop87(__LINE__,__FILE__) +#endif +{ + int i; + +#if NDPP + dbg_printf("pop87(%s(%d): stackused=%d)\n", file, line, stackused); +#endif + --stackused; + assert(stackused >= 0); + for (i = 0; i < arraysize(_8087elems) - 1; i++) + _8087elems[i] = _8087elems[i + 1]; + /* end of stack is nothing */ + _8087elems[arraysize(_8087elems) - 1] = ndp_zero; +} + +/******************************* + * Push 8087 stack. Generate and return any code + * necessary to preserve anything that might run off the end of the stack. + */ + +#undef push87 + +#ifdef DEBUG +code *push87(int line, const char *file); +code *push87() { return push87(__LINE__,__FILE__); } +#endif + +code *push87( +#ifdef DEBUG + int line, const char *file +#endif + ) +#ifdef DEBUG +#define push87() push87(__LINE__,__FILE__) +#endif +{ + code *c; + int i; + + c = CNIL; + // if we would lose the top register off of the stack + if (_8087elems[7].e != NULL) + { + i = getemptyslot(); + NDP::save[i] = _8087elems[7]; + c = genf2(c,0xD9,0xF6); // FDECSTP + c = genfwait(c); + c = ndp_fstp(c, i, _8087elems[7].e->Ety); // FSTP i[BP] + assert(stackused == 8); + if (NDPP) dbg_printf("push87() : overflow\n"); + } + else + { +#ifdef DEBUG + if (NDPP) dbg_printf("push87(%s(%d): %d)\n", file, line, stackused); +#endif + stackused++; + assert(stackused <= 8); + } + // Shift the stack up + for (i = 7; i > 0; i--) + _8087elems[i] = _8087elems[i - 1]; + _8087elems[0] = ndp_zero; + return c; +} + +/***************************** + * Note elem e as being in ST(i) as being a value we want to keep. + */ + +#ifdef DEBUG +void note87(elem *e, unsigned offset, int i, int linnum); +void note87(elem *e, unsigned offset, int i) +{ + return note87(e, offset, i, 0); +} +void note87(elem *e, unsigned offset, int i, int linnum) +#define note87(e,offset,i) note87(e,offset,i,__LINE__) +#else +void note87(elem *e, unsigned offset, int i) +#endif +{ +#if NDPP + printf("note87(e = %p.%d, i = %d, stackused = %d, line = %d)\n",e,offset,i,stackused,linnum); +#endif +#if 0 && DEBUG + if (_8087elems[i].e) + printf("_8087elems[%d].e = %p\n",i,_8087elems[i].e); +#endif + //if (i >= stackused) *(char*)0=0; + assert(i < stackused); + _8087elems[i].e = e; + _8087elems[i].offset = offset; +} + +/**************************************************** + * Exchange two entries in 8087 stack. + */ + +void xchg87(int i, int j) +{ + NDP save; + + save = _8087elems[i]; + _8087elems[i] = _8087elems[j]; + _8087elems[j] = save; +} + +/**************************** + * Make sure that elem e is in register ST(i). Reload it if necessary. + * Input: + * i 0..3 8087 register number + * flag 1 don't bother with FXCH + */ + +#ifdef DEBUG +STATIC code * makesure87(elem *e,unsigned offset,int i,unsigned flag,int linnum) +#define makesure87(e,offset,i,flag) makesure87(e,offset,i,flag,__LINE__) +#else +STATIC code * makesure87(elem *e,unsigned offset,int i,unsigned flag) +#endif +{ + code *c; + int j; + +#ifdef DEBUG + if (NDPP) printf("makesure87(e=%p, offset=%d, i=%d, flag=%d, line=%d)\n",e,offset,i,flag,linnum); +#endif + assert(e && i < 4); + c = CNIL; + L1: + if (_8087elems[i].e != e || _8087elems[i].offset != offset) + { +#ifdef DEBUG + if (_8087elems[i].e) + printf("_8087elems[%d].e = %p, .offset = %d\n",i,_8087elems[i].e,_8087elems[i].offset); +#endif + assert(_8087elems[i].e == NULL); + for (j = 0; 1; j++) + { + if (j >= NDP::savetop && e->Eoper == OPcomma) + { + e = e->E2; // try right side + goto L1; + } +#ifdef DEBUG + if (j >= NDP::savetop) + printf("e = %p, NDP::savetop = %d\n",e,NDP::savetop); +#endif + assert(j < NDP::savetop); + //printf("\tNDP::save[%d] = %p, .offset = %d\n", j, NDP::save[j].e, NDP::save[j].offset); + if (e == NDP::save[j].e && offset == NDP::save[j].offset) + break; + } + c = push87(); + c = genfwait(c); + c = ndp_fld(c, j, e->Ety); // FLD j[BP] + if (!(flag & 1)) + { + while (i != 0) + { + genf2(c,0xD9,0xC8 + i); // FXCH ST(i) + i--; + } + } + NDP::save[j] = ndp_zero; // back in 8087 + } + //_8087elems[i].e = NULL; + return c; +} + +/**************************** + * Save in memory any values in the 8087 that we want to keep. + */ + +code *save87() +{ + code *c; + int i; + + c = CNIL; + while (_8087elems[0].e && stackused) + { + /* Save it */ + i = getemptyslot(); + if (NDPP) printf("saving %p in temporary NDP::save[%d]\n",_8087elems[0].e,i); + NDP::save[i] = _8087elems[0]; + + c = genfwait(c); + c = ndp_fstp(c,i,_8087elems[0].e->Ety); // FSTP i[BP] + pop87(); + } + if (c) /* if any stores */ + genfwait(c); /* wait for last one to finish */ + return c; +} + +/****************************************** + * Save any noted values that would be destroyed by n pushes + */ + +code *save87regs(unsigned n) +{ + unsigned j; + unsigned k; + code *c = NULL; + + assert(n <= 7); + j = 8 - n; + if (stackused > j) + { + for (k = 8; k > j; k--) + { + c = genf2(c,0xD9,0xF6); // FDECSTP + c = genfwait(c); + if (k <= stackused) + { int i; + + i = getemptyslot(); + c = ndp_fstp(c, i, _8087elems[k - 1].e->Ety); // FSTP i[BP] + NDP::save[i] = _8087elems[k - 1]; + _8087elems[k - 1] = ndp_zero; + } + } + + for (k = 8; k > j; k--) + { + if (k > stackused) + { c = genf2(c,0xD9,0xF7); // FINCSTP + c = genfwait(c); + } + } + stackused = j; + } + return c; +} + +/***************************************************** + * Save/restore ST0 or ST01 + */ + +void gensaverestore87(regm_t regm, code **csave, code **crestore) +{ + //printf("gensaverestore87(%s)\n", regm_str(regm)); + code *cs1 = *csave; + code *cs2 = *crestore; + assert(regm == mST0 || regm == mST01); + + int i = getemptyslot(); + NDP::save[i].e = el_calloc(); // this blocks slot [i] for the life of this function + cs1 = ndp_fstp(cs1, i, TYldouble); + cs2 = cat(ndp_fld(CNIL, i, TYldouble), cs2); + if (regm == mST01) + { + int j = getemptyslot(); + NDP::save[j].e = el_calloc(); + cs1 = ndp_fstp(cs1, j, TYldouble); + cs2 = cat(ndp_fld(CNIL, j, TYldouble), cs2); + } + *csave = cs1; + *crestore = cs2; +} + +/************************************* + * Find which, if any, slot on stack holds elem e. + */ + +STATIC int cse_get(elem *e, unsigned offset) +{ int i; + + for (i = 0; 1; i++) + { + if (i == stackused) + { + i = -1; + //printf("cse not found\n"); + //elem_print(e); + break; + } + if (_8087elems[i].e == e && + _8087elems[i].offset == offset) + { //printf("cse found %d\n",i); + //elem_print(e); + break; + } + } + return i; +} + +/************************************* + * Reload common subexpression. + */ + +code *comsub87(elem *e,regm_t *pretregs) +{ code *c; + + //printf("comsub87(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + // Look on 8087 stack + int i = cse_get(e, 0); + + if (tycomplex(e->Ety)) + { + unsigned sz = tysize(e->Ety); + int j = cse_get(e, sz / 2); + if (i >= 0 && j >= 0) + { + c = push87(); + c = cat(c, push87()); + c = genf2(c,0xD9,0xC0 + i); // FLD ST(i) + c = genf2(c,0xD9,0xC0 + j + 1); // FLD ST(j + 1) + c = cat(c,fixresult_complex87(e,mST01,pretregs)); + } + else + // Reload + c = loaddata(e,pretregs); + } + else + { + if (i >= 0) + { + c = push87(); + c = genf2(c,0xD9,0xC0 + i); // FLD ST(i) + if (*pretregs & XMMREGS) + c = cat(c,fixresult87(e,mST0,pretregs)); + else + c = cat(c,fixresult(e,mST0,pretregs)); + } + else + // Reload + c = loaddata(e,pretregs); + } + + freenode(e); + return c; +} + + +/************************** + * Generate code to deal with floatreg. + */ + +code * genfltreg(code *c,unsigned opcode,unsigned reg,targ_size_t offset) +{ + floatreg = TRUE; + reflocal = TRUE; + if ((opcode & ~7) == 0xD8) + c = genfwait(c); + return genc1(c,opcode,modregxrm(2,reg,BPRM),FLfltreg,offset); +} + +/******************************* + * Decide if we need to gen an FWAIT. + */ + +code *genfwait(code *c) +{ + if (ADDFWAIT()) + c = gen1(c,FWAIT); + return c; +} + +/*************************************** + * Generate floating point instruction. + */ + +code * genf2(code *c,unsigned op,unsigned rm) +{ + return gen2(genfwait(c),op,rm); +} + +/*************************** + * Put the 8087 flags into the CPU flags. + */ + +STATIC code * cg87_87topsw(code *c) +{ + /* Note that SAHF is not available on some early I64 processors + * and will cause a seg fault + */ + c = cat(c,getregs(mAX)); + if (config.target_cpu >= TARGET_80286) + c = genf2(c,0xDF,0xE0); // FSTSW AX + else + { c = genfltreg(c,0xD8+5,7,0); /* FSTSW floatreg[BP] */ + genfwait(c); /* FWAIT */ + genfltreg(c,0x8A,4,1); /* MOV AH,floatreg+1[BP] */ + } + gen1(c,0x9E); // SAHF + code_orflag(c,CFpsw); + return c; +} + +/*************************** + * Set the PSW based on the state of ST0. + * Input: + * pop if stack should be popped after test + * Returns: + * start of code appended to c. + */ + +STATIC code * genftst(code *c,elem *e,int pop) +{ + if (NOSAHF) + { + c = cat(c,push87()); + c = gen2(c,0xD9,0xEE); // FLDZ + gen2(c,0xDF,0xE9); // FUCOMIP ST1 + pop87(); + if (pop) + { c = genf2(c,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + } + else if (config.flags4 & CFG4fastfloat) // if fast floating point + { + c = genf2(c,0xD9,0xE4); // FTST + c = cg87_87topsw(c); // put 8087 flags in CPU flags + if (pop) + { c = genf2(c,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + } + else if (config.target_cpu >= TARGET_80386) + { + // FUCOMP doesn't raise exceptions on QNANs, unlike FTST + c = cat(c,push87()); + c = gen2(c,0xD9,0xEE); // FLDZ + gen2(c,pop ? 0xDA : 0xDD,0xE9); // FUCOMPP / FUCOMP + pop87(); + if (pop) + pop87(); + cg87_87topsw(c); // put 8087 flags in CPU flags + } + else + { + // Call library function which does not raise exceptions + regm_t regm = 0; + + c = cat(c,callclib(e,CLIBftest,®m,0)); + if (pop) + { c = genf2(c,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + } + return c; +} + +/************************************* + * Determine if there is a special 8087 instruction to load + * constant e. + * Input: + * im 0 load real part + * 1 load imaginary part + * Returns: + * opcode if found + * 0 if not + */ + +unsigned char loadconst(elem *e, int im) +#if __DMC__ +__in +{ + elem_debug(e); + assert(im == 0 || im == 1); +} +__body +#endif +{ + static float fval[7] = + {0.0,1.0,PI,LOG2T,LOG2E,LOG2,LN2}; + static double dval[7] = + {0.0,1.0,PI,LOG2T,LOG2E,LOG2,LN2}; + static long double ldval[7] = +#if __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#define M_PIl 0x1.921fb54442d1846ap+1L // 3.14159 fldpi +#define M_LOG2T_L 0x1.a934f0979a3715fcp+1L // 3.32193 fldl2t +#define M_LOG2El 0x1.71547652b82fe178p+0L // 1.4427 fldl2e +#define M_LOG2_L 0x1.34413509f79fef32p-2L // 0.30103 fldlg2 +#define M_LN2l 0x1.62e42fefa39ef358p-1L // 0.693147 fldln2 + {0.0,1.0,M_PIl,M_LOG2T_L,M_LOG2El,M_LOG2_L,M_LN2l}; +#elif __GNUC__ + // BUG: should get proper 80 bit values for these + #define M_LOG2T_L LOG2T + #define M_LOG2_L LOG2 + {0.0,1.0,M_PIl,M_LOG2T_L,M_LOG2El,M_LOG2_L,M_LN2l}; +#else + {0.0,1.0,M_PI_L,M_LOG2T_L,M_LOG2E_L,M_LOG2_L,M_LN2_L}; +#endif + static char opcode[7 + 1] = + /* FLDZ,FLD1,FLDPI,FLDL2T,FLDL2E,FLDLG2,FLDLN2,0 */ + {0xEE,0xE8,0xEB,0xE9,0xEA,0xEC,0xED,0}; + int i; + targ_float f; + targ_double d; + targ_ldouble ld; + int sz; + int zero; + void *p; + static char zeros[sizeof(long double)]; + + if (im == 0) + { + switch (tybasic(e->Ety)) + { + case TYfloat: + case TYifloat: + case TYcfloat: + f = e->EV.Vfloat; + sz = 4; + p = &f; + break; + + case TYdouble: + case TYdouble_alias: + case TYidouble: + case TYcdouble: + d = e->EV.Vdouble; + sz = 8; + p = &d; + break; + + case TYldouble: + case TYildouble: + case TYcldouble: + ld = e->EV.Vldouble; + sz = 10; + p = &ld; + break; + + default: + assert(0); + } + } + else + { + switch (tybasic(e->Ety)) + { + case TYcfloat: + f = e->EV.Vcfloat.im; + sz = 4; + p = &f; + break; + + case TYcdouble: + d = e->EV.Vcdouble.im; + sz = 8; + p = &d; + break; + + case TYcldouble: + ld = e->EV.Vcldouble.im; + sz = 10; + p = &ld; + break; + + default: + assert(0); + } + } + + // Note that for this purpose, -0 is not regarded as +0, + // since FLDZ loads a +0 + zero = (memcmp(p, zeros, sz) == 0); + if (zero && config.target_cpu >= TARGET_PentiumPro) + return 0xEE; // FLDZ is the only one with 1 micro-op + + // For some reason, these instructions take more clocks + if (config.flags4 & CFG4speed && config.target_cpu >= TARGET_Pentium) + return 0; + + if (zero) + return 0xEE; + + for (i = 1; i < arraysize(fval); i++) + { + switch (sz) + { + case 4: + if (fval[i] != f) + continue; + break; + case 8: + if (dval[i] != d) + continue; + break; + case 10: + if (ldval[i] != ld) + continue; + break; + default: + assert(0); + } + break; + } + return opcode[i]; +} + +/****************************** + * Given the result of an expression is in retregs, + * generate necessary code to return result in *pretregs. + */ + + +code *fixresult87(elem *e,regm_t retregs,regm_t *pretregs) +{ + regm_t regm; + tym_t tym; + code *c1,*c2; + unsigned sz; + + //printf("fixresult87(e = %p, retregs = x%x, *pretregs = x%x)\n", e,retregs,*pretregs); + //printf("fixresult87(e = %p, retregs = %s, *pretregs = %s)\n", e,regm_str(retregs),regm_str(*pretregs)); + assert(!*pretregs || retregs); + c1 = CNIL; + c2 = CNIL; + tym = tybasic(e->Ety); + sz = tysize[tym]; + //printf("tym = x%x, sz = %d\n", tym, sz); + + if (*pretregs & mST01) + return fixresult_complex87(e, retregs, pretregs); + + /* if retregs needs to be transferred into the 8087 */ + if (*pretregs & mST0 && retregs & (mBP | ALLREGS)) + { + assert(sz <= DOUBLESIZE); + if (!I16) + { + + if (*pretregs & mPSW) + { // Set flags + regm_t r = retregs | mPSW; + c1 = fixresult(e,retregs,&r); + } + c2 = push87(); + if (sz == REGSIZE || (I64 && sz == 4)) + { + unsigned reg = findreg(retregs); + c2 = genfltreg(c2,0x89,reg,0); // MOV fltreg,reg + genfltreg(c2,0xD9,0,0); // FLD float ptr fltreg + } + else + { unsigned msreg,lsreg; + + msreg = findregmsw(retregs); + lsreg = findreglsw(retregs); + c2 = genfltreg(c2,0x89,lsreg,0); // MOV fltreg,lsreg + genfltreg(c2,0x89,msreg,4); // MOV fltreg+4,msreg + genfltreg(c2,0xDD,0,0); // FLD double ptr fltreg + } + } + else + { + regm = (sz == FLOATSIZE) ? FLOATREGS : DOUBLEREGS; + regm |= *pretregs & mPSW; + c1 = fixresult(e,retregs,®m); + regm = 0; // don't worry about result from CLIBxxx + c2 = callclib(e, + ((sz == FLOATSIZE) ? CLIBfltto87 : CLIBdblto87), + ®m,0); + } + } + else if (*pretregs & (mBP | ALLREGS) && retregs & mST0) + { unsigned mf; + unsigned reg; + + assert(sz <= DOUBLESIZE); + mf = (sz == FLOATSIZE) ? MFfloat : MFdouble; + if (*pretregs & mPSW && !(retregs & mPSW)) + c1 = genftst(c1,e,0); + /* FSTP floatreg */ + pop87(); + c1 = genfltreg(c1,ESC(mf,1),3,0); + genfwait(c1); + c2 = allocreg(pretregs,®,(sz == FLOATSIZE) ? TYfloat : TYdouble); + if (sz == FLOATSIZE) + { + if (!I16) + c2 = genfltreg(c2,0x8B,reg,0); + else + { c2 = genfltreg(c2,0x8B,reg,REGSIZE); + genfltreg(c2,0x8B,findreglsw(*pretregs),0); + } + } + else + { assert(sz == DOUBLESIZE); + if (I16) + { c2 = genfltreg(c2,0x8B,AX,6); + genfltreg(c2,0x8B,BX,4); + genfltreg(c2,0x8B,CX,2); + genfltreg(c2,0x8B,DX,0); + } + else if (I32) + { c2 = genfltreg(c2,0x8B,reg,REGSIZE); + genfltreg(c2,0x8B,findreglsw(*pretregs),0); + } + else // I64 + { + c2 = genfltreg(c2,0x8B,reg,0); + code_orrex(c2, REX_W); + } + } + } + else if (*pretregs == 0 && retregs == mST0) + { + c1 = genf2(c1,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + else + { if (*pretregs & mPSW) + { if (!(retregs & mPSW)) + { assert(retregs & mST0); + c1 = genftst(c1,e,!(*pretregs & (mST0 | XMMREGS))); // FTST + } + } + if (*pretregs & mST0 && retregs & XMMREGS) + { + assert(sz <= DOUBLESIZE); + unsigned mf = (sz == FLOATSIZE) ? MFfloat : MFdouble; + // MOVD floatreg,XMM? + unsigned reg = findreg(retregs); + c1 = genfltreg(c1,xmmstore(tym),reg - XMM0,0); + c2 = push87(); + c2 = genfltreg(c2,ESC(mf,1),0,0); // FLD float/double ptr fltreg + } + else if (retregs & mST0 && *pretregs & XMMREGS) + { + assert(sz <= DOUBLESIZE); + unsigned mf = (sz == FLOATSIZE) ? MFfloat : MFdouble; + // FSTP floatreg + pop87(); + c1 = genfltreg(c1,ESC(mf,1),3,0); + genfwait(c1); + // MOVD XMM?,floatreg + unsigned reg; + c2 = allocreg(pretregs,®,(sz == FLOATSIZE) ? TYfloat : TYdouble); + c2 = genfltreg(c2,xmmload(tym),reg -XMM0,0); + } + else + assert(!(*pretregs & mST0) || (retregs & mST0)); + } + if (*pretregs & mST0) + note87(e,0,0); + return cat(c1,c2); +} + +/******************************** + * Generate in-line 8087 code for the following operators: + * add + * min + * mul + * div + * cmp + */ + +// Reverse the order that the op is done in +static const char oprev[9] = { -1,0,1,2,3,5,4,7,6 }; + +code *orth87(elem *e,regm_t *pretregs) +{ + unsigned op; + code *c1,*c2,*c3,*c4; + code *cx; + regm_t retregs; + regm_t resregm; + elem *e1; + elem *e2; + int e2oper; + int eoper; + unsigned sz2; + int clib = CLIBMAX; // initialize to invalid value + int reverse = 0; + + //printf("orth87(+e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); +#if 1 // we could be evaluating / for side effects only + assert(*pretregs != 0); +#endif + retregs = mST0; + resregm = mST0; + + e1 = e->E1; + e2 = e->E2; + c3 = CNIL; + c4 = CNIL; + sz2 = tysize(e1->Ety); + if (tycomplex(e1->Ety)) + sz2 /= 2; + + eoper = e->Eoper; + if (eoper == OPmul && e2->Eoper == OPconst && el_toldouble(e->E2) == 2.0L) + { + // Perform "mul 2.0" as fadd ST(0), ST + c1 = codelem(e1,&retregs,FALSE); + c1 = genf2(c1, 0xDC, 0xC0); // fadd ST(0), ST; + c2 = fixresult87(e,mST0,pretregs); // result is in ST(0). + freenode(e2); + return cat(c1,c2); + } + + if (OTrel(eoper)) + eoper = OPeqeq; + #define X(op, ty1, ty2) (((op) << 16) + (ty1) * 256 + (ty2)) + switch (X(eoper, tybasic(e1->Ety), tybasic(e2->Ety))) + { + case X(OPadd, TYfloat, TYfloat): + case X(OPadd, TYdouble, TYdouble): + case X(OPadd, TYdouble_alias, TYdouble_alias): + case X(OPadd, TYldouble, TYldouble): + case X(OPadd, TYldouble, TYdouble): + case X(OPadd, TYdouble, TYldouble): + case X(OPadd, TYifloat, TYifloat): + case X(OPadd, TYidouble, TYidouble): + case X(OPadd, TYildouble, TYildouble): + op = 0; // FADDP + break; + + case X(OPmin, TYfloat, TYfloat): + case X(OPmin, TYdouble, TYdouble): + case X(OPmin, TYdouble_alias, TYdouble_alias): + case X(OPmin, TYldouble, TYldouble): + case X(OPmin, TYldouble, TYdouble): + case X(OPmin, TYdouble, TYldouble): + case X(OPmin, TYifloat, TYifloat): + case X(OPmin, TYidouble, TYidouble): + case X(OPmin, TYildouble, TYildouble): + op = 4; // FSUBP + break; + + case X(OPmul, TYfloat, TYfloat): + case X(OPmul, TYdouble, TYdouble): + case X(OPmul, TYdouble_alias, TYdouble_alias): + case X(OPmul, TYldouble, TYldouble): + case X(OPmul, TYldouble, TYdouble): + case X(OPmul, TYdouble, TYldouble): + case X(OPmul, TYifloat, TYifloat): + case X(OPmul, TYidouble, TYidouble): + case X(OPmul, TYildouble, TYildouble): + case X(OPmul, TYfloat, TYifloat): + case X(OPmul, TYdouble, TYidouble): + case X(OPmul, TYldouble, TYildouble): + case X(OPmul, TYifloat, TYfloat): + case X(OPmul, TYidouble, TYdouble): + case X(OPmul, TYildouble, TYldouble): + op = 1; // FMULP + break; + + case X(OPdiv, TYfloat, TYfloat): + case X(OPdiv, TYdouble, TYdouble): + case X(OPdiv, TYdouble_alias, TYdouble_alias): + case X(OPdiv, TYldouble, TYldouble): + case X(OPdiv, TYldouble, TYdouble): + case X(OPdiv, TYdouble, TYldouble): + case X(OPdiv, TYifloat, TYifloat): + case X(OPdiv, TYidouble, TYidouble): + case X(OPdiv, TYildouble, TYildouble): + op = 6; // FDIVP + break; + + case X(OPmod, TYfloat, TYfloat): + case X(OPmod, TYdouble, TYdouble): + case X(OPmod, TYdouble_alias, TYdouble_alias): + case X(OPmod, TYldouble, TYldouble): + case X(OPmod, TYfloat, TYifloat): + case X(OPmod, TYdouble, TYidouble): + case X(OPmod, TYldouble, TYildouble): + case X(OPmod, TYifloat, TYifloat): + case X(OPmod, TYidouble, TYidouble): + case X(OPmod, TYildouble, TYildouble): + case X(OPmod, TYifloat, TYfloat): + case X(OPmod, TYidouble, TYdouble): + case X(OPmod, TYildouble, TYldouble): + op = (unsigned) -1; + break; + + case X(OPeqeq, TYfloat, TYfloat): + case X(OPeqeq, TYdouble, TYdouble): + case X(OPeqeq, TYdouble_alias, TYdouble_alias): + case X(OPeqeq, TYldouble, TYldouble): + case X(OPeqeq, TYifloat, TYifloat): + case X(OPeqeq, TYidouble, TYidouble): + case X(OPeqeq, TYildouble, TYildouble): + assert(OTrel(e->Eoper)); + assert((*pretregs & mST0) == 0); + c1 = codelem(e1,&retregs,FALSE); + note87(e1,0,0); + resregm = mPSW; + + if (rel_exception(e->Eoper) || config.flags4 & CFG4fastfloat) + { + if (cnst(e2) && !boolres(e2)) + { + if (NOSAHF) + { + c1 = cat(c1,push87()); + c1 = gen2(c1,0xD9,0xEE); // FLDZ + gen2(c1,0xDF,0xF1); // FCOMIP ST1 + pop87(); + } + else + { c1 = genf2(c1,0xD9,0xE4); // FTST + c1 = cg87_87topsw(c1); + } + c2 = genf2(NULL,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + else if (NOSAHF) + { + note87(e1,0,0); + c2 = load87(e2,0,&retregs,e1,-1); + c2 = cat(c2,makesure87(e1,0,1,0)); + resregm = 0; + //c2 = genf2(c2,0xD9,0xC8 + 1); // FXCH ST1 + c2 = gen2(c2,0xDF,0xF1); // FCOMIP ST1 + pop87(); + genf2(c2,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + else + { + c2 = load87(e2, 0, pretregs, e1, 3); // FCOMPP + } + } + else + { + if (cnst(e2) && !boolres(e2) && + config.target_cpu < TARGET_80386) + { + regm_t regm = 0; + + c2 = callclib(e,CLIBftest0,®m,0); + pop87(); + } + else + { + note87(e1,0,0); + c2 = load87(e2,0,&retregs,e1,-1); + c2 = cat(c2,makesure87(e1,0,1,0)); + resregm = 0; + if (NOSAHF) + { + c3 = gen2(CNIL,0xDF,0xE9); // FUCOMIP ST1 + pop87(); + genf2(c3,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + else if (config.target_cpu >= TARGET_80386) + { + c3 = gen2(CNIL,0xDA,0xE9); // FUCOMPP + c3 = cg87_87topsw(c3); + pop87(); + pop87(); + } + else + // Call a function instead so that exceptions + // are not generated. + c3 = callclib(e,CLIBfcompp,&resregm,0); + } + } + + freenode(e2); + return cat4(c1,c2,c3,c4); + + case X(OPadd, TYcfloat, TYcfloat): + case X(OPadd, TYcdouble, TYcdouble): + case X(OPadd, TYcldouble, TYcldouble): + case X(OPadd, TYcfloat, TYfloat): + case X(OPadd, TYcdouble, TYdouble): + case X(OPadd, TYcldouble, TYldouble): + case X(OPadd, TYfloat, TYcfloat): + case X(OPadd, TYdouble, TYcdouble): + case X(OPadd, TYldouble, TYcldouble): + goto Lcomplex; + + case X(OPadd, TYifloat, TYcfloat): + case X(OPadd, TYidouble, TYcdouble): + case X(OPadd, TYildouble, TYcldouble): + goto Lcomplex2; + + case X(OPmin, TYcfloat, TYcfloat): + case X(OPmin, TYcdouble, TYcdouble): + case X(OPmin, TYcldouble, TYcldouble): + case X(OPmin, TYcfloat, TYfloat): + case X(OPmin, TYcdouble, TYdouble): + case X(OPmin, TYcldouble, TYldouble): + case X(OPmin, TYfloat, TYcfloat): + case X(OPmin, TYdouble, TYcdouble): + case X(OPmin, TYldouble, TYcldouble): + goto Lcomplex; + + case X(OPmin, TYifloat, TYcfloat): + case X(OPmin, TYidouble, TYcdouble): + case X(OPmin, TYildouble, TYcldouble): + goto Lcomplex2; + + case X(OPmul, TYcfloat, TYcfloat): + case X(OPmul, TYcdouble, TYcdouble): + case X(OPmul, TYcldouble, TYcldouble): + clib = CLIBcmul; + goto Lcomplex; + + case X(OPdiv, TYcfloat, TYcfloat): + case X(OPdiv, TYcdouble, TYcdouble): + case X(OPdiv, TYcldouble, TYcldouble): + case X(OPdiv, TYfloat, TYcfloat): + case X(OPdiv, TYdouble, TYcdouble): + case X(OPdiv, TYldouble, TYcldouble): + case X(OPdiv, TYifloat, TYcfloat): + case X(OPdiv, TYidouble, TYcdouble): + case X(OPdiv, TYildouble, TYcldouble): + clib = CLIBcdiv; + goto Lcomplex; + + case X(OPdiv, TYifloat, TYfloat): + case X(OPdiv, TYidouble, TYdouble): + case X(OPdiv, TYildouble, TYldouble): + op = 6; // FDIVP + break; + + Lcomplex: + c1 = loadComplex(e1); + c2 = loadComplex(e2); + c3 = makesure87(e1, sz2, 2, 0); + c3 = cat(c3,makesure87(e1, 0, 3, 0)); + retregs = mST01; + if (eoper == OPadd) + { + c4 = genf2(NULL, 0xDE, 0xC0+2); // FADDP ST(2),ST + genf2(c4, 0xDE, 0xC0+2); // FADDP ST(2),ST + pop87(); + pop87(); + } + else if (eoper == OPmin) + { + c4 = genf2(NULL, 0xDE, 0xE8+2); // FSUBP ST(2),ST + genf2(c4, 0xDE, 0xE8+2); // FSUBP ST(2),ST + pop87(); + pop87(); + } + else + c4 = callclib(e, clib, &retregs, 0); + c4 = cat(c4, fixresult_complex87(e, retregs, pretregs)); + return cat4(c1,c2,c3,c4); + + Lcomplex2: + retregs = mST0; + c1 = codelem(e1, &retregs, FALSE); + note87(e1, 0, 0); + c2 = loadComplex(e2); + c3 = makesure87(e1, 0, 2, 0); + retregs = mST01; + if (eoper == OPadd) + { + c4 = genf2(NULL, 0xDE, 0xC0+2); // FADDP ST(2),ST + } + else if (eoper == OPmin) + { + c4 = genf2(NULL, 0xDE, 0xE8+2); // FSUBP ST(2),ST + c4 = genf2(c4, 0xD9, 0xE0); // FCHS + } + else + assert(0); + pop87(); + c4 = genf2(c4, 0xD9, 0xC8 + 1); // FXCH ST(1) + c4 = cat(c4, fixresult_complex87(e, retregs, pretregs)); + return cat4(c1,c2,c3,c4); + + case X(OPeqeq, TYcfloat, TYcfloat): + case X(OPeqeq, TYcdouble, TYcdouble): + case X(OPeqeq, TYcldouble, TYcldouble): + case X(OPeqeq, TYcfloat, TYifloat): + case X(OPeqeq, TYcdouble, TYidouble): + case X(OPeqeq, TYcldouble, TYildouble): + case X(OPeqeq, TYcfloat, TYfloat): + case X(OPeqeq, TYcdouble, TYdouble): + case X(OPeqeq, TYcldouble, TYldouble): + case X(OPeqeq, TYifloat, TYcfloat): + case X(OPeqeq, TYidouble, TYcdouble): + case X(OPeqeq, TYildouble, TYcldouble): + case X(OPeqeq, TYfloat, TYcfloat): + case X(OPeqeq, TYdouble, TYcdouble): + case X(OPeqeq, TYldouble, TYcldouble): + case X(OPeqeq, TYfloat, TYifloat): + case X(OPeqeq, TYdouble, TYidouble): + case X(OPeqeq, TYldouble, TYildouble): + case X(OPeqeq, TYifloat, TYfloat): + case X(OPeqeq, TYidouble, TYdouble): + case X(OPeqeq, TYildouble, TYldouble): + c1 = loadComplex(e1); + c2 = loadComplex(e2); + c3 = makesure87(e1, sz2, 2, 0); + c3 = cat(c3,makesure87(e1, 0, 3, 0)); + retregs = 0; + c4 = callclib(e, CLIBccmp, &retregs, 0); + return cat4(c1,c2,c3,c4); + + + case X(OPadd, TYfloat, TYifloat): + case X(OPadd, TYdouble, TYidouble): + case X(OPadd, TYldouble, TYildouble): + case X(OPadd, TYifloat, TYfloat): + case X(OPadd, TYidouble, TYdouble): + case X(OPadd, TYildouble, TYldouble): + + case X(OPmin, TYfloat, TYifloat): + case X(OPmin, TYdouble, TYidouble): + case X(OPmin, TYldouble, TYildouble): + case X(OPmin, TYifloat, TYfloat): + case X(OPmin, TYidouble, TYdouble): + case X(OPmin, TYildouble, TYldouble): + retregs = mST0; + c1 = codelem(e1, &retregs, FALSE); + note87(e1, 0, 0); + c2 = codelem(e2, &retregs, FALSE); + c3 = makesure87(e1, 0, 1, 0); + if (eoper == OPmin) + c3 = genf2(c3, 0xD9, 0xE0); // FCHS + if (tyimaginary(e1->Ety)) + c3 = genf2(c3, 0xD9, 0xC8 + 1); // FXCH ST(1) + retregs = mST01; + c4 = fixresult_complex87(e, retregs, pretregs); + return cat4(c1,c2,c3,c4); + + case X(OPadd, TYcfloat, TYifloat): + case X(OPadd, TYcdouble, TYidouble): + case X(OPadd, TYcldouble, TYildouble): + op = 0; + goto Lci; + + case X(OPmin, TYcfloat, TYifloat): + case X(OPmin, TYcdouble, TYidouble): + case X(OPmin, TYcldouble, TYildouble): + op = 4; + goto Lci; + + Lci: + c1 = loadComplex(e1); + retregs = mST0; + c2 = load87(e2,sz2,&retregs,e1,op); + freenode(e2); + retregs = mST01; + c3 = makesure87(e1,0,1,0); + c4 = fixresult_complex87(e, retregs, pretregs); + return cat4(c1,c2,c3,c4); + + case X(OPmul, TYcfloat, TYfloat): + case X(OPmul, TYcdouble, TYdouble): + case X(OPmul, TYcldouble, TYldouble): + c1 = loadComplex(e1); + goto Lcm1; + + case X(OPmul, TYcfloat, TYifloat): + case X(OPmul, TYcdouble, TYidouble): + case X(OPmul, TYcldouble, TYildouble): + c1 = loadComplex(e1); + c1 = genf2(c1, 0xD9, 0xE0); // FCHS + genf2(c1,0xD9,0xC8 + 1); // FXCH ST(1) + if (elemisone(e2)) + { + freenode(e2); + c2 = NULL; + c3 = NULL; + goto Lcd4; + } + goto Lcm1; + + Lcm1: + retregs = mST0; + c2 = codelem(e2, &retregs, FALSE); + c3 = makesure87(e1, sz2, 1, 0); + c3 = cat(c3,makesure87(e1, 0, 2, 0)); + goto Lcm2; + + case X(OPmul, TYfloat, TYcfloat): + case X(OPmul, TYdouble, TYcdouble): + case X(OPmul, TYldouble, TYcldouble): + retregs = mST0; + c1 = codelem(e1, &retregs, FALSE); + note87(e1, 0, 0); + c2 = loadComplex(e2); + c3 = makesure87(e1, 0, 2, 0); + c3 = genf2(c3,0xD9,0xC8 + 1); // FXCH ST(1) + genf2(c3,0xD9,0xC8 + 2); // FXCH ST(2) + goto Lcm2; + + case X(OPmul, TYifloat, TYcfloat): + case X(OPmul, TYidouble, TYcdouble): + case X(OPmul, TYildouble, TYcldouble): + retregs = mST0; + c1 = codelem(e1, &retregs, FALSE); + note87(e1, 0, 0); + c2 = loadComplex(e2); + c3 = makesure87(e1, 0, 2, 0); + c3 = genf2(c3, 0xD9, 0xE0); // FCHS + genf2(c3,0xD9,0xC8 + 2); // FXCH ST(2) + goto Lcm2; + + Lcm2: + c3 = genf2(c3,0xDC,0xC8 + 2); // FMUL ST(2), ST + genf2(c3,0xDE,0xC8 + 1); // FMULP ST(1), ST + goto Lcd3; + + case X(OPdiv, TYcfloat, TYfloat): + case X(OPdiv, TYcdouble, TYdouble): + case X(OPdiv, TYcldouble, TYldouble): + c1 = loadComplex(e1); + retregs = mST0; + c2 = codelem(e2, &retregs, FALSE); + c3 = makesure87(e1, sz2, 1, 0); + c3 = cat(c3,makesure87(e1, 0, 2, 0)); + goto Lcd1; + + case X(OPdiv, TYcfloat, TYifloat): + case X(OPdiv, TYcdouble, TYidouble): + case X(OPdiv, TYcldouble, TYildouble): + c1 = loadComplex(e1); + c1 = genf2(c1,0xD9,0xC8 + 1); // FXCH ST(1) + xchg87(0, 1); + genf2(c1, 0xD9, 0xE0); // FCHS + retregs = mST0; + c2 = codelem(e2, &retregs, FALSE); + c3 = makesure87(e1, 0, 1, 0); + c3 = cat(c3,makesure87(e1, sz2, 2, 0)); + Lcd1: + c3 = genf2(c3,0xDC,0xF8 + 2); // FDIV ST(2), ST + genf2(c3,0xDE,0xF8 + 1); // FDIVP ST(1), ST + Lcd3: + pop87(); + Lcd4: + retregs = mST01; + c4 = fixresult_complex87(e, retregs, pretregs); + return cat4(c1, c2, c3, c4); + + case X(OPmod, TYcfloat, TYfloat): + case X(OPmod, TYcdouble, TYdouble): + case X(OPmod, TYcldouble, TYldouble): + case X(OPmod, TYcfloat, TYifloat): + case X(OPmod, TYcdouble, TYidouble): + case X(OPmod, TYcldouble, TYildouble): + /* + fld E1.re + fld E1.im + fld E2 + fxch ST(1) + FM1: fprem + fstsw word ptr sw + fwait + mov AH, byte ptr sw+1 + jp FM1 + fxch ST(2) + FM2: fprem + fstsw word ptr sw + fwait + mov AH, byte ptr sw+1 + jp FM2 + fstp ST(1) + fxch ST(1) + */ + c1 = loadComplex(e1); + retregs = mST0; + c2 = codelem(e2, &retregs, FALSE); + c3 = makesure87(e1, sz2, 1, 0); + c3 = cat(c3,makesure87(e1, 0, 2, 0)); + c3 = genf2(c3, 0xD9, 0xC8 + 1); // FXCH ST(1) + + cx = gen2(NULL, 0xD9, 0xF8); // FPREM + cx = cg87_87topsw(cx); + cx = genjmp(cx, JP, FLcode, (block *)cx); // JP FM1 + cx = genf2(cx, 0xD9, 0xC8 + 2); // FXCH ST(2) + c3 = cat(c3,cx); + + cx = gen2(NULL, 0xD9, 0xF8); // FPREM + cx = cg87_87topsw(cx); + cx = genjmp(cx, JP, FLcode, (block *)cx); // JP FM2 + cx = genf2(cx,0xDD,0xD8 + 1); // FSTP ST(1) + cx = genf2(cx, 0xD9, 0xC8 + 1); // FXCH ST(1) + c3 = cat(c3,cx); + + goto Lcd3; + + default: +#ifdef DEBUG + elem_print(e); +#endif + assert(0); + break; + } + #undef X + + e2oper = e2->Eoper; + + /* Move double-sized operand into the second position if there's a chance + * it will allow combining a load with an operation (DMD Bugzilla 2905) + */ + if ( ((tybasic(e1->Ety) == TYdouble) + && ((e1->Eoper == OPvar) || (e1->Eoper == OPconst)) + && (tybasic(e2->Ety) != TYdouble)) || + (e1->Eoper == OPconst) || + (e1->Eoper == OPvar && + ((e1->Ety & (mTYconst | mTYimmutable) && !OTleaf(e2oper)) || + (e2oper == OPd_f && + (e2->E1->Eoper == OPs32_d || e2->E1->Eoper == OPs64_d || e2->E1->Eoper == OPs16_d) && + e2->E1->E1->Eoper == OPvar + ) || + ((e2oper == OPs32_d || e2oper == OPs64_d || e2oper == OPs16_d) && + e2->E1->Eoper == OPvar + ) + ) + ) + ) + { // Reverse order of evaluation + e1 = e->E2; + e2 = e->E1; + op = oprev[op + 1]; + reverse ^= 1; + } + + c1 = codelem(e1,&retregs,FALSE); + note87(e1,0,0); + + if (config.flags4 & CFG4fdivcall && e->Eoper == OPdiv) + { + regm_t retregs = mST0; + c2 = load87(e2,0,&retregs,e1,-1); + c2 = cat(c2,makesure87(e1,0,1,0)); + if (op == 7) // if reverse divide + c2 = genf2(c2,0xD9,0xC8 + 1); // FXCH ST(1) + c2 = cat(c2,callclib(e,CLIBfdiv87,&retregs,0)); + pop87(); + resregm = mST0; + freenode(e2); + c4 = fixresult87(e,resregm,pretregs); + } + else if (e->Eoper == OPmod) + { + /* + * fld tbyte ptr y + * fld tbyte ptr x // ST = x, ST1 = y + * FM1: // We don't use fprem1 because for some inexplicable + * // reason we get -5 when we do _modulo(15, 10) + * fprem // ST = ST % ST1 + * fstsw word ptr sw + * fwait + * mov AH,byte ptr sw+1 // get msb of status word in AH + * sahf // transfer to flags + * jp FM1 // continue till ST < ST1 + * fstp ST(1) // leave remainder on stack + */ + regm_t retregs = mST0; + c2 = load87(e2,0,&retregs,e1,-1); + c2 = cat(c2,makesure87(e1,0,1,0)); // now have x,y on stack; need y,x + if (!reverse) // if not reverse modulo + c2 = genf2(c2,0xD9,0xC8 + 1); // FXCH ST(1) + + c3 = gen2(NULL, 0xD9, 0xF8); // FM1: FPREM + c3 = cg87_87topsw(c3); + c3 = genjmp(c3, JP, FLcode, (block *)c3); // JP FM1 + c3 = genf2(c3,0xDD,0xD8 + 1); // FSTP ST(1) + + pop87(); + resregm = mST0; + freenode(e2); + c4 = fixresult87(e,resregm,pretregs); + } + else + { c2 = load87(e2,0,pretregs,e1,op); + freenode(e2); + } + if (*pretregs & mST0) + note87(e,0,0); + //printf("orth87(-e = %p, *pretregs = x%x)\n", e, *pretregs); + return cat4(c1,c2,c3,c4); +} + +/***************************** + * Load e into ST01. + */ + +code *loadComplex(elem *e) +{ int sz; + regm_t retregs; + code *c; + + sz = tysize(e->Ety); + switch (tybasic(e->Ety)) + { + case TYfloat: + case TYdouble: + case TYldouble: + retregs = mST0; + c = codelem(e,&retregs,FALSE); + // Convert to complex with a 0 for the imaginary part + c = cat(c, push87()); + c = gen2(c,0xD9,0xEE); // FLDZ + break; + + case TYifloat: + case TYidouble: + case TYildouble: + // Convert to complex with a 0 for the real part + c = push87(); + c = gen2(c,0xD9,0xEE); // FLDZ + retregs = mST0; + c = cat(c, codelem(e,&retregs,FALSE)); + break; + + case TYcfloat: + case TYcdouble: + case TYcldouble: + sz /= 2; + retregs = mST01; + c = codelem(e,&retregs,FALSE); + break; + + default: + assert(0); + } + note87(e, 0, 1); + note87(e, sz, 0); + return c; +} + +/************************* + * If op == -1, load expression e into ST0. + * else compute (eleft op e), eleft is in ST0. + * Must follow same logic as cmporder87(); + */ + +code *load87(elem *e,unsigned eoffset,regm_t *pretregs,elem *eleft,int op) +{ + code *ccomma,*c,*c2,*cpush; + code cs; + regm_t retregs; + unsigned reg,mf,mf1; + int opr; + unsigned char ldop; + tym_t ty; + int i; + +#if NDPP + printf("+load87(e=%p, eoffset=%d, *pretregs=%s, eleft=%p, op=%d, stackused = %d)\n",e,eoffset,regm_str(*pretregs),eleft,op,stackused); +#endif + elem_debug(e); + ccomma = NULL; + cpush = NULL; + if (ADDFWAIT()) + cs.Iflags = CFwait; + else + cs.Iflags = 0; + cs.Irex = 0; + opr = oprev[op + 1]; + ty = tybasic(e->Ety); + if ((ty == TYldouble || ty == TYildouble) && + op != -1 && e->Eoper != OPd_ld) + goto Ldefault; + mf = (ty == TYfloat || ty == TYifloat || ty == TYcfloat) ? MFfloat : MFdouble; + L5: + switch (e->Eoper) + { + case OPcomma: + ccomma = docommas(&e); +// if (op != -1) +// ccomma = cat(ccomma,makesure87(eleft,eoffset,0,0)); + goto L5; + + case OPvar: + notreg(e); + case OPind: + L2: + if (op != -1) + { + if (e->Ecount && e->Ecount != e->Ecomsub && + (i = cse_get(e, 0)) >= 0) + { static unsigned char b2[8] = {0xC0,0xC8,0xD0,0xD8,0xE0,0xE8,0xF0,0xF8}; + + c = genf2(NULL,0xD8,b2[op] + i); // Fop ST(i) + } + else + { + c = getlvalue(&cs,e,0); + if (I64) + cs.Irex &= ~REX_W; // don't use for x87 ops + c = cat(c,makesure87(eleft,eoffset,0,0)); + cs.Iop = ESC(mf,0); + cs.Irm |= modregrm(0,op,0); + c = gen(c,&cs); + } + } + else + { + cpush = push87(); + switch (ty) + { + case TYfloat: + case TYdouble: + case TYifloat: + case TYidouble: + case TYcfloat: + case TYcdouble: + case TYdouble_alias: + c = loadea(e,&cs,ESC(mf,1),0,0,0,0); // FLD var + break; + case TYldouble: + case TYildouble: + case TYcldouble: + c = loadea(e,&cs,0xDB,5,0,0,0); // FLD var + break; + default: + // __debug printf("ty = x%x\n", ty); + assert(0); + break; + } + note87(e,0,0); + } + break; + case OPd_f: + case OPf_d: + case OPd_ld: + mf1 = (tybasic(e->E1->Ety) == TYfloat || tybasic(e->E1->Ety) == TYifloat) + ? MFfloat : MFdouble; + if (op != -1 && stackused) + note87(eleft,eoffset,0); // don't trash this value + if (e->E1->Eoper == OPvar || e->E1->Eoper == OPind) + { +#if 1 + L4: + c = getlvalue(&cs,e->E1,0); + cs.Iop = ESC(mf1,0); + if (ADDFWAIT()) + cs.Iflags |= CFwait; + if (!I16) + cs.Iflags &= ~CFopsize; + if (op != -1) + { cs.Irm |= modregrm(0,op,0); + c = cat(c,makesure87(eleft,eoffset,0,0)); + } + else + { cs.Iop |= 1; + c = cat(c,push87()); + } + c = gen(c,&cs); /* FLD / Fop */ +#else + c = loadea(e->E1,&cs,ESC(mf1,1),0,0,0,0); /* FLD e->E1 */ +#endif + /* Variable cannot be put into a register anymore */ + if (e->E1->Eoper == OPvar) + notreg(e->E1); + freenode(e->E1); + } + else + { + retregs = mST0; + c = codelem(e->E1,&retregs,FALSE); + if (op != -1) + { c = cat(c,makesure87(eleft,eoffset,1,0)); + c = genf2(c,0xDE,modregrm(3,opr,1)); // FopRP + pop87(); + } + } + break; + + case OPs64_d: + if (e->E1->Eoper == OPvar || + (e->E1->Eoper == OPind && e->E1->Ecount == 0)) + { + c = getlvalue(&cs,e->E1,0); + cs.Iop = 0xDF; + if (ADDFWAIT()) + cs.Iflags |= CFwait; + if (!I16) + cs.Iflags &= ~CFopsize; + c = cat(c,push87()); + cs.Irm |= modregrm(0,5,0); + c = gen(c,&cs); // FILD m64 + // Variable cannot be put into a register anymore + if (e->E1->Eoper == OPvar) + notreg(e->E1); + freenode(e->E1); + } + else if (I64) + { + retregs = ALLREGS; + c = codelem(e->E1,&retregs,FALSE); + reg = findreg(retregs); + c = genfltreg(c,0x89,reg,0); // MOV floatreg,reg + code_orrex(c, REX_W); + c = cat(c,push87()); + c = genfltreg(c,0xDF,5,0); // FILD long long ptr floatreg + } + else + { + retregs = ALLREGS; + c = codelem(e->E1,&retregs,FALSE); + reg = findreglsw(retregs); + c = genfltreg(c,0x89,reg,0); // MOV floatreg,reglsw + reg = findregmsw(retregs); + c = genfltreg(c,0x89,reg,4); // MOV floatreg+4,regmsw + c = cat(c,push87()); + c = genfltreg(c,0xDF,5,0); // FILD long long ptr floatreg + } + if (op != -1) + { c = cat(c,makesure87(eleft,eoffset,1,0)); + c = genf2(c,0xDE,modregrm(3,opr,1)); // FopRP + pop87(); + } + break; + + case OPconst: + ldop = loadconst(e, 0); + if (ldop) + { + cpush = push87(); + c = genf2(NULL,0xD9,ldop); // FLDx + if (op != -1) + { genf2(c,0xDE,modregrm(3,opr,1)); // FopRP + pop87(); + } + } + else + { + assert(0); + } + break; + + case OPu16_d: + { + /* This opcode should never be generated */ + /* (probably shouldn't be for 16 bit code too) */ + assert(!I32); + + if (op != -1) + note87(eleft,eoffset,0); // don't trash this value + retregs = ALLREGS & mLSW; + c = codelem(e->E1,&retregs,FALSE); + c = regwithvalue(c,ALLREGS & mMSW,0,®,0); // 0-extend + retregs |= mask[reg]; + mf1 = MFlong; + goto L3; + } + case OPs16_d: mf1 = MFword; goto L6; + case OPs32_d: mf1 = MFlong; goto L6; + L6: + if (op != -1) + note87(eleft,eoffset,0); // don't trash this value + if (e->E1->Eoper == OPvar || + (e->E1->Eoper == OPind && e->E1->Ecount == 0)) + { + goto L4; + } + else + { + retregs = ALLREGS; + c = codelem(e->E1,&retregs,FALSE); + L3: + if (I16 && e->Eoper != OPs16_d) + { + /* MOV floatreg+2,reg */ + reg = findregmsw(retregs); + c = genfltreg(c,0x89,reg,REGSIZE); + retregs &= mLSW; + } + reg = findreg(retregs); + c = genfltreg(c,0x89,reg,0); /* MOV floatreg,reg */ + if (op != -1) + { c = cat(c,makesure87(eleft,eoffset,0,0)); + genfltreg(c,ESC(mf1,0),op,0); /* Fop floatreg */ + } + else + { + /* FLD long ptr floatreg */ + c = cat(c,push87()); + c = genfltreg(c,ESC(mf1,1),0,0); + } + } + break; + default: + Ldefault: + retregs = mST0; +#if 1 /* Do this instead of codelem() to avoid the freenode(e). + We also lose CSE capability */ + if (e->Eoper == OPconst) + { + c = load87(e, 0, &retregs, NULL, -1); + } + else + c = (*cdxxx[e->Eoper])(e,&retregs); +#else + c = codelem(e,&retregs,FALSE); +#endif + if (op != -1) + { + c = cat(c,makesure87(eleft,eoffset,1,(op == 0 || op == 1))); + pop87(); + if (op == 4 || op == 6) // sub or div + { code *cl; + + cl = code_last(c); + if (cl && cl->Iop == 0xD9 && cl->Irm == 0xC9) // FXCH ST(1) + { cl->Iop = NOP; + opr = op; // reverse operands + } + } + c = genf2(c,0xDE,modregrm(3,opr,1)); // FopRP + } + break; + } + if (op == 3) // FCOMP + { pop87(); // extra pop was done + cg87_87topsw(c); + } + c2 = fixresult87(e,((op == 3) ? mPSW : mST0),pretregs); +#if NDPP + printf("-load87(e=%p, eoffset=%d, *pretregs=%s, eleft=%p, op=%d, stackused = %d)\n",e,eoffset,regm_str(*pretregs),eleft,op,stackused); +#endif + return cat4(ccomma,cpush,c,c2); +} + +/******************************** + * Determine if a compare is to be done forwards (return 0) + * or backwards (return 1). + * Must follow same logic as load87(). + */ + +int cmporder87(elem *e) +{ + //printf("cmporder87(%p)\n",e); +L1: + switch (e->Eoper) + { + case OPcomma: + e = e->E2; + goto L1; + + case OPd_f: + case OPf_d: + case OPd_ld: + if (e->E1->Eoper == OPvar || e->E1->Eoper == OPind) + goto ret0; + else + goto ret1; + + case OPconst: + if (loadconst(e, 0) || tybasic(e->Ety) == TYldouble + || tybasic(e->Ety) == TYildouble) +{ +//printf("ret 1, loadconst(e) = %d\n", loadconst(e)); + goto ret1; +} + goto ret0; + + case OPvar: + case OPind: + if (tybasic(e->Ety) == TYldouble || + tybasic(e->Ety) == TYildouble) + goto ret1; + case OPu16_d: + case OPs16_d: + case OPs32_d: + goto ret0; + + case OPs64_d: + goto ret1; + + default: + goto ret1; + } + +ret1: return 1; +ret0: return 0; +} + +/******************************* + * Perform an assignment to a long double/double/float. + */ + +code *eq87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + code cs; + unsigned op1; + unsigned op2; + tym_t ty1; + + //printf("+eq87(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + assert(e->Eoper == OPeq); + retregs = mST0 | (*pretregs & mPSW); + c1 = codelem(e->E2,&retregs,FALSE); + ty1 = tybasic(e->E1->Ety); + switch (ty1) + { case TYdouble_alias: + case TYidouble: + case TYdouble: op1 = ESC(MFdouble,1); op2 = 3; break; + case TYifloat: + case TYfloat: op1 = ESC(MFfloat,1); op2 = 3; break; + case TYildouble: + case TYldouble: op1 = 0xDB; op2 = 7; break; + default: + assert(0); + } + if (*pretregs & (mST0 | ALLREGS | mBP | XMMREGS)) // if want result on stack too + { + if (ty1 == TYldouble || ty1 == TYildouble) + { + c1 = cat(c1,push87()); + c1 = genf2(c1,0xD9,0xC0); // FLD ST(0) + pop87(); + } + else + op2 = 2; // FST e->E1 + } + else + { // FSTP e->E1 + pop87(); + } +#if 0 + // Doesn't work if ST(0) gets saved to the stack by getlvalue() + c2 = loadea(e->E1,&cs,op1,op2,0,0,0); +#else + cs.Irex = 0; + cs.Iflags = 0; + cs.Iop = op1; + if (*pretregs & (mST0 | ALLREGS | mBP | XMMREGS)) // if want result on stack too + { // Make sure it's still there + elem *e2 = e->E2; + while (e2->Eoper == OPcomma) + e2 = e2->E2; + note87(e2,0,0); + c2 = getlvalue(&cs, e->E1, 0); + c2 = cat(c2,makesure87(e2,0,0,1)); + } + else + { + c2 = getlvalue(&cs, e->E1, 0); + } + cs.Irm |= modregrm(0,op2,0); // OR in reg field + if (I32) + cs.Iflags &= ~CFopsize; + else if (ADDFWAIT()) + cs.Iflags |= CFwait; + else if (I64) + cs.Irex &= ~REX_W; + c2 = gen(c2, &cs); +#if LNGDBLSIZE == 12 + if (tysize[TYldouble] == 12) + { + /* This deals with the fact that 10 byte reals really + * occupy 12 bytes by zeroing the extra 2 bytes. + */ + if (op1 == 0xDB) + { + cs.Iop = 0xC7; // MOV EA+10,0 + NEWREG(cs.Irm, 0); + cs.IEV1.sp.Voffset += 10; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + cs.Iflags |= CFopsize; + c2 = gen(c2, &cs); + } + } +#endif + if (tysize[TYldouble] == 16) + { + /* This deals with the fact that 10 byte reals really + * occupy 16 bytes by zeroing the extra 6 bytes. + */ + if (op1 == 0xDB) + { + cs.Irex &= ~REX_W; + cs.Iop = 0xC7; // MOV EA+10,0 + NEWREG(cs.Irm, 0); + cs.IEV1.sp.Voffset += 10; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + cs.Iflags |= CFopsize; + c2 = gen(c2, &cs); + + cs.IEV1.sp.Voffset += 2; + cs.Iflags &= ~CFopsize; + c2 = gen(c2, &cs); + } + } +#endif + c2 = genfwait(c2); + freenode(e->E1); + c1 = cat3(c1,c2,fixresult87(e,mST0 | mPSW,pretregs)); + return c1; +} + +/******************************* + * Perform an assignment to a long double/double/float. + */ + +code *complex_eq87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + code cs; + unsigned op1; + unsigned op2; + unsigned sz; + tym_t ty1; + int fxch = 0; + + //printf("complex_eq87(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + assert(e->Eoper == OPeq); + cs.Iflags = ADDFWAIT() ? CFwait : 0; + cs.Irex = 0; + retregs = mST01 | (*pretregs & mPSW); + c1 = codelem(e->E2,&retregs,FALSE); + ty1 = tybasic(e->E1->Ety); + switch (ty1) + { + case TYcdouble: op1 = ESC(MFdouble,1); op2 = 3; break; + case TYcfloat: op1 = ESC(MFfloat,1); op2 = 3; break; + case TYcldouble: op1 = 0xDB; op2 = 7; break; + default: + assert(0); + } + if (*pretregs & (mST01 | mXMM0 | mXMM1)) // if want result on stack too + { + if (ty1 == TYcldouble) + { + c1 = cat(c1,push87()); + c1 = cat(c1,push87()); + c1 = genf2(c1,0xD9,0xC0 + 1); // FLD ST(1) + genf2(c1,0xD9,0xC0 + 1); // FLD ST(1) + pop87(); + pop87(); + } + else + { op2 = 2; // FST e->E1 + fxch = 1; + } + } + else + { // FSTP e->E1 + pop87(); + pop87(); + } + sz = tysize(ty1) / 2; + if (*pretregs & (mST01 | mXMM0 | mXMM1)) + { + cs.Iflags = 0; + cs.Irex = 0; + cs.Iop = op1; + c2 = getlvalue(&cs, e->E1, 0); + cs.IEVoffset1 += sz; + cs.Irm |= modregrm(0, op2, 0); + c2 = cat(c2, makesure87(e->E2, sz, 0, 0)); + c2 = gen(c2, &cs); + c2 = genfwait(c2); + c2 = cat(c2, makesure87(e->E2, 0, 1, 0)); + } + else + { + c2 = loadea(e->E1,&cs,op1,op2,sz,0,0); + c2 = genfwait(c2); + } + if (fxch) + c2 = genf2(c2,0xD9,0xC8 + 1); // FXCH ST(1) + cs.IEVoffset1 -= sz; + gen(c2, &cs); + if (fxch) + genf2(c2,0xD9,0xC8 + 1); // FXCH ST(1) + if (tysize[TYldouble] == 12) + { + if (op1 == 0xDB) + { + cs.Iop = 0xC7; // MOV EA+10,0 + NEWREG(cs.Irm, 0); + cs.IEV1.sp.Voffset += 10; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + cs.Iflags |= CFopsize; + c2 = gen(c2, &cs); + cs.IEVoffset1 += 12; + c2 = gen(c2, &cs); // MOV EA+22,0 + } + } + if (tysize[TYldouble] == 16) + { + if (op1 == 0xDB) + { + cs.Iop = 0xC7; // MOV EA+10,0 + NEWREG(cs.Irm, 0); + cs.IEV1.sp.Voffset += 10; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + cs.Iflags |= CFopsize; + c2 = gen(c2, &cs); + + cs.IEV1.sp.Voffset += 2; + cs.Iflags &= ~CFopsize; + c2 = gen(c2, &cs); + + cs.IEV1.sp.Voffset += 14; + cs.Iflags |= CFopsize; + c2 = gen(c2, &cs); + + cs.IEV1.sp.Voffset += 2; + cs.Iflags &= ~CFopsize; + c2 = gen(c2, &cs); + } + } + c2 = genfwait(c2); + freenode(e->E1); + return cat3(c1,c2,fixresult_complex87(e,mST01 | mPSW,pretregs)); +} + +/******************************* + * Perform an assignment while converting to integral type, + * i.e. handle (e1 = (int) e2) + */ + +code *cnvteq87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + code cs; + unsigned op1; + unsigned op2; + + assert(e->Eoper == OPeq); + assert(!*pretregs); + retregs = mST0; + elem_debug(e->E2); + c1 = codelem(e->E2->E1,&retregs,FALSE); + + switch (e->E2->Eoper) + { case OPd_s16: + op1 = ESC(MFword,1); + op2 = 3; + break; + case OPd_s32: + case OPd_u16: + op1 = ESC(MFlong,1); + op2 = 3; + break; + case OPd_s64: + op1 = 0xDF; + op2 = 7; + break; + default: + assert(0); + } + freenode(e->E2); + + c1 = genfwait(c1); + c1 = genrnd(c1, CW_roundto0); // FLDCW roundto0 + + pop87(); + cs.Iflags = ADDFWAIT() ? CFwait : 0; + if (e->E1->Eoper == OPvar) + notreg(e->E1); // cannot be put in register anymore + c2 = loadea(e->E1,&cs,op1,op2,0,0,0); + + c2 = genfwait(c2); + c2 = genrnd(c2, CW_roundtonearest); // FLDCW roundtonearest + + freenode(e->E1); + return cat(c1,c2); +} + +/********************************** + * Perform +=, -=, *= and /= for doubles. + */ + +code *opass87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *cl,*cr,*c; + code cs; + unsigned op; + unsigned opld; + unsigned op1; + unsigned op2; + tym_t ty1; + + ty1 = tybasic(e->E1->Ety); + switch (ty1) + { case TYdouble_alias: + case TYidouble: + case TYdouble: op1 = ESC(MFdouble,1); op2 = 3; break; + case TYifloat: + case TYfloat: op1 = ESC(MFfloat,1); op2 = 3; break; + case TYildouble: + case TYldouble: op1 = 0xDB; op2 = 7; break; + + case TYcfloat: + case TYcdouble: + case TYcldouble: + return (e->Eoper == OPmodass) + ? opmod_complex87(e, pretregs) + : opass_complex87(e, pretregs); + + default: + assert(0); + } + switch (e->Eoper) + { case OPpostinc: + case OPaddass: op = 0 << 3; opld = 0xC1; break; // FADD + case OPpostdec: + case OPminass: op = 5 << 3; opld = 0xE1; /*0xE9;*/ break; // FSUBR + case OPmulass: op = 1 << 3; opld = 0xC9; break; // FMUL + case OPdivass: op = 7 << 3; opld = 0xF1; break; // FDIVR + case OPmodass: break; + default: assert(0); + } + retregs = mST0; + cr = codelem(e->E2,&retregs,FALSE); // evaluate rvalue + note87(e->E2,0,0); + cl = getlvalue(&cs,e->E1,0); + cl = cat(cl,makesure87(e->E2,0,0,0)); + cs.Iflags |= ADDFWAIT() ? CFwait : 0; + if (I32) + cs.Iflags &= ~CFopsize; + if (config.flags4 & CFG4fdivcall && e->Eoper == OPdivass) + { + c = push87(); + cs.Iop = op1; + if (ty1 == TYldouble || ty1 == TYildouble) + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); + c = genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + c = cat(c,callclib(e,CLIBfdiv87,&retregs,0)); + pop87(); + } + else if (e->Eoper == OPmodass) + { + /* + * fld tbyte ptr y + * fld tbyte ptr x // ST = x, ST1 = y + * FM1: // We don't use fprem1 because for some inexplicable + * // reason we get -5 when we do _modulo(15, 10) + * fprem // ST = ST % ST1 + * fstsw word ptr sw + * fwait + * mov AH,byte ptr sw+1 // get msb of status word in AH + * sahf // transfer to flags + * jp FM1 // continue till ST < ST1 + * fstp ST(1) // leave remainder on stack + */ + code *c1; + + c = push87(); + cs.Iop = op1; + if (ty1 == TYldouble || ty1 == TYildouble) + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1 + + c1 = gen2(NULL, 0xD9, 0xF8); // FPREM + c1 = cg87_87topsw(c1); + c1 = genjmp(c1, JP, FLcode, (block *)c1); // JP FM1 + c1 = genf2(c1,0xDD,0xD8 + 1); // FSTP ST(1) + c = cat(c,c1); + + pop87(); + } + else if (ty1 == TYldouble || ty1 == TYildouble) + { + c = push87(); + cs.Iop = op1; + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1 + genf2(c,0xDE,opld); // FopP ST(1) + pop87(); + } + else + { cs.Iop = op1 & ~1; + cs.Irm |= op; + c = gen(CNIL,&cs); // Fop e->E1 + } + if (*pretregs & mPSW) + genftst(c,e,0); // FTST ST0 + /* if want result in registers */ + if (*pretregs & (mST0 | ALLREGS | mBP)) + { + if (ty1 == TYldouble || ty1 == TYildouble) + { + c = cat(c,push87()); + c = genf2(c,0xD9,0xC0); // FLD ST(0) + pop87(); + } + else + op2 = 2; // FST e->E1 + } + else + { // FSTP + pop87(); + } + cs.Iop = op1; + NEWREG(cs.Irm,op2); // FSTx e->E1 + freenode(e->E1); + gen(c,&cs); + genfwait(c); + return cat4(cr,cl,c,fixresult87(e,mST0 | mPSW,pretregs)); +} + +/*********************************** + * Perform %= where E1 is complex and E2 is real or imaginary. + */ + +code *opmod_complex87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *cl,*cr,*c; + code cs; + tym_t ty1; + unsigned sz2; + + /* fld E2 + fld E1.re + FM1: fprem + fstsw word ptr sw + fwait + mov AH, byte ptr sw+1 + jp FM1 + fxch ST(1) + fld E1.im + FM2: fprem + fstsw word ptr sw + fwait + mov AH, byte ptr sw+1 + jp FM2 + fstp ST(1) + */ + + ty1 = tybasic(e->E1->Ety); + sz2 = tysize[ty1] / 2; + + retregs = mST0; + cr = codelem(e->E2,&retregs,FALSE); // FLD E2 + note87(e->E2,0,0); + cl = getlvalue(&cs,e->E1,0); + cl = cat(cl,makesure87(e->E2,0,0,0)); + cs.Iflags |= ADDFWAIT() ? CFwait : 0; + if (!I16) + cs.Iflags &= ~CFopsize; + + c = push87(); + switch (ty1) + { + case TYcdouble: cs.Iop = ESC(MFdouble,1); break; + case TYcfloat: cs.Iop = ESC(MFfloat,1); break; + case TYcldouble: cs.Iop = 0xDB; cs.Irm |= modregrm(0, 5, 0); break; + default: + assert(0); + } + c = gen(c,&cs); // FLD E1.re + + code *c1; + + c1 = gen2(NULL, 0xD9, 0xF8); // FPREM + c1 = cg87_87topsw(c1); + c1 = genjmp(c1, JP, FLcode, (block *)c1); // JP FM1 + c1 = genf2(c1, 0xD9, 0xC8 + 1); // FXCH ST(1) + c = cat(c,c1); + + c = cat(c, push87()); + cs.IEVoffset1 += sz2; + gen(c, &cs); // FLD E1.im + + c1 = gen2(NULL, 0xD9, 0xF8); // FPREM + c1 = cg87_87topsw(c1); + c1 = genjmp(c1, JP, FLcode, (block *)c1); // JP FM2 + c1 = genf2(c1,0xDD,0xD8 + 1); // FSTP ST(1) + c = cat(c,c1); + + pop87(); + + if (*pretregs & (mST01 | mPSW)) + { + cs.Irm |= modregrm(0, 2, 0); + gen(c, &cs); // FST mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FST mreal.re + retregs = mST01; + } + else + { + cs.Irm |= modregrm(0, 3, 0); + gen(c, &cs); // FSTP mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSTP mreal.re + pop87(); + pop87(); + retregs = 0; + } + freenode(e->E1); + genfwait(c); + return cat4(cr,cl,c,fixresult_complex87(e,retregs,pretregs)); +} + +/********************************** + * Perform +=, -=, *= and /= for the lvalue being complex. + */ + +code *opass_complex87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + regm_t idxregs; + code *cl,*cr,*c; + code cs; + unsigned op; + unsigned op2; + tym_t ty1; + unsigned sz2; + + ty1 = tybasic(e->E1->Ety); + sz2 = tysize[ty1] / 2; + switch (e->Eoper) + { case OPpostinc: + case OPaddass: op = 0 << 3; // FADD + op2 = 0xC0; // FADDP ST(i),ST + break; + case OPpostdec: + case OPminass: op = 5 << 3; // FSUBR + op2 = 0xE0; // FSUBRP ST(i),ST + break; + case OPmulass: op = 1 << 3; // FMUL + op2 = 0xC8; // FMULP ST(i),ST + break; + case OPdivass: op = 7 << 3; // FDIVR + op2 = 0xF0; // FDIVRP ST(i),ST + break; + default: assert(0); + } + + if (!tycomplex(e->E2->Ety) && + (e->Eoper == OPmulass || e->Eoper == OPdivass)) + { + retregs = mST0; + cr = codelem(e->E2, &retregs, FALSE); + note87(e->E2, 0, 0); + cl = getlvalue(&cs, e->E1, 0); + cl = cat(cl,makesure87(e->E2,0,0,0)); + cl = cat(cl,push87()); + cl = genf2(cl,0xD9,0xC0); // FLD ST(0) + goto L1; + } + else + { + cr = loadComplex(e->E2); + cl = getlvalue(&cs,e->E1,0); + cl = cat(cl,makesure87(e->E2,sz2,0,0)); + cl = cat(cl,makesure87(e->E2,0,1,0)); + } + cs.Iflags |= ADDFWAIT() ? CFwait : 0; + if (!I16) + cs.Iflags &= ~CFopsize; + + switch (e->Eoper) + { + case OPpostinc: + case OPaddass: + case OPpostdec: + case OPminass: + L1: + if (ty1 == TYcldouble) + { + c = push87(); + c = cat(c, push87()); + cs.Iop = 0xDB; + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1.re + cs.IEVoffset1 += sz2; + gen(c,&cs); // FLD e->E1.im + genf2(c, 0xDE, op2 + 2); // FADDP/FSUBRP ST(2),ST + genf2(c, 0xDE, op2 + 2); // FADDP/FSUBRP ST(2),ST + pop87(); + pop87(); + if (tyimaginary(e->E2->Ety)) + { + if (e->Eoper == OPmulass) + { + genf2(c, 0xD9, 0xE0); // FCHS + genf2(c, 0xD9, 0xC8+1); // FXCH ST(1) + } + else if (e->Eoper == OPdivass) + { + genf2(c, 0xD9, 0xC8+1); // FXCH ST(1) + genf2(c, 0xD9, 0xE0); // FCHS + } + } + L2: + if (*pretregs & (mST01 | mPSW)) + { + c = cat(c,push87()); + c = cat(c,push87()); + c = genf2(c,0xD9,0xC1); // FLD ST(1) + c = genf2(c,0xD9,0xC1); // FLD ST(1) + retregs = mST01; + } + else + retregs = 0; + cs.Iop = 0xDB; + cs.Irm |= modregrm(0,7,0); + gen(c,&cs); // FSTP e->E1.im + cs.IEVoffset1 -= sz2; + gen(c,&cs); // FSTP e->E1.re + pop87(); + pop87(); + + } + else + { unsigned char rmop = cs.Irm | op; + unsigned char rmfst = cs.Irm | modregrm(0,2,0); + unsigned char rmfstp = cs.Irm | modregrm(0,3,0); + unsigned char iopfst = (ty1 == TYcfloat) ? 0xD9 : 0xDD; + unsigned char iop = (ty1 == TYcfloat) ? 0xD8 : 0xDC; + + cs.Iop = iop; + cs.Irm = rmop; + cs.IEVoffset1 += sz2; + c = gen(NULL, &cs); // FSUBR mreal.im + if (tyimaginary(e->E2->Ety) && (e->Eoper == OPmulass || e->Eoper == OPdivass)) + { + if (e->Eoper == OPmulass) + genf2(c, 0xD9, 0xE0); // FCHS + genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FMUL mreal.re + if (e->Eoper == OPdivass) + genf2(c, 0xD9, 0xE0); // FCHS + if (*pretregs & (mST01 | mPSW)) + { + cs.Iop = iopfst; + cs.Irm = rmfst; + cs.IEVoffset1 += sz2; + gen(c, &cs); // FST mreal.im + genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FST mreal.re + genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + retregs = mST01; + } + else + { + cs.Iop = iopfst; + cs.Irm = rmfstp; + cs.IEVoffset1 += sz2; + gen(c, &cs); // FSTP mreal.im + pop87(); + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSTP mreal.re + pop87(); + retregs = 0; + } + goto L3; + } + + if (*pretregs & (mST01 | mPSW)) + { + cs.Iop = iopfst; + cs.Irm = rmfst; + gen(c, &cs); // FST mreal.im + genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + cs.Iop = iop; + cs.Irm = rmop; + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSUBR mreal.re + cs.Iop = iopfst; + cs.Irm = rmfst; + gen(c, &cs); // FST mreal.re + genf2(c,0xD9,0xC8 + 1); // FXCH ST(1) + retregs = mST01; + } + else + { + cs.Iop = iopfst; + cs.Irm = rmfstp; + gen(c, &cs); // FSTP mreal.im + pop87(); + cs.Iop = iop; + cs.Irm = rmop; + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSUBR mreal.re + cs.Iop = iopfst; + cs.Irm = rmfstp; + gen(c, &cs); // FSTP mreal.re + pop87(); + retregs = 0; + } + } + L3: + freenode(e->E1); + genfwait(c); + return cat4(cr,cl,c,fixresult_complex87(e,retregs,pretregs)); + + case OPmulass: + c = push87(); + c = cat(c, push87()); + if (ty1 == TYcldouble) + { + cs.Iop = 0xDB; + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1.re + cs.IEVoffset1 += sz2; + gen(c,&cs); // FLD e->E1.im + retregs = mST01; + c = cat(c,callclib(e, CLIBcmul, &retregs, 0)); + goto L2; + } + else + { + cs.Iop = (ty1 == TYcfloat) ? 0xD9 : 0xDD; + cs.Irm |= modregrm(0, 0, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1.re + cs.IEVoffset1 += sz2; + gen(c,&cs); // FLD e->E1.im + retregs = mST01; + c = cat(c,callclib(e, CLIBcmul, &retregs, 0)); + if (*pretregs & (mST01 | mPSW)) + { + cs.Irm |= modregrm(0, 2, 0); + gen(c, &cs); // FST mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FST mreal.re + retregs = mST01; + } + else + { + cs.Irm |= modregrm(0, 3, 0); + gen(c, &cs); // FSTP mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSTP mreal.re + pop87(); + pop87(); + retregs = 0; + } + goto L3; + } + + case OPdivass: + c = push87(); + c = cat(c, push87()); + idxregs = idxregm(&cs); // mask of index regs used + if (ty1 == TYcldouble) + { + cs.Iop = 0xDB; + cs.Irm |= modregrm(0, 5, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1.re + genf2(c,0xD9,0xC8 + 2); // FXCH ST(2) + cs.IEVoffset1 += sz2; + gen(c,&cs); // FLD e->E1.im + genf2(c,0xD9,0xC8 + 2); // FXCH ST(2) + retregs = mST01; + c = cat(c,callclib(e, CLIBcdiv, &retregs, idxregs)); + goto L2; + } + else + { + cs.Iop = (ty1 == TYcfloat) ? 0xD9 : 0xDD; + cs.Irm |= modregrm(0, 0, 0); // FLD tbyte ptr ... + c = gen(c,&cs); // FLD e->E1.re + genf2(c,0xD9,0xC8 + 2); // FXCH ST(2) + cs.IEVoffset1 += sz2; + gen(c,&cs); // FLD e->E1.im + genf2(c,0xD9,0xC8 + 2); // FXCH ST(2) + retregs = mST01; + c = cat(c,callclib(e, CLIBcdiv, &retregs, idxregs)); + if (*pretregs & (mST01 | mPSW)) + { + cs.Irm |= modregrm(0, 2, 0); + gen(c, &cs); // FST mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FST mreal.re + retregs = mST01; + } + else + { + cs.Irm |= modregrm(0, 3, 0); + gen(c, &cs); // FSTP mreal.im + cs.IEVoffset1 -= sz2; + gen(c, &cs); // FSTP mreal.re + pop87(); + pop87(); + retregs = 0; + } + goto L3; + } + + default: + assert(0); + } + return NULL; +} + +/************************** + * OPnegass + */ + +code *cdnegass87(elem *e,regm_t *pretregs) +{ regm_t retregs; + tym_t tyml; + unsigned op; + code *cl,*cr,*c,cs; + elem *e1; + int sz; + + //printf("cdnegass87(e = %p, *pretregs = x%x)\n", e, *pretregs); + e1 = e->E1; + tyml = tybasic(e1->Ety); // type of lvalue + sz = tysize[tyml]; + + cl = getlvalue(&cs,e1,0); + cr = modEA(&cs); + cs.Irm |= modregrm(0,6,0); + cs.Iop = 0x80; + cs.Irex = 0; +#if LNGDBLSIZE > 10 + if (tyml == TYldouble || tyml == TYildouble) + cs.IEVoffset1 += 10 - 1; + else if (tyml == TYcldouble) + cs.IEVoffset1 += tysize[TYldouble] + 10 - 1; + else +#endif + cs.IEVoffset1 += sz - 1; + cs.IFL2 = FLconst; + cs.IEV2.Vuns = 0x80; + c = gen(NULL,&cs); // XOR 7[EA],0x80 + if (tycomplex(tyml)) + { + cs.IEVoffset1 -= sz / 2; + gen(c,&cs); // XOR 7[EA],0x80 + } + c = cat3(cl,cr,c); + + if (*pretregs) + { + switch (tyml) + { + case TYifloat: + case TYfloat: cs.Iop = 0xD9; op = 0; break; + case TYidouble: + case TYdouble: + case TYdouble_alias: cs.Iop = 0xDD; op = 0; break; + case TYildouble: + case TYldouble: cs.Iop = 0xDB; op = 5; break; + default: + assert(0); + } + NEWREG(cs.Irm,op); + cs.IEVoffset1 -= sz - 1; + c = cat(c, push87()); + c = gen(c,&cs); // FLD EA + retregs = mST0; + } + else + retregs = 0; + + freenode(e1); + return cat(c,fixresult87(e,retregs,pretregs)); +} + +/************************ + * Take care of OPpostinc and OPpostdec. + */ + +code *post87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *cl,*cr,*c; + code cs; + unsigned op; + unsigned op1; + unsigned reg; + tym_t ty1; + + //printf("post87()\n"); + assert(*pretregs); + cl = getlvalue(&cs,e->E1,0); + cs.Iflags |= ADDFWAIT() ? CFwait : 0; + if (!I16) + cs.Iflags &= ~CFopsize; + ty1 = tybasic(e->E1->Ety); + switch (ty1) + { case TYdouble_alias: + case TYidouble: + case TYdouble: + case TYcdouble: op1 = ESC(MFdouble,1); reg = 0; break; + case TYifloat: + case TYfloat: + case TYcfloat: op1 = ESC(MFfloat,1); reg = 0; break; + case TYildouble: + case TYldouble: + case TYcldouble: op1 = 0xDB; reg = 5; break; + default: + assert(0); + } + NEWREG(cs.Irm, reg); + if (reg == 5) + reg = 7; + else + reg = 3; + cs.Iop = op1; + cl = cat(cl,push87()); + cl = gen(cl,&cs); // FLD e->E1 + if (tycomplex(ty1)) + { unsigned sz = tysize[ty1] / 2; + + cl = cat(cl,push87()); + cs.IEVoffset1 += sz; + cl = gen(cl,&cs); // FLD e->E1 + retregs = mST0; // note kludge to only load real part + cr = codelem(e->E2,&retregs,FALSE); // load rvalue + c = genf2(NULL,0xD8, // FADD/FSUBR ST,ST2 + (e->Eoper == OPpostinc) ? 0xC0 + 2 : 0xE8 + 2); + NEWREG(cs.Irm,reg); + pop87(); + cs.IEVoffset1 -= sz; + gen(c,&cs); // FSTP e->E1 + genfwait(c); + freenode(e->E1); + return cat4(cl, cr, c, fixresult_complex87(e, mST01, pretregs)); + } + + if (*pretregs & (mST0 | ALLREGS | mBP)) + { // Want the result in a register + cl = cat(cl,push87()); + genf2(cl,0xD9,0xC0); // FLD ST0 + } + if (*pretregs & mPSW) /* if result in flags */ + genftst(cl,e,0); // FTST ST0 + retregs = mST0; + cr = codelem(e->E2,&retregs,FALSE); /* load rvalue */ + pop87(); + op = (e->Eoper == OPpostinc) ? modregrm(3,0,1) : modregrm(3,5,1); + c = genf2(NULL,0xDE,op); // FADDP/FSUBRP ST1 + NEWREG(cs.Irm,reg); + pop87(); + gen(c,&cs); /* FSTP e->E1 */ + genfwait(c); + freenode(e->E1); + return cat4(cl,cr,c,fixresult87(e,mPSW | mST0,pretregs)); +} + +/************************ + * Do the following opcodes: + * OPd_s16 + * OPd_s32 + * OPd_u16 + * OPd_s64 + */ + +code *cnvt87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + unsigned mf,rf,reg; + tym_t tym; + int clib; + int sz; + int szoff; + + //printf("cnvt87(e = %p, *pretregs = x%x)\n", e, *pretregs); + assert(*pretregs); + tym = e->Ety; + sz = tysize(tym); + szoff = sz; + unsigned grex = I64 ? REX_W << 16 : 0; + + switch (e->Eoper) + { case OPd_s16: + clib = CLIBdblint87; + mf = ESC(MFword,1); + rf = 3; + break; + + case OPd_u16: + szoff = 4; + case OPd_s32: + clib = CLIBdbllng87; + mf = ESC(MFlong,1); + rf = 3; + break; + + case OPd_s64: + clib = CLIBdblllng; + mf = 0xDF; + rf = 7; + break; + + default: + assert(0); + } + + if (I16) // C may change the default control word + { + if (clib == CLIBdblllng) + { retregs = I32 ? DOUBLEREGS_32 : DOUBLEREGS_16; + c1 = codelem(e->E1,&retregs,FALSE); + c2 = callclib(e,clib,pretregs,0); + } + else + { retregs = mST0; //I32 ? DOUBLEREGS_32 : DOUBLEREGS_16; + c1 = codelem(e->E1,&retregs,FALSE); + c2 = callclib(e,clib,pretregs,0); + pop87(); + } + } + else if (1) + { // Generate: + // sub ESP,12 + // fstcw 8[ESP] + // fldcw roundto0 + // fistp long64 ptr [ESP] + // fldcw 8[ESP] + // pop lsw + // pop msw + // add ESP,4 + + unsigned szpush = szoff + 2; + if (config.flags3 & CFG3pic) + szpush += 2; + szpush = (szpush + REGSIZE - 1) & ~(REGSIZE - 1); + + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + + if (szpush == REGSIZE) + c1 = gen1(c1,0x50 + AX); // PUSH EAX + else + c1 = genc2(c1,0x81,grex | modregrm(3,5,SP), szpush); // SUB ESP,12 + c1 = genfwait(c1); + genc1(c1,0xD9,modregrm(2,7,4) + 256*modregrm(0,4,SP),FLconst,szoff); // FSTCW szoff[ESP] + + c1 = genfwait(c1); + + if (config.flags3 & CFG3pic) + { + genc(c1,0xC7,modregrm(2,0,4) + 256*modregrm(0,4,SP),FLconst,szoff+2,FLconst,CW_roundto0); // MOV szoff+2[ESP], CW_roundto0 + code_orflag(c1, CFopsize); + genc1(c1,0xD9,modregrm(2,5,4) + 256*modregrm(0,4,SP),FLconst,szoff+2); // FLDCW szoff+2[ESP] + } + else + c1 = genrnd(c1, CW_roundto0); // FLDCW roundto0 + + pop87(); + + c1 = genfwait(c1); + gen2sib(c1,mf,grex | modregrm(0,rf,4),modregrm(0,4,SP)); // FISTP [ESP] + + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + c2 = allocreg(&retregs,®,tym); + + c2 = genfwait(c2); // FWAIT + c2 = genc1(c2,0xD9,grex | modregrm(2,5,4) + 256*modregrm(0,4,SP),FLconst,szoff); // FLDCW szoff[ESP] + + if (szoff > REGSIZE) + { szpush -= REGSIZE; + c2 = genpop(c2,findreglsw(retregs)); // POP lsw + } + szpush -= REGSIZE; + c2 = genpop(c2,reg); // POP reg + + if (szpush) + genc2(c2,0x81,grex | modregrm(3,0,SP), szpush); // ADD ESP,4 + c2 = cat(c2,fixresult(e,retregs,pretregs)); + } + else + { + // This is incorrect. For -inf and nan, the 8087 returns the largest + // negative int (0x80000....). For -inf, 0x7FFFF... should be returned, + // and for nan, 0 should be returned. + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + + c1 = genfwait(c1); + c1 = genrnd(c1, CW_roundto0); // FLDCW roundto0 + + pop87(); + c1 = genfltreg(c1,mf,rf,0); // FISTP floatreg + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + c2 = allocreg(&retregs,®,tym); + + c2 = genfwait(c2); + + if (sz > REGSIZE) + { c2 = genfltreg(c2,0x8B,reg,REGSIZE); // MOV reg,floatreg + REGSIZE + // MOV lsreg,floatreg + genfltreg(c2,0x8B,findreglsw(retregs),0); + } + else + c2 = genfltreg(c2,0x8B,reg,0); // MOV reg,floatreg + c2 = genrnd(c2, CW_roundtonearest); // FLDCW roundtonearest + c2 = cat(c2,fixresult(e,retregs,pretregs)); + } + return cat(c1,c2); +} + +/************************ + * Do OPrndtol. + */ + +code *cdrndtol(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + unsigned reg; + tym_t tym; + unsigned sz; + unsigned char op1,op2; + + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + tym = e->Ety; + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + + sz = tysize(tym); + switch (sz) + { case 2: + op1 = 0xDF; + op2 = 3; + break; + case 4: + op1 = 0xDB; + op2 = 3; + break; + case 8: + op1 = 0xDF; + op2 = 7; + break; + default: + assert(0); + } + + pop87(); + c1 = genfltreg(c1,op1,op2,0); // FISTP floatreg + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + c2 = allocreg(&retregs,®,tym); + c2 = genfwait(c2); // FWAIT + if (tysize(tym) > REGSIZE) + { c2 = genfltreg(c2,0x8B,reg,REGSIZE); // MOV reg,floatreg + REGSIZE + // MOV lsreg,floatreg + genfltreg(c2,0x8B,findreglsw(retregs),0); + } + else + { + c2 = genfltreg(c2,0x8B,reg,0); // MOV reg,floatreg + if (tysize(tym) == 8 && I64) + code_orrex(c2, REX_W); + } + c2 = cat(c2,fixresult(e,retregs,pretregs)); + + return cat(c1,c2); +} + +/************************* + * Do OPscale, OPyl2x, OPyl2xp1. + */ + +code *cdscale(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2,*c3; + + assert(*pretregs != 0); + + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + note87(e->E1,0,0); + c2 = codelem(e->E2,&retregs,FALSE); + c2 = cat(c2,makesure87(e->E1,0,1,0)); // now have x,y on stack; need y,x + switch (e->Eoper) + { + case OPscale: + c2 = genf2(c2,0xD9,0xFD); // FSCALE + genf2(c2,0xDD,0xD8 + 1); // FSTP ST(1) + break; + + case OPyl2x: + c2 = genf2(c2,0xD9,0xF1); // FYL2X + break; + + case OPyl2xp1: + c2 = genf2(c2,0xD9,0xF9); // FYL2XP1 + break; + } + pop87(); + c3 = fixresult87(e,mST0,pretregs); + return cat3(c1,c2,c3); +} + + +/********************************** + * Unary -, absolute value, square root, sine, cosine + */ + +code *neg87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + int op; + + assert(*pretregs); + switch (e->Eoper) + { case OPneg: op = 0xE0; break; + case OPabs: op = 0xE1; break; + case OPsqrt: op = 0xFA; break; + case OPsin: op = 0xFE; break; + case OPcos: op = 0xFF; break; + case OPrint: op = 0xFC; break; // FRNDINT + default: + assert(0); + } + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + c1 = genf2(c1,0xD9,op); // FCHS/FABS/FSQRT/FSIN/FCOS/FRNDINT + c2 = fixresult87(e,mST0,pretregs); + return cat(c1,c2); +} + +/********************************** + * Unary - for complex operands + */ + +code *neg_complex87(elem *e,regm_t *pretregs) +{ + regm_t retregs; + code *c1,*c2; + + assert(e->Eoper == OPneg); + retregs = mST01; + c1 = codelem(e->E1,&retregs,FALSE); + c1 = genf2(c1,0xD9,0xE0); // FCHS + genf2(c1,0xD9,0xC8 + 1); // FXCH ST(1) + genf2(c1,0xD9,0xE0); // FCHS + genf2(c1,0xD9,0xC8 + 1); // FXCH ST(1) + c2 = fixresult_complex87(e,mST01,pretregs); + return cat(c1,c2); +} + +/********************************* + */ + +code *cdind87(elem *e,regm_t *pretregs) +{ code *c,*ce,cs; + + //printf("cdind87(e = %p, *pretregs = x%x)\n",e,*pretregs); + + c = getlvalue(&cs,e,0); // get addressing mode + if (*pretregs) + { + switch (tybasic(e->Ety)) + { case TYfloat: + case TYifloat: + cs.Iop = 0xD9; + break; + + case TYidouble: + case TYdouble: + case TYdouble_alias: + cs.Iop = 0xDD; + break; + + case TYildouble: + case TYldouble: + cs.Iop = 0xDB; + cs.Irm |= modregrm(0,5,0); + break; + + default: + assert(0); + } + c = cat(c,push87()); + c = gen(c,&cs); // FLD EA + ce = fixresult87(e,mST0,pretregs); + c = cat(c,ce); + } + return c; +} + +/************************************ + * Reset statics for another .obj file. + */ + +void cg87_reset() +{ + memset(&oldd,0,sizeof(oldd)); +} + + +/***************************************** + * Initialize control word constants. + */ + +STATIC code *genrnd(code *c, short cw) +{ + if (config.flags3 & CFG3pic) + { code *c1; + + c1 = genfltreg(NULL, 0xC7, 0, 0); // MOV floatreg, cw + c1->IFL2 = FLconst; + c1->IEV2.Vuns = cw; + + c1 = genfltreg(c1, 0xD9, 5, 0); // FLDCW floatreg + c = cat(c, c1); + } + else + { + if (!oldd.round) // if not initialized + { short cwi; + + oldd.round = 1; + + cwi = CW_roundto0; // round to 0 + oldd.roundto0 = out_readonly_sym(TYshort,&cwi,2); + cwi = CW_roundtonearest; // round to nearest + oldd.roundtonearest = out_readonly_sym(TYshort,&cwi,2); + } + symbol *rnddir = (cw == CW_roundto0) ? oldd.roundto0 : oldd.roundtonearest; + code cs; + cs.Iop = 0xD9; + cs.Iflags = CFoff; + cs.Irex = 0; + cs.IEVsym1 = rnddir; + cs.IFL1 = rnddir->Sfl; + cs.IEVoffset1 = 0; + cs.Irm = modregrm(0,5,BPRM); + c = gen(c,&cs); + } + return c; +} + +/************************* Complex Numbers *********************/ + +/*************************** + * Set the PSW based on the state of ST01. + * Input: + * pop if stack should be popped after test + * Returns: + * start of code appended to c. + */ + +STATIC code * genctst(code *c,elem *e,int pop) +#if __DMC__ +__in +{ + assert(pop == 0 || pop == 1); +} +__body +#endif +{ + // Generate: + // if (pop) + // FLDZ + // FUCOMPP + // FSTSW AX + // SAHF + // FLDZ + // FUCOMPP + // JNE L1 + // JP L1 // if NAN + // FSTSW AX + // SAHF + // L1: + // else + // FLDZ + // FUCOM + // FSTSW AX + // SAHF + // FUCOMP ST(2) + // JNE L1 + // JP L1 // if NAN + // FSTSW AX + // SAHF + // L1: + // FUCOMP doesn't raise exceptions on QNANs, unlike FTST + + code *cnop; + + cnop = gennop(CNIL); + c = cat(c,push87()); + c = gen2(c,0xD9,0xEE); // FLDZ + if (pop) + { + gen2(c,0xDA,0xE9); // FUCOMPP + pop87(); + pop87(); + cg87_87topsw(c); // put 8087 flags in CPU flags + gen2(c,0xD9,0xEE); // FLDZ + gen2(c,0xDA,0xE9); // FUCOMPP + pop87(); + genjmp(c,JNE,FLcode,(block *) cnop); // JNE L1 + genjmp(c,JP, FLcode,(block *) cnop); // JP L1 + cg87_87topsw(c); // put 8087 flags in CPU flags + } + else + { + gen2(c,0xDD,0xE1); // FUCOM + cg87_87topsw(c); // put 8087 flags in CPU flags + gen2(c,0xDD,0xEA); // FUCOMP ST(2) + pop87(); + genjmp(c,JNE,FLcode,(block *) cnop); // JNE L1 + genjmp(c,JP, FLcode,(block *) cnop); // JP L1 + cg87_87topsw(c); // put 8087 flags in CPU flags + } + return cat(c, cnop); +} + +/****************************** + * Given the result of an expression is in retregs, + * generate necessary code to return result in *pretregs. + */ + + +code *fixresult_complex87(elem *e,regm_t retregs,regm_t *pretregs) +{ + tym_t tym; + code *c1,*c2; + unsigned sz; + +#if 0 + printf("fixresult_complex87(e = %p, retregs = %s, *pretregs = %s)\n", + e,regm_str(retregs),regm_str(*pretregs)); +#endif + assert(!*pretregs || retregs); + c1 = CNIL; + c2 = CNIL; + tym = tybasic(e->Ety); + sz = tysize[tym]; + + if (*pretregs == 0 && retregs == mST01) + { + c1 = genf2(c1,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + c1 = genf2(c1,0xDD,modregrm(3,3,0)); // FPOP + pop87(); + } + else if (tym == TYcfloat && *pretregs & (mAX|mDX) && retregs & mST01) + { + if (*pretregs & mPSW && !(retregs & mPSW)) + c1 = genctst(c1,e,0); // FTST + pop87(); + c1 = genfltreg(c1, ESC(MFfloat,1),3,0); // FSTP floatreg + genfwait(c1); + c2 = getregs(mDX|mAX); + c2 = genfltreg(c2, 0x8B, DX, 0); // MOV EDX,floatreg + + pop87(); + c2 = genfltreg(c2, ESC(MFfloat,1),3,0); // FSTP floatreg + genfwait(c2); + c2 = genfltreg(c2, 0x8B, AX, 0); // MOV EAX,floatreg + } + else if (tym == TYcfloat && retregs & (mAX|mDX) && *pretregs & mST01) + { + c1 = push87(); + c1 = genfltreg(c1, 0x89, AX, 0); // MOV floatreg, EAX + genfltreg(c1, 0xD9, 0, 0); // FLD float ptr floatreg + + c2 = push87(); + c2 = genfltreg(c2, 0x89, DX, 0); // MOV floatreg, EDX + genfltreg(c2, 0xD9, 0, 0); // FLD float ptr floatreg + + if (*pretregs & mPSW) + c2 = genctst(c2,e,0); // FTST + } + else if ((tym == TYcfloat || tym == TYcdouble) && + *pretregs & (mXMM0|mXMM1) && retregs & mST01) + { + if (*pretregs & mPSW && !(retregs & mPSW)) + c1 = genctst(c1,e,0); // FTST + pop87(); + c1 = genfltreg(c1, ESC(MFdouble,1),3,0); // FSTP floatreg + genfwait(c1); + c2 = getregs(mXMM0|mXMM1); + c2 = genfltreg(c2, 0xF20F10, XMM1 - XMM0, 0); // MOVD XMM1,floatreg + + pop87(); + c2 = genfltreg(c2, ESC(MFdouble,1),3,0); // FSTP floatreg + genfwait(c2); + c2 = genfltreg(c2, 0xF20F10, XMM0 - XMM0, 0); // MOVD XMM0,floatreg + } + else if ((tym == TYcfloat || tym == TYcdouble) && + retregs & (mXMM0|mXMM1) && *pretregs & mST01) + { + c1 = push87(); + c1 = genfltreg(c1, 0xF20F11, XMM0-XMM0, 0); // MOVD floatreg, XMM0 + genfltreg(c1, 0xDD, 0, 0); // FLD double ptr floatreg + + c2 = push87(); + c2 = genfltreg(c2, 0xF20F11, XMM1-XMM0, 0); // MOV floatreg, XMM1 + genfltreg(c2, 0xDD, 0, 0); // FLD double ptr floatreg + + if (*pretregs & mPSW) + c2 = genctst(c2,e,0); // FTST + } + else + { if (*pretregs & mPSW) + { if (!(retregs & mPSW)) + { assert(retregs & mST01); + c1 = genctst(c1,e,!(*pretregs & mST01)); // FTST + } + } + assert(!(*pretregs & mST01) || (retregs & mST01)); + } + if (*pretregs & mST01) + { note87(e,0,1); + note87(e,sz/2,0); + } + return cat(c1,c2); +} + +/***************************************** + * Operators OPc_r and OPc_i + */ + +code *cdconvt87(elem *e, regm_t *pretregs) +{ + regm_t retregs; + code *c; + + retregs = mST01; + c = codelem(e->E1, &retregs, FALSE); + switch (e->Eoper) + { + case OPc_r: + c = genf2(c,0xDD,0xD8 + 0); // FPOP + pop87(); + break; + + case OPc_i: + c = genf2(c,0xDD,0xD8 + 1); // FSTP ST(1) + pop87(); + break; + + default: + assert(0); + } + retregs = mST0; + c = cat(c, fixresult87(e, retregs, pretregs)); + return c; +} + +/************************************** + * Load complex operand into ST01 or flags or both. + */ + +code *cload87(elem *e, regm_t *pretregs) +#if __DMC__ +__in +{ + assert(I32 && config.inline8087); + elem_debug(e); + assert(*pretregs & (mST01 | mPSW)); + assert(!(*pretregs & ~(mST01 | mPSW))); +} +__out (result) +{ +} +__body +#endif +{ + tym_t ty = tybasic(e->Ety); + code *c = NULL; + code *cpush = NULL; + code cs; + unsigned mf; + unsigned sz; + unsigned char ldop; + regm_t retregs; + int i; + + //printf("cload87(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + sz = tysize[ty] / 2; + memset(&cs, 0, sizeof(cs)); + if (ADDFWAIT()) + cs.Iflags = CFwait; + switch (ty) + { + case TYcfloat: mf = MFfloat; break; + case TYcdouble: mf = MFdouble; break; + case TYcldouble: break; + default: assert(0); + } + switch (e->Eoper) + { + case OPvar: + notreg(e); // never enregister this variable + case OPind: + cpush = cat(push87(), push87()); + switch (ty) + { + case TYcfloat: + case TYcdouble: + c = loadea(e,&cs,ESC(mf,1),0,0,0,0); // FLD var + cs.IEVoffset1 += sz; + c = gen(c, &cs); + break; + + case TYcldouble: + c = loadea(e,&cs,0xDB,5,0,0,0); // FLD var + cs.IEVoffset1 += sz; + c = gen(c, &cs); + break; + + default: + assert(0); + } + retregs = mST01; + break; + + case OPd_ld: + case OPld_d: + case OPf_d: + case OPd_f: + c = cload87(e->E1, pretregs); + freenode(e->E1); + return c; + + case OPconst: + cpush = cat(push87(), push87()); + for (i = 0; i < 2; i++) + { + ldop = loadconst(e, i); + if (ldop) + { + c = genf2(c,0xD9,ldop); // FLDx + } + else + { + assert(0); + } + } + retregs = mST01; + break; + + default: +#ifdef DEBUG + elem_print(e); +#endif + assert(0); + } + return cat4(cpush,c,fixresult_complex87(e, retregs, pretregs), NULL); +} + +#endif // !SPP diff --git a/backend/cgcod.c b/backend/cgcod.c new file mode 100644 index 00000000..395b4fa2 --- /dev/null +++ b/backend/cgcod.c @@ -0,0 +1,2527 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt. + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "global.h" +#include "type.h" +#include "exh.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +STATIC void resetEcomsub(elem *e); +STATIC code * loadcse(elem *,unsigned,regm_t); +STATIC void blcodgen(block *); +STATIC void cgcod_eh(); +STATIC code * cse_save(regm_t ms); +STATIC int cse_simple(elem *e,int i); +STATIC code * comsub(elem *,regm_t *); + +bool floatreg; // !=0 if floating register is required + +targ_size_t Aoffset; // offset of automatics and registers +targ_size_t Toffset; // offset of temporaries +targ_size_t EEoffset; // offset of SCstack variables from ESP +int Aalign; // alignment for Aoffset + +REGSAVE regsave; + +CGstate cgstate; // state of code generator + +/************************************ + * # of bytes that SP is beyond BP. + */ + +unsigned stackpush; + +int stackchanged; /* set to !=0 if any use of the stack + other than accessing parameters. Used + to see if we can address parameters + with ESP rather than EBP. + */ +int refparam; // !=0 if we referenced any parameters +int reflocal; // !=0 if we referenced any locals +char anyiasm; // !=0 if any inline assembler +char calledafunc; // !=0 if we called a function +char needframe; // if TRUE, then we will need the frame + // pointer (BP for the 8088) +char usedalloca; // if TRUE, then alloca() was called +char gotref; // !=0 if the GOTsym was referenced +unsigned usednteh; // if !=0, then used NT exception handling + +/* Register contents */ +con_t regcon; + +int pass; // PASSxxxx + +static symbol *retsym; // set to symbol that should be placed in + // register AX + +/**************************** + * Register masks. + */ + +regm_t msavereg; // Mask of registers that we would like to save. + // they are temporaries (set by scodelem()) +regm_t mfuncreg; // Mask of registers preserved by a function +regm_t allregs; // ALLREGS optionally including mBP + +int dfoidx; /* which block we are in */ +struct CSE *csextab = NULL; /* CSE table (allocated for each function) */ +unsigned cstop; /* # of entries in CSE table (csextab[]) */ +unsigned csmax; /* amount of space in csextab[] */ + +targ_size_t funcoffset; // offset of start of function +targ_size_t startoffset; // size of function entry code +targ_size_t retoffset; /* offset from start of func to ret code */ +targ_size_t retsize; /* size of function return */ + +static regm_t lastretregs,last2retregs,last3retregs,last4retregs,last5retregs; + +/********************************* + * Generate code for a function. + * Note at the end of this routine mfuncreg will contain the mask + * of registers not affected by the function. Some minor optimization + * possibilities are here... + */ + +void codgen() +{ block *b,*bn; + bool flag; + int i; + targ_size_t swoffset,coffset; + tym_t functy; + unsigned nretblocks; // number of return blocks + code *cprolog; + regm_t noparams; +#if SCPP + block *btry; +#endif + // Register usage. If a bit is on, the corresponding register is live + // in that basic block. + + //printf("codgen('%s')\n",funcsym_p->Sident); + + cgreg_init(); + csmax = 64; + csextab = (struct CSE *) util_calloc(sizeof(struct CSE),csmax); + functy = tybasic(funcsym_p->ty()); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + regm_t value = BYTEREGS_INIT; + ALLREGS = ALLREGS_INIT; + BYTEREGS = value; + if (I64) + { ALLREGS = mAX|mBX|mCX|mDX|mSI|mDI| mR8|mR9|mR10|mR11|mR12|mR13|mR14|mR15; + BYTEREGS = ALLREGS; + } +#endif + allregs = ALLREGS; + pass = PASSinit; + +tryagain: + #ifdef DEBUG + if (debugr) + printf("------------------ PASS%s -----------------\n", + (pass == PASSinit) ? "init" : ((pass == PASSreg) ? "reg" : "final")); + #endif + lastretregs = last2retregs = last3retregs = last4retregs = last5retregs = 0; + + // if no parameters, assume we don't need a stack frame + needframe = 0; + usedalloca = 0; + gotref = 0; + stackchanged = 0; + stackpush = 0; + refparam = 0; + anyiasm = 0; + calledafunc = 0; + cgstate.stackclean = 1; + retsym = NULL; + + regsave.reset(); +#if TX86 + memset(_8087elems,0,sizeof(_8087elems)); +#endif + + usednteh = 0; +#if (MARS) && TARGET_WINDOS + if (funcsym_p->Sfunc->Fflags3 & Fjmonitor) + usednteh |= NTEHjmonitor; +#else + if (CPP) + { + if (config.flags2 & CFG2seh && + (funcsym_p->Stype->Tflags & TFemptyexc || funcsym_p->Stype->Texcspec)) + usednteh |= NTEHexcspec; + except_reset(); + } +#endif + + floatreg = FALSE; +#if TX86 + assert(stackused == 0); /* nobody in 8087 stack */ +#endif + cstop = 0; /* no entries in table yet */ + memset(®con,0,sizeof(regcon)); + regcon.cse.mval = regcon.cse.mops = 0; // no common subs yet + msavereg = 0; + nretblocks = 0; + mfuncreg = fregsaved; // so we can see which are used + // (bit is cleared each time + // we use one) + for (b = startblock; b; b = b->Bnext) + { memset(&b->Bregcon,0,sizeof(b->Bregcon)); // Clear out values in registers + if (b->Belem) + resetEcomsub(b->Belem); // reset all the Ecomsubs + if (b->BC == BCasm) + anyiasm = 1; // we have inline assembler + if (b->BC == BCret || b->BC == BCretexp) + nretblocks++; + } + + if (!config.fulltypes || (config.flags4 & CFG4optimized)) + { + noparams = 0; + for (i = 0; i < globsym.top; i++) + { + Symbol *s = globsym.tab[i]; + s->Sflags &= ~SFLread; + switch (s->Sclass) + { case SCfastpar: + regcon.params |= mask[s->Spreg]; + case SCparameter: + if (s->Sfl == FLreg) + noparams |= s->Sregm; + break; + } + } + regcon.params &= ~noparams; + } + + if (config.flags4 & CFG4optimized) + { + if (nretblocks == 0 && // if no return blocks in function + !(funcsym_p->ty() & mTYnaked)) // naked functions may have hidden veys of returning + funcsym_p->Sflags |= SFLexit; // mark function as never returning + + assert(dfo); + + cgreg_reset(); + for (dfoidx = 0; dfoidx < dfotop; dfoidx++) + { regcon.used = msavereg | regcon.cse.mval; // registers already in use + b = dfo[dfoidx]; + blcodgen(b); // gen code in depth-first order + //printf("b->Bregcon.used = x%x\n", b->Bregcon.used); + cgreg_used(dfoidx,b->Bregcon.used); // gather register used information + } + } + else + { pass = PASSfinal; + for (b = startblock; b; b = b->Bnext) + blcodgen(b); // generate the code for each block + } + regcon.immed.mval = 0; + assert(!regcon.cse.mops); // should have all been used + + // See which variables we can put into registers + if (pass != PASSfinal && + !anyiasm) // possible LEA or LES opcodes + { + allregs |= cod3_useBP(); // see if we can use EBP + + // If pic code, but EBX was never needed + if (!(allregs & mBX) && !gotref) + { allregs |= mBX; // EBX can now be used + cgreg_assign(retsym); + pass = PASSreg; + } + else if (cgreg_assign(retsym)) // if we found some registers + pass = PASSreg; + else + pass = PASSfinal; + for (b = startblock; b; b = b->Bnext) + { code_free(b->Bcode); + b->Bcode = NULL; + } + goto tryagain; + } + cgreg_term(); + +#if SCPP + if (CPP) + cgcod_eh(); +#endif + + stackoffsets(1); // compute addresses of stack variables + cod5_prol_epi(); // see where to place prolog/epilog + + // Get rid of unused cse temporaries + while (cstop != 0 && (csextab[cstop - 1].flags & CSEload) == 0) + cstop--; + + if (configv.addlinenumbers) + objlinnum(funcsym_p->Sfunc->Fstartline,Coffset); + + // Otherwise, jmp's to startblock will execute the prolog again + assert(!startblock->Bpred); + + cprolog = prolog(); // gen function start code + if (cprolog) + pinholeopt(cprolog,NULL); // optimize + + funcoffset = Coffset; + coffset = Coffset; + + if (eecontext.EEelem) + genEEcode(); + + for (b = startblock; b; b = b->Bnext) + { + // We couldn't do this before because localsize was unknown + switch (b->BC) + { case BCret: + if (configv.addlinenumbers && b->Bsrcpos.Slinnum && !(funcsym_p->ty() & mTYnaked)) + cgen_linnum(&b->Bcode,b->Bsrcpos); + case BCretexp: + epilog(b); + break; + default: + if (b->Bflags & BFLepilog) + epilog(b); + break; + } + assignaddr(b); // assign addresses + pinholeopt(b->Bcode,b); // do pinhole optimization + if (b->Bflags & BFLprolog) // do function prolog + { + startoffset = coffset + calcblksize(cprolog) - funcoffset; + b->Bcode = cat(cprolog,b->Bcode); + } + cgsched_block(b); + b->Bsize = calcblksize(b->Bcode); // calculate block size + if (b->Balign) + { targ_size_t u = b->Balign - 1; + + coffset = (coffset + u) & ~u; + } + b->Boffset = coffset; /* offset of this block */ + coffset += b->Bsize; /* offset of following block */ + } +#ifdef DEBUG + debugw && printf("code addr complete\n"); +#endif + + // Do jump optimization + do + { flag = FALSE; + for (b = startblock; b; b = b->Bnext) + { if (b->Bflags & BFLjmpoptdone) /* if no more jmp opts for this blk */ + continue; + i = branch(b,0); // see if jmp => jmp short + if (i) /* if any bytes saved */ + { targ_size_t offset; + + b->Bsize -= i; + offset = b->Boffset + b->Bsize; + for (bn = b->Bnext; bn; bn = bn->Bnext) + { + if (bn->Balign) + { targ_size_t u = bn->Balign - 1; + + offset = (offset + u) & ~u; + } + bn->Boffset = offset; + offset += bn->Bsize; + } + coffset = offset; + flag = TRUE; + } + } + if (!I16 && !(config.flags4 & CFG4optimized)) + break; // use the long conditional jmps + } while (flag); // loop till no more bytes saved +#ifdef DEBUG + debugw && printf("code jump optimization complete\n"); +#endif + +#if MARS + if (usednteh & NTEH_try) + { + // Do this before code is emitted because we patch some instructions + nteh_filltables(); + } +#endif + + // Compute starting offset for switch tables +#if ELFOBJ || MACHOBJ + swoffset = (config.flags & CFGromable) ? coffset : CDoffset; +#else + swoffset = (config.flags & CFGromable) ? coffset : Doffset; +#endif + swoffset = align(0,swoffset); + + // Emit the generated code + if (eecontext.EEcompile == 1) + { + codout(eecontext.EEcode); + code_free(eecontext.EEcode); +#if SCPP + el_free(eecontext.EEelem); +#endif + } + else + { + for (b = startblock; b; b = b->Bnext) + { + if (b->BC == BCjmptab || b->BC == BCswitch) + { b->Btableoffset = swoffset; /* offset of sw tab */ + swoffset += b->Btablesize; + } + jmpaddr(b->Bcode); /* assign jump addresses */ +#ifdef DEBUG + if (debugc) + { printf("Boffset = x%lx, Bsize = x%lx, Coffset = x%lx\n", + (long)b->Boffset,(long)b->Bsize,(long)Coffset); + if (b->Bcode) + printf( "First opcode of block is: %0x\n", b->Bcode->Iop ); + } +#endif + if (b->Balign) + { unsigned u = b->Balign; + unsigned nalign = (u - (unsigned)Coffset) & (u - 1); + + while (nalign--) + obj_byte(cseg,Coffset++,0x90); // XCHG AX,AX + } + assert(b->Boffset == Coffset); + +#if SCPP + if (CPP && + !(config.flags2 & CFG2seh)) + { + //printf("b = %p, index = %d\n",b,b->Bindex); + //except_index_set(b->Bindex); + + if (btry != b->Btry) + { + btry = b->Btry; + except_pair_setoffset(b,Coffset - funcoffset); + } + if (b->BC == BCtry) + { + btry = b; + except_pair_setoffset(b,Coffset - funcoffset); + } + } +#endif + codout(b->Bcode); // output code + } + if (coffset != Coffset) + { +#ifdef DEBUG + printf("coffset = %ld, Coffset = %ld\n",(long)coffset,(long)Coffset); +#endif + assert(0); + } + funcsym_p->Ssize = Coffset - funcoffset; // size of function + +#if NTEXCEPTIONS || MARS +#if (SCPP && NTEXCEPTIONS) + if (usednteh & NTEHcpp) +#elif MARS + if (usednteh & NTEH_try) +#endif + { assert(!(config.flags & CFGromable)); + //printf("framehandleroffset = x%x, coffset = x%x\n",framehandleroffset,coffset); + reftocodseg(cseg,framehandleroffset,coffset); + } +#endif + + + // Write out switch tables + flag = FALSE; // TRUE if last active block was a ret + for (b = startblock; b; b = b->Bnext) + { + switch (b->BC) + { case BCjmptab: /* if jump table */ + outjmptab(b); /* write out jump table */ + break; + case BCswitch: + outswitab(b); /* write out switch table */ + break; + case BCret: + case BCretexp: + /* Compute offset to return code from start of function */ + retoffset = b->Boffset + b->Bsize - retsize - funcoffset; +#if MARS + /* Add 3 bytes to retoffset in case we have an exception + * handler. THIS PROBABLY NEEDS TO BE IN ANOTHER SPOT BUT + * IT FIXES THE PROBLEM HERE AS WELL. + */ + if (usednteh & NTEH_try) + retoffset += 3; +#endif + flag = TRUE; + break; + case BCexit: + // Fake it to keep debugger happy + retoffset = b->Boffset + b->Bsize - funcoffset; + break; + } + } + if (flag && configv.addlinenumbers && !(funcsym_p->ty() & mTYnaked)) + /* put line number at end of function on the + start of the last instruction + */ + /* Instead, try offset to cleanup code */ + objlinnum(funcsym_p->Sfunc->Fendline,funcoffset + retoffset); + +#if MARS + if (usednteh & NTEH_try) + { + // Do this before code is emitted because we patch some instructions + nteh_gentables(); + } + if (usednteh & EHtry) + { + except_gentables(); + } +#endif + +#if SCPP +#if NTEXCEPTIONS + // Write out frame handler + if (usednteh & NTEHcpp) + nteh_framehandler(except_gentables()); + else +#endif + { +#if NTEXCEPTIONS + if (usednteh & NTEH_try) + nteh_gentables(); + else +#endif + { + if (CPP) + except_gentables(); + } + ; + } +#endif + for (b = startblock; b; b = b->Bnext) + { + code_free(b->Bcode); + b->Bcode = NULL; + } + + } + + // Mask of regs saved + // BUG: do interrupt functions save BP? + funcsym_p->Sregsaved = (functy == TYifunc) ? mBP : (mfuncreg | fregsaved); + + util_free(csextab); + csextab = NULL; +#if TX86 +#ifdef DEBUG + if (stackused != 0) + printf("stackused = %d\n",stackused); +#endif + assert(stackused == 0); /* nobody in 8087 stack */ + + /* Clean up ndp save array */ + mem_free(NDP::save); + NDP::save = NULL; + NDP::savetop = 0; + NDP::savemax = 0; +#endif +} + + +/****************************** + * Compute offsets for remaining tmp, automatic and register variables + * that did not make it into registers. + */ + +void stackoffsets(int flags) +{ + symbol *s; + targ_size_t Amax,sz; + unsigned alignsize; + int offi; +#if AUTONEST + targ_size_t offstack[20]; + int offi = 0; // index into offstack[] +#endif + vec_t tbl = NULL; + + + //printf("stackoffsets()\n"); + if (config.flags4 & CFG4optimized) + { + tbl = vec_calloc(globsym.top); + } + Aoffset = 0; // automatic & register offset + Toffset = 0; // temporary offset + Poffset = 0; // parameter offset + EEoffset = 0; // for SCstack's + Amax = 0; + Aalign = REGSIZE; + for (int pass = 0; pass < 2; pass++) + { + for (int si = 0; si < globsym.top; si++) + { s = globsym.tab[si]; + if (s->Sflags & SFLdead || + (!anyiasm && !(s->Sflags & SFLread) && s->Sflags & SFLunambig && +#if MARS + /* mTYvolatile was set if s has been reference by a nested function + * meaning we'd better allocate space for it + */ + !(s->Stype->Tty & mTYvolatile) && +#endif + (config.flags4 & CFG4optimized || !config.fulltypes)) + ) + sz = 0; + else + { sz = type_size(s->Stype); + if (sz == 0) + sz++; // can't handle 0 length structs + } + alignsize = type_alignsize(s->Stype); + + //printf("symbol '%s', size = x%lx, align = %d, read = %x\n",s->Sident,(long)sz, (int)type_alignsize(s->Stype), s->Sflags & SFLread); + assert((int)sz >= 0); + + if (pass == 1) + { + if (s->Sclass == SCfastpar) // if parameter s is passed in a register + { + /* Allocate in second pass in order to get these + * right next to the stack frame pointer, EBP. + * Needed so we can call nested contract functions + * frequire and fensure. + */ + if (s->Sfl == FLreg) // if allocated in register + continue; + /* Needed because storing fastpar's on the stack in prolog() + * does the entire register + */ + if (sz < REGSIZE) + sz = REGSIZE; + + Aoffset = align(sz,Aoffset); + s->Soffset = Aoffset; + Aoffset += sz; + if (Aoffset > Amax) + Amax = Aoffset; + //printf("fastpar '%s' sz = %d, auto offset = x%lx\n",s->Sident,sz,(long)s->Soffset); + + // Align doubles to 8 byte boundary + if (!I16 && alignsize > REGSIZE) + Aalign = alignsize; + } + continue; + } + + /* Can't do this for CPP because the inline function expander + adds new symbols on the end. + */ +#if AUTONEST + /*printf("symbol '%s', push = %d, pop = %d\n", + s->Sident,s->Spush,s->Spop);*/ + + /* Can't do this for optimizer if any code motion occurred. + Code motion changes the live range, so variables that + occupy the same space could have live ranges that overlap! + */ + if (config.flags4 & CFG4optimized) + s->Spop = 0; + else + while (s->Spush != 0) + { s->Spush--; + assert(offi < arraysize(offstack)); + /*printf("Pushing offset x%x\n",Aoffset);*/ + offstack[offi++] = Aoffset; + } +#endif + + switch (s->Sclass) + { + case SCfastpar: + break; // ignore on pass 0 + case SCregister: + case SCauto: + if (s->Sfl == FLreg) // if allocated in register + break; + // See if we can share storage with another variable + if (config.flags4 & CFG4optimized && + // Don't share because could stomp on variables + // used in finally blocks + !(usednteh & ~NTEHjmonitor) && + s->Srange && sz && flags && !(s->Sflags & SFLspill)) + { + for (int i = 0; i < si; i++) + { + if (!vec_testbit(i,tbl)) + continue; + symbol *sp = globsym.tab[i]; +//printf("auto s = '%s', sp = '%s', %d, %d, %d\n",s->Sident,sp->Sident,dfotop,vec_numbits(s->Srange),vec_numbits(sp->Srange)); + if (vec_disjoint(s->Srange,sp->Srange) && + sz <= type_size(sp->Stype)) + { + vec_or(sp->Srange,sp->Srange,s->Srange); + //printf("sharing space - '%s' onto '%s'\n",s->Sident,sp->Sident); + s->Soffset = sp->Soffset; + goto L2; + } + } + } + Aoffset = align(sz,Aoffset); + s->Soffset = Aoffset; + //printf("auto '%s' sz = %d, auto offset = x%lx\n",s->Sident,sz,(long)s->Soffset); + Aoffset += sz; + if (Aoffset > Amax) + Amax = Aoffset; + if (s->Srange && sz && !(s->Sflags & SFLspill)) + vec_setbit(si,tbl); + + // Align doubles to 8 byte boundary + if (!I16 && type_alignsize(s->Stype) > REGSIZE) + Aalign = type_alignsize(s->Stype); + L2: + break; + + case SCtmp: + // Allocated separately from SCauto to avoid storage + // overlapping problems. + Toffset = align(sz,Toffset); + s->Soffset = Toffset; + //printf("tmp offset = x%lx\n",(long)s->Soffset); + Toffset += sz; + break; + + case SCstack: + EEoffset = align(sz,EEoffset); + s->Soffset = EEoffset; + //printf("EEoffset = x%lx\n",(long)s->Soffset); + EEoffset += sz; + break; + + case SCparameter: + Poffset = align(REGSIZE,Poffset); /* align on word stack boundary */ + if (I64 && alignsize == 16 && Poffset & 8) + Poffset += 8; + s->Soffset = Poffset; + //printf("%s param offset = x%lx, alignsize = %d\n",s->Sident,(long)s->Soffset, (int)alignsize); + Poffset += (s->Sflags & SFLdouble) + ? type_size(tsdouble) // float passed as double + : type_size(s->Stype); + break; + case SCpseudo: + case SCstatic: + case SCbprel: + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + +#if AUTONEST + while (s->Spop != 0) + { s->Spop--; + assert(offi > 0); + Aoffset = offstack[--offi]; + /*printf("Popping offset x%x\n",Aoffset);*/ + } +#endif + } + } + Aoffset = Amax; + Aoffset = align(0,Aoffset); + if (Aalign > REGSIZE) + Aoffset = (Aoffset + Aalign - 1) & ~(Aalign - 1); + //printf("Aligned Aoffset = x%lx, Toffset = x%lx\n", (long)Aoffset,(long)Toffset); + Toffset = align(0,Toffset); + + if (config.flags4 & CFG4optimized) + { + vec_free(tbl); + } +} + +/**************************** + * Generate code for a block. + */ + +STATIC void blcodgen(block *bl) +{ + code *c; + list_t bpl; + int refparamsave; + regm_t mfuncregsave = mfuncreg; + char *sflsave = NULL; + int anyspill; + + //dbg_printf("blcodgen(%p)\n",bl); + + /* Determine existing immediate values in registers by ANDing + together the values from all the predecessors of b. + */ + assert(bl->Bregcon.immed.mval == 0); + regcon.immed.mval = 0; // assume no previous contents in registers +// regcon.cse.mval = 0; + for (bpl = bl->Bpred; bpl; bpl = list_next(bpl)) + { block *bp = list_block(bpl); + + if (bpl == bl->Bpred) + { regcon.immed = bp->Bregcon.immed; + regcon.params = bp->Bregcon.params; +// regcon.cse = bp->Bregcon.cse; + } + else + { int i; + + regcon.params &= bp->Bregcon.params; + if ((regcon.immed.mval &= bp->Bregcon.immed.mval) != 0) + // Actual values must match, too + for (i = 0; i < REGMAX; i++) + { + if (regcon.immed.value[i] != bp->Bregcon.immed.value[i]) + regcon.immed.mval &= ~mask[i]; + } + } + } + regcon.cse.mops &= regcon.cse.mval; + + // Set regcon.mvar according to what variables are in registers for this block + c = NULL; + regcon.mvar = 0; + regcon.mpvar = 0; + regcon.indexregs = 1; + anyspill = 0; + if (config.flags4 & CFG4optimized) + { SYMIDX i; + code *cload = NULL; + code *cstore = NULL; + + sflsave = (char *) alloca(globsym.top * sizeof(char)); + for (i = 0; i < globsym.top; i++) + { symbol *s = globsym.tab[i]; + + sflsave[i] = s->Sfl; + if (s->Sclass & SCfastpar && + regcon.params & mask[s->Spreg] && + vec_testbit(dfoidx,s->Srange)) + { + regcon.used |= mask[s->Spreg]; + } + + if (s->Sfl == FLreg) + { if (vec_testbit(dfoidx,s->Srange)) + { regcon.mvar |= s->Sregm; + if (s->Sclass == SCfastpar) + regcon.mpvar |= s->Sregm; + } + } + else if (s->Sflags & SFLspill) + { if (vec_testbit(dfoidx,s->Srange)) + { + anyspill = i + 1; + cgreg_spillreg_prolog(bl,s,&cstore,&cload); + if (vec_testbit(dfoidx,s->Slvreg)) + { s->Sfl = FLreg; + regcon.mvar |= s->Sregm; + regcon.cse.mval &= ~s->Sregm; + regcon.immed.mval &= ~s->Sregm; + if (s->Sclass == SCfastpar) + regcon.mpvar |= s->Sregm; + } + } + } + } + if ((regcon.cse.mops & regcon.cse.mval) != regcon.cse.mops) + { code *cx; + + cx = cse_save(regcon.cse.mops & ~regcon.cse.mval); + cstore = cat(cx, cstore); + } + c = cat(cstore,cload); + mfuncreg &= ~regcon.mvar; // use these registers + regcon.used |= regcon.mvar; + + // Determine if we have more than 1 uncommitted index register + regcon.indexregs = IDXREGS & ~regcon.mvar; + regcon.indexregs &= regcon.indexregs - 1; + } + + regsave.idx = 0; + reflocal = 0; + refparamsave = refparam; + refparam = 0; + assert((regcon.cse.mops & regcon.cse.mval) == regcon.cse.mops); + + outblkexitcode(bl, c, anyspill, sflsave, &retsym, mfuncregsave); + + for (int i = 0; i < anyspill; i++) + { symbol *s = globsym.tab[i]; + + s->Sfl = sflsave[i]; // undo block register assignments + } + + if (reflocal) + bl->Bflags |= BFLreflocal; + if (refparam) + bl->Bflags |= BFLrefparam; + refparam |= refparamsave; + bl->Bregcon.immed = regcon.immed; + bl->Bregcon.cse = regcon.cse; + bl->Bregcon.used = regcon.used; + bl->Bregcon.params = regcon.params; +#ifdef DEBUG + debugw && printf("code gen complete\n"); +#endif +} + +/***************************************** + * Add in exception handling code. + */ + +#if SCPP + +STATIC void cgcod_eh() +{ block *btry; + code *c; + code *c1; + list_t stack; + list_t list; + block *b; + int idx; + int lastidx; + int tryidx; + int i; + + if (!(usednteh & (EHtry | EHcleanup))) + return; + + // Compute Bindex for each block + for (b = startblock; b; b = b->Bnext) + { b->Bindex = -1; + b->Bflags &= ~BFLvisited; /* mark as unvisited */ + } + btry = NULL; + lastidx = 0; + startblock->Bindex = 0; + for (b = startblock; b; b = b->Bnext) + { + if (btry == b->Btry && b->BC == BCcatch) // if don't need to pop try block + { block *br; + + br = list_block(b->Bpred); // find corresponding try block + assert(br->BC == BCtry); + b->Bindex = br->Bindex; + } + else if (btry != b->Btry && b->BC != BCcatch || + !(b->Bflags & BFLvisited)) + b->Bindex = lastidx; + b->Bflags |= BFLvisited; +#ifdef DEBUG + if (debuge) + { + WRBC(b->BC); + dbg_printf(" block (%p) Btry=%p Bindex=%d\n",b,b->Btry,b->Bindex); + } +#endif + except_index_set(b->Bindex); + if (btry != b->Btry) // exited previous try block + { + except_pop(b,NULL,btry); + btry = b->Btry; + } + if (b->BC == BCtry) + { + except_push(b,NULL,b); + btry = b; + tryidx = except_index_get(); + b->Bcode = cat(nteh_gensindex(tryidx - 1),b->Bcode); + } + + stack = NULL; + for (c = b->Bcode; c; c = code_next(c)) + { + if ((c->Iop & 0xFF) == ESCAPE) + { + c1 = NULL; + switch (c->Iop & 0xFFFF00) + { + case ESCctor: +//printf("ESCctor\n"); + except_push(c,c->IEV1.Vtor,NULL); + goto L1; + + case ESCdtor: +//printf("ESCdtor\n"); + except_pop(c,c->IEV1.Vtor,NULL); + L1: if (config.flags2 & CFG2seh) + { + c1 = nteh_gensindex(except_index_get() - 1); + code_next(c1) = code_next(c); + code_next(c) = c1; + } + break; + case ESCmark: +//printf("ESCmark\n"); + idx = except_index_get(); + list_prependdata(&stack,idx); + except_mark(); + break; + case ESCrelease: +//printf("ESCrelease\n"); + idx = list_data(stack); + list_pop(&stack); + if (idx != except_index_get()) + { + if (config.flags2 & CFG2seh) + { c1 = nteh_gensindex(idx - 1); + code_next(c1) = code_next(c); + code_next(c) = c1; + } + else + { except_pair_append(c,idx - 1); + c->Iop = ESCAPE | ESCoffset; + } + } + except_release(); + break; + case ESCmark2: +//printf("ESCmark2\n"); + except_mark(); + break; + case ESCrelease2: +//printf("ESCrelease2\n"); + except_release(); + break; + } + } + } + assert(stack == NULL); + b->Bendindex = except_index_get(); + + if (b->BC != BCret && b->BC != BCretexp) + lastidx = b->Bendindex; + + // Set starting index for each of the successors + i = 0; + for (list = b->Bsucc; list; list = list_next(list)) + { block *bs = list_block(list); + + if (b->BC == BCtry) + { switch (i) + { case 0: // block after catches + bs->Bindex = b->Bendindex; + break; + case 1: // 1st catch block + bs->Bindex = tryidx; + break; + default: // subsequent catch blocks + bs->Bindex = b->Bindex; + break; + } +#ifdef DEBUG + if (debuge) + { + dbg_printf(" 1setting %p to %d\n",bs,bs->Bindex); + } +#endif + } + else if (!(bs->Bflags & BFLvisited)) + { + bs->Bindex = b->Bendindex; +#ifdef DEBUG + if (debuge) + { + dbg_printf(" 2setting %p to %d\n",bs,bs->Bindex); + } +#endif + } + bs->Bflags |= BFLvisited; + i++; + } + } + + if (config.flags2 & CFG2seh) + for (b = startblock; b; b = b->Bnext) + { + if (/*!b->Bcount ||*/ b->BC == BCtry) + continue; + for (list = b->Bpred; list; list = list_next(list)) + { int pi; + + pi = list_block(list)->Bendindex; + if (b->Bindex != pi) + { + b->Bcode = cat(nteh_gensindex(b->Bindex - 1),b->Bcode); + break; + } + } + } +} + +#endif + +/****************************** + * Count the number of bits set in a register mask. + */ + +int numbitsset(regm_t regm) +{ int n; + + n = 0; + if (regm) + do + n++; + while ((regm &= regm - 1) != 0); + return n; +} + +/****************************** + * Given a register mask, find and return the number + * of the first register that fits. + */ + +#undef findreg + +unsigned findreg(regm_t regm +#ifdef DEBUG + ,int line,const char *file +#endif + ) +#ifdef DEBUG +#define findreg(regm) findreg((regm),__LINE__,__FILE__) +#endif +{ +#ifdef DEBUG + regm_t regmsave = regm; +#endif + int i = 0; + while (1) + { + if (!(regm & 0xF)) + { + regm >>= 4; + i += 4; + if (!regm) + break; + } + if (regm & 1) + return i; + regm >>= 1; + i++; + } +#ifdef DEBUG + printf("findreg(x%x, line=%d, file='%s')\n",regmsave,line,file); + fflush(stdout); +#endif +//*(char*)0=0; + assert(0); + return 0; +} + +/*************** + * Free element (but not it's leaves! (assume they are already freed)) + * Don't decrement Ecount! This is so we can detect if the common subexp + * has already been evaluated. + * If common subexpression is not required anymore, eliminate + * references to it. + */ + +void freenode(elem *e) +{ unsigned i; + + elem_debug(e); + //dbg_printf("freenode(%p) : comsub = %d, count = %d\n",e,e->Ecomsub,e->Ecount); + if (e->Ecomsub--) return; /* usage count */ + if (e->Ecount) /* if it was a CSE */ + { for (i = 0; i < arraysize(regcon.cse.value); i++) + { if (regcon.cse.value[i] == e) /* if a register is holding it */ + { regcon.cse.mval &= ~mask[i]; + regcon.cse.mops &= ~mask[i]; /* free masks */ + } + } + for (i = 0; i < cstop; i++) + { if (csextab[i].e == e) + csextab[i].e = NULL; + } + } +} + +/********************************* + * Reset Ecomsub for all elem nodes, i.e. reverse the effects of freenode(). + */ + +STATIC void resetEcomsub(elem *e) +{ unsigned op; + + while (1) + { + elem_debug(e); + e->Ecomsub = e->Ecount; + op = e->Eoper; + if (!OTleaf(op)) + { if (OTbinary(op)) + resetEcomsub(e->E2); + e = e->E1; + } + else + break; + } +} + +/********************************* + * Determine if elem e is a register variable. + * If so: + * *pregm = mask of registers that make up the variable + * *preg = the least significant register + * returns TRUE + * Else + * returns FALSE + */ + +int isregvar(elem *e,regm_t *pregm,unsigned *preg) +{ symbol *s; + unsigned u; + regm_t m; + regm_t regm; + unsigned reg; + + elem_debug(e); + if (e->Eoper == OPvar || e->Eoper == OPrelconst) + { + s = e->EV.sp.Vsym; + switch (s->Sfl) + { case FLreg: + if (s->Sclass == SCparameter) + { refparam = TRUE; + reflocal = TRUE; + } + reg = s->Sreglsw; + regm = s->Sregm; + //assert(tyreg(s->ty())); +#if 0 + // Let's just see if there is a CSE in a reg we can use + // instead. This helps avoid AGI's. + if (e->Ecount && e->Ecount != e->Ecomsub) + { int i; + + for (i = 0; i < arraysize(regcon.cse.value); i++) + { + if (regcon.cse.value[i] == e) + { reg = i; + break; + } + } + } +#endif + assert(regm & regcon.mvar && !(regm & ~regcon.mvar)); + goto Lreg; + + case FLpseudo: +#if MARS + assert(0); +#else + u = s->Sreglsw; + m = pseudomask[u]; + if (m & ALLREGS && (u & ~3) != 4) // if not BP,SP,EBP,ESP,or ?H + { reg = pseudoreg[u] & 7; + regm = m; + goto Lreg; + } +#endif + break; + } + } + return FALSE; + +Lreg: + if (preg) + *preg = reg; + if (pregm) + *pregm = regm; + return TRUE; +} + +/********************************* + * Allocate some registers. + * Input: + * pretregs Pointer to mask of registers to make selection from. + * tym Mask of type we will store in registers. + * Output: + * *pretregs Mask of allocated registers. + * *preg Register number of first allocated register. + * msavereg,mfuncreg retregs bits are cleared. + * regcon.cse.mval,regcon.cse.mops updated + * Returns: + * pointer to code generated if necessary to save any regcon.cse.mops on the + * stack. + */ + +#undef allocreg + +code *allocreg(regm_t *pretregs,unsigned *preg,tym_t tym +#ifdef DEBUG + ,int line,const char *file +#endif + ) +#ifdef DEBUG +#define allocreg(a,b,c) allocreg((a),(b),(c),__LINE__,__FILE__) +#endif +{ regm_t r; + regm_t retregs; + unsigned reg; + unsigned msreg,lsreg; + int count; + unsigned size; + +#if 0 + if (pass == PASSfinal) + { dbg_printf("allocreg %s,%d: regcon.mvar %s regcon.cse.mval %s msavereg %s *pretregs %s tym ", + file,line,regm_str(regcon.mvar),regm_str(regcon.cse.mval), + regm_str(msavereg),regm_str(*pretregs)); + WRTYxx(tym); + dbg_printf("\n"); + } +#endif + tym = tybasic(tym); + size = tysize[tym]; + *pretregs &= mES | allregs | XMMREGS; + retregs = *pretregs; + if ((retregs & regcon.mvar) == retregs) // if exactly in reg vars + { + if (size <= REGSIZE || (retregs & XMMREGS)) + { *preg = findreg(retregs); + assert(retregs == mask[*preg]); /* no more bits are set */ + } + else if (size <= 2 * REGSIZE) + { *preg = findregmsw(retregs); + assert(retregs & mLSW); + } + else + assert(0); + return getregs(retregs); + } + count = 0; +L1: + //printf("L1: allregs = x%x, *pretregs = x%x\n", allregs, *pretregs); + assert(++count < 20); /* fail instead of hanging if blocked */ + assert(retregs); + msreg = lsreg = (unsigned)-1; /* no value assigned yet */ +L3: + //printf("L2: allregs = x%x, *pretregs = x%x\n", allregs, *pretregs); + r = retregs & ~(msavereg | regcon.cse.mval | regcon.params); + if (!r) + { + r = retregs & ~(msavereg | regcon.cse.mval); + if (!r) + { + r = retregs & ~(msavereg | regcon.cse.mops); + if (!r) + { r = retregs & ~msavereg; + if (!r) + r = retregs; + } + } + } + + if (size <= REGSIZE || retregs & XMMREGS) + { + if (r & ~mBP) + r &= ~mBP; + + // If only one index register, prefer to not use LSW registers + if (!regcon.indexregs && r & ~mLSW) + r &= ~mLSW; + + if (pass == PASSfinal && r & ~lastretregs && !I16) + { // Try not to always allocate the same register, + // to schedule better + + r &= ~lastretregs; + if (r & ~last2retregs) + { r &= ~last2retregs; + if (r & ~last3retregs) + { r &= ~last3retregs; + if (r & ~last4retregs) + { r &= ~last4retregs; +// if (r & ~last5retregs) +// r &= ~last5retregs; + } + } + } + if (r & ~mfuncreg) + r &= ~mfuncreg; + } + reg = findreg(r); + retregs = mask[reg]; + } + else if (size <= 2 * REGSIZE) + { + /* Select pair with both regs free. Failing */ + /* that, select pair with one reg free. */ + + if (r & mBP) + { retregs &= ~mBP; + goto L3; + } + + if (r & mMSW) + { + if (r & mDX) + msreg = DX; /* prefer to use DX over CX */ + else + msreg = findregmsw(r); + r &= mLSW; /* see if there's an LSW also */ + if (r) + lsreg = findreg(r); + else if (lsreg == -1) /* if don't have LSW yet */ + { retregs &= mLSW; + goto L3; + } + } + else + { + if (I64 && !(r & mLSW)) + { retregs = *pretregs & (mMSW | mLSW); + assert(retregs); + goto L1; + } + lsreg = findreglsw(r); + if (msreg == -1) + { retregs &= mMSW; + assert(retregs); + goto L3; + } + } + reg = (msreg == ES) ? lsreg : msreg; + retregs = mask[msreg] | mask[lsreg]; + } + else if (I16 && (tym == TYdouble || tym == TYdouble_alias)) + { +#ifdef DEBUG + if (retregs != DOUBLEREGS) + printf("retregs = x%x, *pretregs = x%x\n",retregs,*pretregs); +#endif + assert(retregs == DOUBLEREGS); + reg = AX; + } + else + { +#ifdef DEBUG + WRTYxx(tym); + printf("\nallocreg: fil %s lin %d, regcon.mvar x%x msavereg x%x *pretregs x%x, reg %d, tym x%x\n", + file,line,regcon.mvar,msavereg,*pretregs,*preg,tym); +#endif + assert(0); + } + if (retregs & regcon.mvar) // if conflict with reg vars + { + if (!(size > REGSIZE && *pretregs == (mAX | mDX))) + { + retregs = (*pretregs &= ~(retregs & regcon.mvar)); + goto L1; // try other registers + } + } + *preg = reg; + *pretregs = retregs; + + //printf("Allocating %s\n",regm_str(retregs)); + last5retregs = last4retregs; + last4retregs = last3retregs; + last3retregs = last2retregs; + last2retregs = lastretregs; + lastretregs = retregs; + return getregs(retregs); +} + +/************************* + * Mark registers as used. + */ + +void useregs(regm_t regm) +{ + //printf("useregs(x%x) %s\n", regm, regm_str(regm)); + mfuncreg &= ~regm; + regcon.used |= regm; // registers used in this block + regcon.params &= ~regm; + if (regm & regcon.mpvar) // if modified a fastpar register variable + regcon.params = 0; // toss them all out +} + +/************************* + * We are going to use the registers in mask r. + * Generate any code necessary to save any regs. + */ + +code *getregs(regm_t r) +{ regm_t ms; + + //printf("getregs(x%x)\n",r); + ms = r & regcon.cse.mops; // mask of common subs we must save + useregs(r); + regcon.cse.mval &= ~r; + msavereg &= ~r; // regs that are destroyed + regcon.immed.mval &= ~r; + return ms ? cse_save(ms) : NULL; +} + +/***************************************** + * Copy registers in cse.mops into memory. + */ + +STATIC code * cse_save(regm_t ms) +{ unsigned reg,i,op; + code *c = NULL; + regm_t regm; + + assert((ms & regcon.cse.mops) == ms); + regcon.cse.mops &= ~ms; + + /* Skip CSEs that are already saved */ + for (regm = 1; regm <= mES; regm <<= 1) + { + if (regm & ms) + { elem *e; + + e = regcon.cse.value[findreg(regm)]; + for (i = 0; i < csmax; i++) + { + if (csextab[i].e == e) + { + tym_t tym; + unsigned sz; + + tym = e->Ety; + sz = tysize(tym); + if (sz <= REGSIZE || + sz <= 2 * REGSIZE && + (regm & mMSW && csextab[i].regm & mMSW || + regm & mLSW && csextab[i].regm & mLSW) || + sz == 4 * REGSIZE && regm == csextab[i].regm + ) + { + ms &= ~regm; + if (!ms) + goto Lret; + break; + } + } + } + } + } + + for (i = cstop; ms; i++) + { + if (i >= csmax) /* array overflow */ + { unsigned cseinc; + +#ifdef DEBUG + cseinc = 8; /* flush out reallocation bugs */ +#else + cseinc = csmax + 32; +#endif + csextab = (struct CSE *) util_realloc(csextab, + (csmax + cseinc), sizeof(csextab[0])); + memset(&csextab[csmax],0,cseinc * sizeof(csextab[0])); + csmax += cseinc; + goto L1; + } + if (i >= cstop) + { + memset(&csextab[cstop],0,sizeof(csextab[0])); + goto L1; + } + if (csextab[i].e == NULL || i >= cstop) + { + L1: + reg = findreg(ms); /* the register to save */ + csextab[i].e = regcon.cse.value[reg]; + csextab[i].regm = mask[reg]; + csextab[i].flags &= CSEload; + if (i >= cstop) + cstop = i + 1; + + ms &= ~mask[reg]; /* turn off reg bit in ms */ + + // If we can simply reload the CSE, we don't need to save it + if (!cse_simple(csextab[i].e,i)) + { + c = cat(c, gensavereg(reg, i)); + reflocal = TRUE; + } + } + } +Lret: + return c; +} + +/****************************************** + * Getregs without marking immediate register values as gone. + */ + +code *getregs_imm(regm_t r) +{ code *c; + regm_t save; + + save = regcon.immed.mval; + c = getregs(r); + regcon.immed.mval = save; + return c; +} + +/****************************************** + * Flush all CSE's out of registers and into memory. + * Input: + * do87 !=0 means save 87 registers too + */ + +code *cse_flush(int do87) +{ code *c; + + //dbg_printf("cse_flush()\n"); + c = cse_save(regcon.cse.mops); // save any CSEs to memory + if (do87) + c = cat(c,save87()); // save any 8087 temporaries + return c; +} + +/************************************************* + */ + +STATIC int cse_simple(elem *e,int i) +{ regm_t regm; + unsigned reg; + code *c; + int sz; + + sz = tysize[tybasic(e->Ety)]; + if (!I16 && // don't bother with 16 bit code + e->Eoper == OPadd && + sz == REGSIZE && + e->E2->Eoper == OPconst && + e->E1->Eoper == OPvar && + isregvar(e->E1,®m,®) && + sz <= REGSIZE && + !(e->E1->EV.sp.Vsym->Sflags & SFLspill) + ) + { + c = &csextab[i].csimple; + memset(c,0,sizeof(*c)); + + // Make this an LEA instruction + c->Iop = 0x8D; // LEA + buildEA(c,reg,-1,1,e->E2->EV.Vuns); + if (I64) + { if (sz == 8) + c->Irex |= REX_W; + else if (sz == 1 && reg >= 4) + c->Irex |= REX; + } + + csextab[i].flags |= CSEsimple; + return 1; + } + else if (e->Eoper == OPind && + sz <= REGSIZE && + e->E1->Eoper == OPvar && + isregvar(e->E1,®m,®) && + (I32 || I64 || regm & IDXREGS) && + !(e->E1->EV.sp.Vsym->Sflags & SFLspill) + ) + { + c = &csextab[i].csimple; + memset(c,0,sizeof(*c)); + + // Make this a MOV instruction + c->Iop = (sz == 1) ? 0x8A : 0x8B; // MOV reg,EA + buildEA(c,reg,-1,1,0); + if (sz == 2 && I32) + c->Iflags |= CFopsize; + else if (I64) + { if (sz == 8) + c->Irex |= REX_W; + else if (sz == 1 && reg >= 4) + c->Irex |= REX; + } + + csextab[i].flags |= CSEsimple; + return 1; + } + return 0; +} + +/************************* + * Common subexpressions exist in registers. Note this in regcon.cse.mval. + * Input: + * e the subexpression + * regm mask of registers holding it + * opsflag if != 0 then regcon.cse.mops gets set too + */ + +void cssave(elem *e,regm_t regm,unsigned opsflag) +{ unsigned i; + + /*if (e->Ecount && e->Ecount == e->Ecomsub)*/ + if (e->Ecount && e->Ecomsub) + { + //printf("cssave(e = %p, regm = x%x, opsflag = %d)\n", e, regm, opsflag); + if (!opsflag && pass != PASSfinal && (I32 || I64)) + return; + + //printf("cssave(e = %p, regm = x%x, opsflag = x%x)\n", e, regm, opsflag); + regm &= mBP | ALLREGS | mES; /* just to be sure */ + +#if 0 + /* Do not register CSEs if they are register variables and */ + /* are not operator nodes. This forces the register allocation */ + /* to go through allocreg(), which will prevent using register */ + /* variables for scratch. */ + if (opsflag || !(regm & regcon.mvar)) +#endif + for (i = 0; regm; i++) + { regm_t mi; + + mi = mask[i]; + if (regm & mi) + { + regm &= ~mi; + + // If we don't need this CSE, and the register already + // holds a CSE that we do need, don't mark the new one + if (regcon.cse.mval & mi && regcon.cse.value[i] != e && + !opsflag && regcon.cse.mops & mi) + continue; + + regcon.cse.mval |= mi; + if (opsflag) + regcon.cse.mops |= mi; + //printf("cssave set: regcon.cse.value[%s] = %p\n",regstring[i],e); + regcon.cse.value[i] = e; + } + } + } +} + +/************************************* + * Determine if a computation should be done into a register. + */ + +bool evalinregister(elem *e) +{ regm_t emask; + unsigned i; + unsigned sz; + + if (e->Ecount == 0) /* elem is not a CSE, therefore */ + /* we don't need to evaluate it */ + /* in a register */ + return FALSE; + if (EOP(e)) /* operators are always in register */ + return TRUE; + + // Need to rethink this code if float or double can be CSE'd + sz = tysize(e->Ety); + if (e->Ecount == e->Ecomsub) /* elem is a CSE that needs */ + /* to be generated */ + { + if ((I32 || I64) && pass == PASSfinal && sz <= REGSIZE) + { + // Do it only if at least 2 registers are available + regm_t m; + + m = allregs & ~regcon.mvar; + if (sz == 1) + m &= BYTEREGS; + if (m & (m - 1)) // if more than one register + { // Need to be at least 3 registers available, as + // addressing modes can use up 2. + while (!(m & 1)) + m >>= 1; + m >>= 1; + if (m & (m - 1)) + return TRUE; + } + } + return FALSE; + } + + /* Elem is now a CSE that might have been generated. If so, and */ + /* it's in a register already, the computation should be done */ + /* using that register. */ + emask = 0; + for (i = 0; i < arraysize(regcon.cse.value); i++) + if (regcon.cse.value[i] == e) + emask |= mask[i]; + emask &= regcon.cse.mval; // mask of available CSEs + if (sz <= REGSIZE) + return emask != 0; /* the CSE is in a register */ + else if (sz <= 2 * REGSIZE) + return (emask & mMSW) && (emask & mLSW); + return TRUE; /* cop-out for now */ +} + +/******************************************************* + * Return mask of scratch registers. + */ + +regm_t getscratch() +{ regm_t scratch; + + scratch = 0; + if (pass == PASSfinal) + { + scratch = allregs & ~(regcon.mvar | regcon.mpvar | regcon.cse.mval | + regcon.immed.mval | regcon.params | mfuncreg); + } + return scratch; +} + +/****************************** + * Evaluate an elem that is a common subexp that has been encountered + * before. + * Look first to see if it is already in a register. + */ + +STATIC code * comsub(elem *e,regm_t *pretregs) +{ tym_t tym; + regm_t regm,emask,csemask; + unsigned reg,i,byte,sz; + code *c; + + //printf("comsub(e = %p, *pretregs = %s)\n",e,regm_str(*pretregs)); + elem_debug(e); +#ifdef DEBUG + if (e->Ecomsub > e->Ecount) + elem_print(e); +#endif + assert(e->Ecomsub <= e->Ecount); + + c = CNIL; + if (*pretregs == 0) goto done; /* no possible side effects anyway */ + + if (tyfloating(e->Ety) && config.inline8087) + return comsub87(e,pretregs); + + /* First construct a mask, emask, of all the registers that */ + /* have the right contents. */ + + emask = 0; + for (i = 0; i < arraysize(regcon.cse.value); i++) + { + //dbg_printf("regcon.cse.value[%d] = %p\n",i,regcon.cse.value[i]); + if (regcon.cse.value[i] == e) /* if contents are right */ + emask |= mask[i]; /* turn on bit for reg */ + } + emask &= regcon.cse.mval; /* make sure all bits are valid */ + + /* create mask of what's in csextab[] */ + csemask = 0; + for (i = 0; i < cstop; i++) + { if (csextab[i].e) + elem_debug(csextab[i].e); + if (csextab[i].e == e) + csemask |= csextab[i].regm; + } + csemask &= ~emask; /* stuff already in registers */ + +#ifdef DEBUG +if (debugw) +{ +printf("comsub(e=%p): *pretregs=%x, emask=%x, csemask=%x, regcon.cse.mval=%x, regcon.mvar=%x\n", + e,*pretregs,emask,csemask,regcon.cse.mval,regcon.mvar); +if (regcon.cse.mval & 1) elem_print(regcon.cse.value[i]); +} +#endif + + tym = tybasic(e->Ety); + sz = tysize[tym]; + byte = sz == 1; + + if (sz <= REGSIZE) // if data will fit in one register + { + /* First see if it is already in a correct register */ + + regm = emask & *pretregs; + if (regm == 0) + regm = emask; /* try any other register */ + if (regm) /* if it's in a register */ + { + if (EOP(e) || !(regm & regcon.mvar) || (*pretregs & regcon.mvar) == *pretregs) + { + regm = mask[findreg(regm)]; + goto fix; + } + } + + if (!EOP(e)) /* if not op or func */ + goto reload; /* reload data */ + for (i = cstop; i--;) /* look through saved comsubs */ + if (csextab[i].e == e) /* found it */ + { regm_t retregs; + + if (csextab[i].flags & CSEsimple) + { code *cr; + + retregs = *pretregs; + if (byte && !(retregs & BYTEREGS)) + retregs = BYTEREGS; + else if (!(retregs & allregs)) + retregs = allregs; + c = allocreg(&retregs,®,tym); + cr = &csextab[i].csimple; + cr->setReg(reg); + c = gen(c,cr); + goto L10; + } + else + { + reflocal = TRUE; + csextab[i].flags |= CSEload; + if (*pretregs == mPSW) /* if result in CCs only */ + { // CMP cs[BP],0 + c = genc(NULL,0x81 ^ byte,modregrm(2,7,BPRM), + FLcs,i, FLconst,(targ_uns) 0); + if (I32 && sz == 2) + c->Iflags |= CFopsize; + } + else + { + retregs = *pretregs; + if (byte && !(retregs & BYTEREGS)) + retregs = BYTEREGS; + c = allocreg(&retregs,®,tym); + // MOV reg,cs[BP] + c = genc1(c,0x8B,modregxrm(2,reg,BPRM),FLcs,(targ_uns) i); + if (I64) + code_orrex(c, REX_W); + L10: + regcon.cse.mval |= mask[reg]; // cs is in a reg + regcon.cse.value[reg] = e; + c = cat(c,fixresult(e,retregs,pretregs)); + } + } + freenode(e); + return c; + } +#ifdef DEBUG + printf("couldn't find cse e = %p, pass = %d\n",e,pass); + elem_print(e); +#endif + assert(0); /* should have found it */ + } + else /* reg pair is req'd */ + if (sz <= 2 * REGSIZE) + { unsigned msreg,lsreg; + + /* see if we have both */ + if (!((emask | csemask) & mMSW && (emask | csemask) & (mLSW | mBP))) + { /* we don't have both */ +#if DEBUG + if (EOP(e)) + { + printf("e = %p, op = x%x, emask = x%x, csemask = x%x\n", + e,e->Eoper,emask,csemask); + //printf("mMSW = x%x, mLSW = x%x\n", mMSW, mLSW); + elem_print(e); + } +#endif + assert(!EOP(e)); /* must have both for operators */ + goto reload; + } + + /* Look for right vals in any regs */ + + regm = *pretregs & mMSW; + if (emask & regm) + msreg = findreg(emask & regm); + else if (emask & mMSW) + msreg = findregmsw(emask); + else /* reload from cse array */ + { + if (!regm) + regm = mMSW & ALLREGS; + c = allocreg(®m,&msreg,TYint); + c = cat(c,loadcse(e,msreg,mMSW)); + } + + regm = *pretregs & (mLSW | mBP); + if (emask & regm) + lsreg = findreg(emask & regm); + else if (emask & (mLSW | mBP)) + lsreg = findreglsw(emask); + else + { + if (!regm) + regm = mLSW; + c = cat(c,allocreg(®m,&lsreg,TYint)); + c = cat(c,loadcse(e,lsreg,mLSW | mBP)); + } + + regm = mask[msreg] | mask[lsreg]; /* mask of result */ + goto fix; + } + else if (tym == TYdouble || tym == TYdouble_alias) // double + { + assert(I16); + if (((csemask | emask) & DOUBLEREGS_16) == DOUBLEREGS_16) + { + for (reg = AX; reg != -1; reg = dblreg[reg]) + { assert((int) reg >= 0 && reg <= 7); + if (mask[reg] & csemask) + c = cat(c,loadcse(e,reg,mask[reg])); + } + regm = DOUBLEREGS_16; + goto fix; + } + if (!EOP(e)) goto reload; +#if DEBUG + printf("e = %p, csemask = x%x, emask = x%x\n",e,csemask,emask); +#endif + assert(0); + } + else + { +#if DEBUG + printf("e = %p, tym = x%x\n",e,tym); +#endif + assert(0); + } + +reload: /* reload result from memory */ + switch (e->Eoper) + { + case OPrelconst: + c = cdrelconst(e,pretregs); + break; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case OPgot: + c = cdgot(e,pretregs); + break; +#endif + default: + c = loaddata(e,pretregs); + break; + } + cssave(e,*pretregs,FALSE); + freenode(e); + return c; + +fix: /* we got result in regm, fix */ + c = cat(c,fixresult(e,regm,pretregs)); +done: + freenode(e); + return c; +} + + +/***************************** + * Load reg from cse stack. + * Returns: + * pointer to the MOV instruction + */ + +STATIC code * loadcse(elem *e,unsigned reg,regm_t regm) +{ unsigned i,op; + code *c; + + for (i = cstop; i--;) + { + //printf("csextab[%d] = %p, regm = x%x\n", i, csextab[i].e, csextab[i].regm); + if (csextab[i].e == e && csextab[i].regm & regm) + { + reflocal = TRUE; + csextab[i].flags |= CSEload; /* it was loaded */ + c = getregs(mask[reg]); + regcon.cse.value[reg] = e; + regcon.cse.mval |= mask[reg]; + op = 0x8B; + if (reg == ES) + { op = 0x8E; + reg = 0; + } + c = genc1(c,op,modregxrm(2,reg,BPRM),FLcs,(targ_uns) i); + if (I64) + code_orrex(c, REX_W); + return c; + } + } +#if DEBUG + printf("loadcse(e = %p, reg = %d, regm = x%x)\n",e,reg,regm); +elem_print(e); +#endif + assert(0); + /* NOTREACHED */ + return 0; +} + +/*************************** + * Generate code sequence for an elem. + * Input: + * pretregs mask of possible registers to return result in + * Note: longs are in AX,BX or CX,DX or SI,DI + * doubles are AX,BX,CX,DX only + * constflag TRUE if user of result will not modify the + * registers returned in *pretregs. + * Output: + * *pretregs mask of registers result is returned in + * Returns: + * pointer to code sequence generated + */ + +#include "cdxxx.c" /* jump table */ + +code *codelem(elem *e,regm_t *pretregs,bool constflag) +{ code *c; + Symbol *s; + unsigned op; + +#ifdef DEBUG + if (debugw) + { printf("+codelem(e=%p,*pretregs=%s) ",e,regm_str(*pretregs)); + WROP(e->Eoper); + printf("msavereg=x%x regcon.cse.mval=x%x regcon.cse.mops=x%x\n", + msavereg,regcon.cse.mval,regcon.cse.mops); + printf("Ecount = %d, Ecomsub = %d\n", e->Ecount, e->Ecomsub); + } +#endif + assert(e); + elem_debug(e); + if ((regcon.cse.mops & regcon.cse.mval) != regcon.cse.mops) + { +#ifdef DEBUG + printf("+codelem(e=%p,*pretregs=x%x) ",e,*pretregs); + elem_print(e); + printf("msavereg=x%x regcon.cse.mval=x%x regcon.cse.mops=x%x\n", + msavereg,regcon.cse.mval,regcon.cse.mops); + printf("Ecount = %d, Ecomsub = %d\n", e->Ecount, e->Ecomsub); +#endif + assert(0); + } + + if (!constflag && *pretregs & (mES | ALLREGS | mBP | XMMREGS) & ~regcon.mvar) + *pretregs &= ~regcon.mvar; /* can't use register vars */ + op = e->Eoper; + if (e->Ecount && e->Ecount != e->Ecomsub) /* if common subexp */ + { c = comsub(e,pretregs); + goto L1; + } + + switch (op) + { + default: + if (e->Ecount) /* if common subexp */ + { + /* if no return value */ + if ((*pretregs & (mSTACK | mES | ALLREGS | mBP)) == 0) + { if (tysize(e->Ety) == 1) + *pretregs |= BYTEREGS; + else if (tybasic(e->Ety) == TYdouble || tybasic(e->Ety) == TYdouble_alias) + *pretregs |= DOUBLEREGS; + else + *pretregs |= ALLREGS; /* make one */ + } + + /* BUG: For CSEs, make sure we have both an MSW */ + /* and an LSW specified in *pretregs */ + } + assert(op <= OPMAX); + c = (*cdxxx[op])(e,pretregs); + break; + case OPrelconst: + c = cdrelconst(e,pretregs); + break; + case OPvar: + if (constflag && (s = e->EV.sp.Vsym)->Sfl == FLreg && + (s->Sregm & *pretregs) == s->Sregm) + { + if (tysize(e->Ety) <= REGSIZE && tysize(s->Stype->Tty) == 2 * REGSIZE) + *pretregs &= mPSW | (s->Sregm & mLSW); + else + *pretregs &= mPSW | s->Sregm; + } + case OPconst: + if (*pretregs == 0 && (e->Ecount >= 3 || e->Ety & mTYvolatile)) + { + switch (tybasic(e->Ety)) + { + case TYbool: + case TYchar: + case TYschar: + case TYuchar: + *pretregs |= BYTEREGS; + break; +#if JHANDLE + case TYjhandle: +#endif + case TYnptr: +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + *pretregs |= IDXREGS; + break; + case TYshort: + case TYushort: + case TYint: + case TYuint: + case TYlong: + case TYulong: + case TYllong: + case TYullong: + case TYcent: + case TYucent: +#if TARGET_SEGMENTED + case TYfptr: + case TYhptr: + case TYvptr: +#endif + *pretregs |= ALLREGS; + break; + } + } + c = loaddata(e,pretregs); + break; + } + cssave(e,*pretregs,!OTleaf(op)); + freenode(e); +L1: +#ifdef DEBUG + if (debugw) + { printf("-codelem(e=%p,*pretregs=x%x) ",e,*pretregs); + WROP(op); + printf("msavereg=x%x regcon.cse.mval=x%x regcon.cse.mops=x%x\n", + msavereg,regcon.cse.mval,regcon.cse.mops); + } +#endif + if (configv.addlinenumbers && e->Esrcpos.Slinnum) + cgen_prelinnum(&c,e->Esrcpos); + return c; +} + +/******************************* + * Same as codelem(), but do not destroy the registers in keepmsk. + * Use scratch registers as much as possible, then use stack. + * Input: + * constflag TRUE if user of result will not modify the + * registers returned in *pretregs. + */ + +code *scodelem(elem *e,regm_t *pretregs,regm_t keepmsk,bool constflag) +{ code *c,*cs1,*cs2,*cs3; + unsigned i,j; + regm_t oldmfuncreg,oldregcon,oldregimmed,overlap,tosave,touse; + int adjesp; + unsigned stackpushsave; + char calledafuncsave; + +#ifdef DEBUG + if (debugw) + printf("+scodelem(e=%p *pretregs=%s keepmsk=%s constflag=%d\n", + e,regm_str(*pretregs),regm_str(keepmsk),constflag); +#endif + elem_debug(e); + if (constflag) + { regm_t regm; + unsigned reg; + + if (isregvar(e,®m,®) && // if e is a register variable + (regm & *pretregs) == regm && // in one of the right regs + e->EV.sp.Voffset == 0 + ) + { + unsigned sz1 = tysize(e->Ety); + unsigned sz2 = tysize(e->EV.sp.Vsym->Stype->Tty); + if (sz1 <= REGSIZE && sz2 > REGSIZE) + regm &= mLSW | XMMREGS; + c = fixresult(e,regm,pretregs); + cssave(e,regm,0); + freenode(e); +#ifdef DEBUG + if (debugw) + printf("-scodelem(e=%p *pretregs=x%x keepmsk=x%x constflag=%d\n", + e,*pretregs,keepmsk,constflag); +#endif + return c; + } + } + overlap = msavereg & keepmsk; + msavereg |= keepmsk; /* add to mask of regs to save */ + oldregcon = regcon.cse.mval; + oldregimmed = regcon.immed.mval; + oldmfuncreg = mfuncreg; /* remember old one */ + mfuncreg = (mBP | mES | ALLREGS) & ~regcon.mvar; + stackpushsave = stackpush; + calledafuncsave = calledafunc; + calledafunc = 0; + c = codelem(e,pretregs,constflag); /* generate code for the elem */ + + tosave = keepmsk & ~msavereg; /* registers to save */ + if (tosave) + { cgstate.stackclean++; + c = genstackclean(c,stackpush - stackpushsave,*pretregs | msavereg); + cgstate.stackclean--; + } + + /* Assert that no new CSEs are generated that are not reflected */ + /* in mfuncreg. */ +#ifdef DEBUG + if ((mfuncreg & (regcon.cse.mval & ~oldregcon)) != 0) + printf("mfuncreg x%x, regcon.cse.mval x%x, oldregcon x%x, regcon.mvar x%x\n", + mfuncreg,regcon.cse.mval,oldregcon,regcon.mvar); +#endif + assert((mfuncreg & (regcon.cse.mval & ~oldregcon)) == 0); + + /* bugzilla 3521 + * The problem is: + * reg op (reg = exp) + * where reg must be preserved (in keepregs) while the expression to be evaluated + * must change it. + * The only solution is to make this variable not a register. + */ + if (regcon.mvar & tosave) + { + //elem_print(e); + //printf("test1: regcon.mvar x%x tosave x%x\n", regcon.mvar, tosave); + cgreg_unregister(regcon.mvar & tosave); + } + + /* which registers can we use to save other registers in? */ + if (config.flags4 & CFG4space || // if optimize for space + config.target_cpu >= TARGET_80486) // PUSH/POP ops are 1 cycle + touse = 0; // PUSH/POP pairs are always shorter + else + { touse = mfuncreg & allregs & ~(msavereg | oldregcon | regcon.cse.mval); + /* Don't use registers we'll have to save/restore */ + touse &= ~(fregsaved & oldmfuncreg); + /* Don't use registers that have constant values in them, since + the code generated might have used the value. + */ + touse &= ~oldregimmed; + } + + cs1 = cs2 = cs3 = NULL; + adjesp = 0; + + for (i = 0; tosave; i++) + { regm_t mi = mask[i]; + + assert(i < REGMAX); + if (mi & tosave) /* i = register to save */ + { + if (touse) /* if any scratch registers */ + { for (j = 0; j < 8; j++) + { regm_t mj = mask[j]; + + if (touse & mj) + { cs1 = genmovreg(cs1,j,i); + cs2 = cat(genmovreg(CNIL,i,j),cs2); + touse &= ~mj; + mfuncreg &= ~mj; + regcon.used |= mj; + break; + } + } + assert(j < 8); + } + else /* else use stack */ + { + stackchanged = 1; + adjesp += REGSIZE; + gensaverestore2(mask[i], &cs1, &cs2); + } + cs3 = cat(getregs(mi),cs3); + tosave &= ~mi; + } + } + if (adjesp) + { + // If this is done an odd number of times, it + // will throw off the 8 byte stack alignment. + // We should *only* worry about this if a function + // was called in the code generation by codelem(). + int sz; + if (STACKALIGN == 16) + sz = -(adjesp & (STACKALIGN - 1)) & (STACKALIGN - 1); + else + sz = -(adjesp & 7) & 7; + if (calledafunc && !I16 && sz && (STACKALIGN == 16 || config.flags4 & CFG4stackalign)) + { + unsigned grex = I64 ? REX_W << 16 : 0; + regm_t mval_save = regcon.immed.mval; + regcon.immed.mval = 0; // prevent reghasvalue() optimizations + // because c hasn't been executed yet + cs1 = genc2(cs1,0x81,grex | modregrm(3,5,SP),sz); // SUB ESP,sz + if (I64) + code_orrex(cs1, REX_W); + regcon.immed.mval = mval_save; + cs1 = genadjesp(cs1, sz); + + code *cx = genc2(CNIL,0x81,grex | modregrm(3,0,SP),sz); // ADD ESP,sz + if (I64) + code_orrex(cx, REX_W); + cx = genadjesp(cx, -sz); + cs2 = cat(cx, cs2); + } + + cs1 = genadjesp(cs1,adjesp); + cs2 = genadjesp(cs2,-adjesp); + } + + calledafunc |= calledafuncsave; + msavereg &= ~keepmsk | overlap; /* remove from mask of regs to save */ + mfuncreg &= oldmfuncreg; /* update original */ +#ifdef DEBUG + if (debugw) + printf("-scodelem(e=%p *pretregs=x%x keepmsk=x%x constflag=%d\n", + e,*pretregs,keepmsk,constflag); +#endif + return cat4(cs1,c,cs3,cs2); +} + +/********************************************* + * Turn register mask into a string suitable for printing. + */ + +#ifdef DEBUG + +const char *regm_str(regm_t rm) +{ + #define NUM 4 + #define SMAX 128 + static char str[NUM][SMAX + 1]; + static int i; + + if (rm == 0) + return "0"; + if (rm == ALLREGS) + return "ALLREGS"; + if (rm == BYTEREGS) + return "BYTEREGS"; + if (rm == allregs) + return "allregs"; + if (rm == XMMREGS) + return "XMMREGS"; + char *p = str[i]; + if (++i == NUM) + i = 0; + *p = 0; + for (size_t j = 0; j < 32; j++) + { + if (mask[j] & rm) + { + strcat(p,regstring[j]); + rm &= ~mask[j]; + if (rm) + strcat(p,"|"); + } + } + if (rm) + { char *s = p + strlen(p); + sprintf(s,"x%02x",rm); + } + assert(strlen(p) <= SMAX); + return strdup(p); +} + +#endif + +/********************************* + * Scan down comma-expressions. + * Output: + * *pe = first elem down right side that is not an OPcomma + * Returns: + * code generated for left branches of comma-expressions + */ + +code *docommas(elem **pe) +{ elem *e; + code *cc; + unsigned stackpushsave; + int stackcleansave; + + stackpushsave = stackpush; + stackcleansave = cgstate.stackclean; + cgstate.stackclean = 0; + cc = CNIL; + e = *pe; + while (1) + { elem *eold; + regm_t retregs; + + if (configv.addlinenumbers && e->Esrcpos.Slinnum) + { cc = genlinnum(cc,e->Esrcpos); + //e->Esrcpos.Slinnum = 0; // don't do it twice + } + if (e->Eoper != OPcomma) + break; + retregs = 0; + cc = cat(cc,codelem(e->E1,&retregs,TRUE)); + eold = e; + e = e->E2; + freenode(eold); + } + *pe = e; + assert(cgstate.stackclean == 0); + cgstate.stackclean = stackcleansave; + cc = genstackclean(cc,stackpush - stackpushsave,0); + return cc; +} + +/************************** + * For elems in regcon that don't match regconsave, + * clear the corresponding bit in regcon.cse.mval. + * Do same for regcon.immed. + */ + +void andregcon(con_t *pregconsave) +{ + regm_t m = ~1; + for (int i = 0; i < REGMAX; i++) + { if (pregconsave->cse.value[i] != regcon.cse.value[i]) + regcon.cse.mval &= m; + if (pregconsave->immed.value[i] != regcon.immed.value[i]) + regcon.immed.mval &= m; + m <<= 1; + m |= 1; + } + //printf("regcon.cse.mval = x%x, regconsave->mval = x%x ",regcon.cse.mval,pregconsave->cse.mval); + regcon.used |= pregconsave->used; + regcon.cse.mval &= pregconsave->cse.mval; + regcon.immed.mval &= pregconsave->immed.mval; + regcon.params &= pregconsave->params; + //printf("regcon.cse.mval®con.cse.mops = x%x, regcon.cse.mops = x%x\n",regcon.cse.mval & regcon.cse.mops,regcon.cse.mops); + regcon.cse.mops &= regcon.cse.mval; +} + +#endif // !SPP diff --git a/backend/cgcs.c b/backend/cgcs.c new file mode 100644 index 00000000..9b981f04 --- /dev/null +++ b/backend/cgcs.c @@ -0,0 +1,683 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2012 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include + +#include "cc.h" +#include "oper.h" +#include "global.h" +#include "code.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/********************************* + * Struct for each elem: + * Helem pointer to elem + * Hhash hash value for the elem + */ + +typedef struct HCS + { elem *Helem; + unsigned Hhash; + } hcs; + +static hcs *hcstab = NULL; /* array of hcs's */ +static unsigned hcsmax = 0; /* max index into hcstab[] */ +static unsigned hcstop; /* # of entries in hcstab[] */ +static unsigned touchstari; +static unsigned touchfunci[2]; + +// Use a bit vector for quick check if expression is possibly in hcstab[]. +// This results in much faster compiles when hcstab[] gets big. +static vec_t csvec; // vector of used entries +#define CSVECDIM 16001 //8009 //3001 // dimension of csvec (should be prime) + +STATIC void ecom(elem **); +STATIC unsigned cs_comphash(elem *); +STATIC void addhcstab(elem *,int); +STATIC void touchlvalue(elem *); +STATIC void touchfunc(int); +STATIC void touchstar(void); +STATIC void touchaccess(elem *); + +/******************************* + * Eliminate common subexpressions across extended basic blocks. + * String together as many blocks as we can. + */ + +void comsubs() +{ register block *bl,*blc,*bln; + register int n; /* # of blocks to treat as one */ + +//static int xx; +//printf("comsubs() %d\n", ++xx); +//debugx = (xx == 37); + +#ifdef DEBUG + if (debugx) dbg_printf("comsubs(%p)\n",startblock); +#endif + + // No longer do we just compute Bcount. We now eliminate unreachable + // blocks. + block_compbcount(); // eliminate unreachable blocks +#if SCPP + if (errcnt) + return; +#endif + + if (!csvec) + { + csvec = vec_calloc(CSVECDIM); + } + + for (bl = startblock; bl; bl = bln) + { + bln = bl->Bnext; + if (!bl->Belem) + continue; /* if no expression or no parents */ + + // Count up n, the number of blocks in this extended basic block (EBB) + n = 1; // always at least one block in EBB + blc = bl; + while (bln && list_nitems(bln->Bpred) == 1 && + ((blc->BC == BCiftrue && + list_block(list_next(blc->Bsucc)) == bln) || + (blc->BC == BCgoto && list_block(blc->Bsucc) == bln) + ) && + bln->BC != BCasm // no CSE's extending across ASM blocks + ) + { + n++; // add block to EBB + blc = bln; + bln = blc->Bnext; + } + vec_clear(csvec); + hcstop = 0; + touchstari = 0; + touchfunci[0] = 0; + touchfunci[1] = 0; + bln = bl; + while (n--) // while more blocks in EBB + { +#ifdef DEBUG + if (debugx) + dbg_printf("cses for block %p\n",bln); +#endif + if (bln->Belem) + ecom(&bln->Belem); // do the tree + bln = bln->Bnext; + } + } + +#ifdef DEBUG + if (debugx) + dbg_printf("done with comsubs()\n"); +#endif +} + +/******************************* + */ + +void cgcs_term() +{ + vec_free(csvec); + csvec = NULL; +#ifdef DEBUG + debugw && dbg_printf("freeing hcstab\n"); +#endif +#if TX86 + util_free(hcstab); +#else + MEM_PARF_FREE(hcstab); +#endif + hcstab = NULL; + hcsmax = 0; +} + +/************************* + * Eliminate common subexpressions for an element. + */ + +STATIC void ecom(elem **pe) +{ int i,op,hcstopsave; + unsigned hash; + elem *e,*ehash; + tym_t tym; + + e = *pe; + assert(e); + elem_debug(e); +#ifdef DEBUG + assert(e->Ecount == 0); + //assert(e->Ecomsub == 0); +#endif + tym = tybasic(e->Ety); + op = e->Eoper; + switch (op) + { + case OPconst: + case OPvar: + case OPrelconst: + break; + case OPstreq: + case OPpostinc: + case OPpostdec: + case OPeq: + case OPaddass: + case OPminass: + case OPmulass: + case OPdivass: + case OPmodass: + case OPshrass: + case OPashrass: + case OPshlass: + case OPandass: + case OPxorass: + case OPorass: +#if TX86 + /* Reverse order of evaluation for double op=. This is so that */ + /* the pushing of the address of the second operand is easier. */ + /* However, with the 8087 we don't need the kludge. */ + if (op != OPeq && tym == TYdouble && !config.inline8087) + { if (EOP(e->E1)) + ecom(&e->E1->E1); + ecom(&e->E2); + } + else +#endif + { + /* Don't mark the increment of an i++ or i-- as a CSE, if it */ + /* can be done with an INC or DEC instruction. */ + if (!(OTpost(op) && elemisone(e->E2))) + ecom(&e->E2); /* evaluate 2nd operand first */ + case OPnegass: + if (EOP(e->E1)) /* if lvalue is an operator */ + { +#ifdef DEBUG + if (e->E1->Eoper != OPind) + elem_print(e); +#endif + assert(e->E1->Eoper == OPind); + ecom(&(e->E1->E1)); + } + } + touchlvalue(e->E1); + if (!OTpost(op)) /* lvalue of i++ or i-- is not a cse*/ + { + hash = cs_comphash(e->E1); + vec_setbit(hash % CSVECDIM,csvec); + addhcstab(e->E1,hash); // add lvalue to hcstab[] + } + return; + + case OPbtc: + case OPbts: + case OPbtr: + ecom(&e->E1); + ecom(&e->E2); + touchfunc(0); // indirect assignment + return; + + case OPandand: + case OPoror: + ecom(&e->E1); + hcstopsave = hcstop; + ecom(&e->E2); + hcstop = hcstopsave; /* no common subs by E2 */ + return; /* if comsub then logexp() will */ + /* break */ + case OPcond: + ecom(&e->E1); + hcstopsave = hcstop; + ecom(&e->E2->E1); /* left condition */ + hcstop = hcstopsave; /* no common subs by E2 */ + ecom(&e->E2->E2); /* right condition */ + hcstop = hcstopsave; /* no common subs by E2 */ + return; /* can't be a common sub */ + case OPcall: + case OPcallns: + ecom(&e->E2); /* eval right first */ + /* FALL-THROUGH */ + case OPucall: + case OPucallns: + ecom(&e->E1); + touchfunc(1); + return; + case OPstrpar: /* so we don't break logexp() */ +#if TX86 + case OPinp: /* never CSE the I/O instruction itself */ +#endif + ecom(&e->E1); + /* FALL-THROUGH */ + case OPasm: + case OPstrthis: // don't CSE these + case OPframeptr: + case OPgot: + case OPctor: + case OPdtor: + case OPdctor: + case OPmark: + return; + + case OPddtor: + return; + + case OPparam: +#if TX86 + case OPoutp: +#endif + ecom(&e->E1); + case OPinfo: + ecom(&e->E2); + return; + case OPcomma: + case OPremquo: + ecom(&e->E1); + ecom(&e->E2); + break; +#if TARGET_SEGMENTED + case OPvp_fp: + case OPcvp_fp: + ecom(&e->E1); + touchaccess(e); + break; +#endif + case OPind: + ecom(&e->E1); + /* Generally, CSEing a *(double *) results in worse code */ + if (tyfloating(tym)) + return; + break; +#if TX86 + case OPstrcpy: + case OPstrcat: + case OPmemcpy: + case OPmemset: + ecom(&e->E2); + case OPsetjmp: + ecom(&e->E1); + touchfunc(0); + return; +#endif + default: /* other operators */ +#if TX86 +#ifdef DEBUG + if (!EBIN(e)) WROP(e->Eoper); +#endif + assert(EBIN(e)); + case OPadd: + case OPmin: + case OPmul: + case OPdiv: + case OPor: + case OPxor: + case OPand: + case OPeqeq: + case OPne: + case OPscale: + case OPyl2x: + case OPyl2xp1: + ecom(&e->E1); + ecom(&e->E2); + break; +#else +#ifdef DEBUG + if (!EOP(e)) WROP(e->Eoper); +#endif + assert(EOP(e)); + ecom(&e->E1); + if (EBIN(e)) + ecom(&e->E2); /* eval left first */ + break; +#endif + case OPstring: + case OPaddr: + case OPbit: +#ifdef DEBUG + WROP(e->Eoper); + elem_print(e); +#endif + assert(0); /* optelem() should have removed these */ + /* NOTREACHED */ + + // Explicitly list all the unary ops for speed + case OPnot: case OPcom: case OPneg: case OPuadd: + case OPabs: case OPsqrt: case OPrndtol: case OPsin: case OPcos: case OPrint: + case OPpreinc: case OPpredec: + case OPbool: case OPstrlen: case OPs16_32: case OPu16_32: + case OPd_s32: case OPd_u32: + case OPs32_d: case OPu32_d: case OPd_s16: case OPs16_d: case OP32_16: + case OPd_f: case OPf_d: + case OPd_ld: case OPld_d: + case OPc_r: case OPc_i: + case OPu8_16: case OPs8_16: case OP16_8: + case OPu32_64: case OPs32_64: case OP64_32: case OPmsw: + case OPu64_128: case OPs64_128: case OP128_64: + case OPd_s64: case OPs64_d: case OPd_u64: case OPu64_d: + case OPstrctor: case OPu16_d: case OPd_u16: + case OParrow: + case OPvoid: case OPnullcheck: + case OPbsf: case OPbsr: case OPbswap: case OPvector: + case OPld_u64: +#if TARGET_SEGMENTED + case OPoffset: case OPnp_fp: case OPnp_f16p: case OPf16p_np: +#endif + ecom(&e->E1); + break; + case OPhalt: + return; + } + + /* don't CSE structures or unions or volatile stuff */ + if (tym == TYstruct || + tym == TYvoid || + e->Ety & mTYvolatile +#if TX86 + || tyxmmreg(tym) + // don't CSE doubles if inline 8087 code (code generator can't handle it) + || (tyfloating(tym) && config.inline8087) +#endif + ) + return; + + hash = cs_comphash(e); /* must be AFTER leaves are done */ + + /* Search for a match in hcstab[]. + * Search backwards, as most likely matches will be towards the end + * of the list. + */ + +#ifdef DEBUG + if (debugx) dbg_printf("elem: %p hash: %6d\n",e,hash); +#endif + int csveci = hash % CSVECDIM; + if (vec_testbit(csveci,csvec)) + { + for (i = hcstop; i--;) + { +#ifdef DEBUG + if (debugx) + dbg_printf("i: %2d Hhash: %6d Helem: %p\n", + i,hcstab[i].Hhash,hcstab[i].Helem); +#endif + if (hash == hcstab[i].Hhash && (ehash = hcstab[i].Helem) != NULL) + { + /* if elems are the same and we still have room for more */ + if (el_match(e,ehash) && ehash->Ecount < 0xFF) + { + /* Make sure leaves are also common subexpressions + * to avoid false matches. + */ + if (!OTleaf(op)) + { + if (!e->E1->Ecount) + continue; + if (OTbinary(op) && !e->E2->Ecount) + continue; + } + ehash->Ecount++; + *pe = ehash; +#ifdef DEBUG + if (debugx) + dbg_printf("**MATCH** %p with %p\n",e,*pe); +#endif + el_free(e); + return; + } + } + } + } + else + vec_setbit(csveci,csvec); + addhcstab(e,hash); // add this elem to hcstab[] +} + +/************************** + * Compute hash function for elem e. + */ + +STATIC unsigned cs_comphash(elem *e) +{ register int hash; + unsigned op; + + elem_debug(e); + op = e->Eoper; +#if TX86 + hash = (e->Ety & (mTYbasic | mTYconst | mTYvolatile)) + (op << 8); +#else + hash = e->Ety + op; +#endif + if (!OTleaf(op)) + { hash += (size_t) e->E1; + if (OTbinary(op)) + hash += (size_t) e->E2; + } + else + { hash += e->EV.Vint; + if (op == OPvar || op == OPrelconst) + hash += (size_t) e->EV.sp.Vsym; + } + return hash; +} + +/**************************** + * Add an elem to the common subexpression table. + * Recompute hash if it is 0. + */ + +STATIC void addhcstab(elem *e,int hash) +{ unsigned h = hcstop; + + if (h >= hcsmax) /* need to reallocate table */ + { + assert(h == hcsmax); + // With 32 bit compiles, we've got memory to burn + hcsmax += (__INTSIZE == 4) ? (hcsmax + 128) : 100; + assert(h < hcsmax); +#if TX86 + hcstab = (hcs *) util_realloc(hcstab,hcsmax,sizeof(hcs)); +#else + hcstab = (hcs *) MEM_PARF_REALLOC(hcstab,hcsmax*sizeof(hcs)); +#endif + //printf("hcstab = %p; hcstop = %d, hcsmax = %d\n",hcstab,hcstop,hcsmax); + } + hcstab[h].Helem = e; + hcstab[h].Hhash = hash; + hcstop++; +} + +/*************************** + * "touch" the elem. + * If it is a pointer, "touch" all the suspects + * who could be pointed to. + * Eliminate common subs that are indirect loads. + */ + +STATIC void touchlvalue(elem *e) +{ register int i; + + if (e->Eoper == OPind) /* if indirect store */ + { + /* NOTE: Some types of array assignments do not need + * to touch all variables. (Like a[5], where a is an + * array instead of a pointer.) + */ + + touchfunc(0); + return; + } + + for (i = hcstop; --i >= 0;) + { if (hcstab[i].Helem && + hcstab[i].Helem->EV.sp.Vsym == e->EV.sp.Vsym) + hcstab[i].Helem = NULL; + } + + assert(e->Eoper == OPvar || e->Eoper == OPrelconst); + switch (e->EV.sp.Vsym->Sclass) + { + case SCregpar: + case SCregister: + case SCtmp: + case SCpseudo: + break; + case SCauto: + case SCparameter: + case SCfastpar: + case SCbprel: + if (e->EV.sp.Vsym->Sflags & SFLunambig) + break; + /* FALL-THROUGH */ + case SCstatic: + case SCextern: + case SCglobal: + case SClocstat: + case SCcomdat: + case SCinline: + case SCsinline: + case SCeinline: + case SCcomdef: + touchstar(); + break; + default: +#ifdef DEBUG + elem_print(e); + symbol_print(e->EV.sp.Vsym); +#endif + assert(0); + } +} + +/************************** + * "touch" variables that could be changed by a function call or + * an indirect assignment. + * Eliminate any subexpressions that are "starred" (they need to + * be recomputed). + * Input: + * flag If !=0, then this is a function call. + * If 0, then this is an indirect assignment. + */ + +STATIC void touchfunc(int flag) +{ register hcs *pe,*petop; + register elem *he; + + //printf("touchfunc(%d)\n", flag); + petop = &hcstab[hcstop]; + //pe = &hcstab[0]; printf("pe = %p, petop = %p\n",pe,petop); + for (pe = &hcstab[0]; pe < petop; pe++) + //for (pe = &hcstab[touchfunci[flag]]; pe < petop; pe++) + { he = pe->Helem; + if (!he) + continue; + switch (he->Eoper) + { + case OPvar: + switch (he->EV.sp.Vsym->Sclass) + { + case SCregpar: + case SCregister: + case SCtmp: + break; + case SCauto: + case SCparameter: + case SCfastpar: + case SCbprel: + //printf("he = '%s'\n", he->EV.sp.Vsym->Sident); + if (he->EV.sp.Vsym->Sflags & SFLunambig) + break; + /* FALL-THROUGH */ + case SCstatic: + case SCextern: + case SCcomdef: + case SCglobal: + case SClocstat: + case SCcomdat: + case SCpseudo: + case SCinline: + case SCsinline: + case SCeinline: + if (!(he->EV.sp.Vsym->ty() & mTYconst)) + goto L1; + break; + default: + debug(WRclass((enum SC)he->EV.sp.Vsym->Sclass)); + assert(0); + } + break; + case OPind: +#if TX86 + case OPstrlen: + case OPstrcmp: + case OPmemcmp: + case OPbt: +#endif + goto L1; +#if TARGET_SEGMENTED + case OPvp_fp: + case OPcvp_fp: + if (flag == 0) /* function calls destroy vptrfptr's, */ + break; /* not indirect assignments */ +#endif + L1: + pe->Helem = NULL; + break; + } + } + touchfunci[flag] = hcstop; +} + + +/******************************* + * Eliminate all common subexpressions that + * do any indirection ("starred" elems). + */ + +STATIC void touchstar() +{ register int i; + register elem *e; + + for (i = touchstari; i < hcstop; i++) + { e = hcstab[i].Helem; + if (e && (e->Eoper == OPind || e->Eoper == OPbt) /*&& !(e->Ety & mTYconst)*/) + hcstab[i].Helem = NULL; + } + touchstari = hcstop; +} + +#if TARGET_SEGMENTED +/***************************************** + * Eliminate any common subexpressions that could be modified + * if a handle pointer access occurs. + */ + +STATIC void touchaccess(elem *ev) +{ register int i; + register elem *e; + + ev = ev->E1; + for (i = 0; i < hcstop; i++) + { e = hcstab[i].Helem; + /* Invalidate any previous handle pointer accesses that */ + /* are not accesses of ev. */ + if (e && (e->Eoper == OPvp_fp || e->Eoper == OPcvp_fp) && e->E1 != ev) + hcstab[i].Helem = NULL; + } +} +#endif + +#endif // !SPP diff --git a/backend/cgcv.c b/backend/cgcv.c new file mode 100644 index 00000000..96645a25 --- /dev/null +++ b/backend/cgcv.c @@ -0,0 +1,2705 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if (SCPP || MARS) && !HTOD + +#include +#include +#include +#include + +#if _WIN32 || linux +#include +#endif + +#if __sun&&__SVR4 +#include +#endif + +#include "cc.h" +#include "type.h" +#include "code.h" +#include "cgcv.h" +#include "cv4.h" +#include "global.h" +#if SCPP +#include "parser.h" +#include "cpp.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +// Convert from SFL protections to CV4 protections +#define SFLtoATTR(sfl) (4 - (((sfl) & SFLpmask) >> 5)) + +extern targ_size_t startoffset; // size of function entry code +extern targ_size_t retoffset; // offset from start of func to ret code + +/* Dynamic array of debtyp_t's */ +static debtyp_t **debtyp; +static unsigned debtyptop; // # of used entries in debtyp[] +static unsigned debtypmax; // current size of debtyp[] +static vec_t debtypvec; // vector of used entries +#define DEBTYPVECDIM 16001 //8009 //3001 // dimension of debtypvec (should be prime) + +#define DEBTYPHASHDIM 1009 +static unsigned debtyphash[DEBTYPHASHDIM]; + +#if MARS +// char *ftdbname; // in ztc/var.c +#define TDB 0 +#else +#define TDB 1 +#endif + +#define DEB_NULL cgcv.deb_offset // index of null debug type record + +/* This limitation is because of 4K page sizes + * in optlink/cv/cvhashes.asm + */ +#define CVIDMAX (0xFF0-20) // the -20 is picked by trial and error + +#if 0 +#define DBG(a) a +#else +#define DBG(a) +#endif + +#define LOCATsegrel 0xC000 + +/* Unfortunately, the fixup stuff is different for EASY OMF and Microsoft */ +#define EASY_LCFDoffset (LOCATsegrel | 0x1404) +#define EASY_LCFDpointer (LOCATsegrel | 0x1800) + +#define LCFD32offset (LOCATsegrel | 0x2404) +#define LCFD32pointer (LOCATsegrel | 0x2C00) +#define LCFD16pointer (LOCATsegrel | 0x0C00) + +Cgcv cgcv; + +STATIC void cv3_symdes ( unsigned char *p , unsigned next ); +STATIC unsigned cv3_paramlist ( type *t , unsigned nparam ); +STATIC unsigned cv3_struct ( symbol *s ); +STATIC char * cv4_prettyident(symbol *s); +STATIC unsigned cv4_symtypidx ( symbol *s ); +STATIC void cv4_outsym(symbol *s); +STATIC void cv4_func(Funcsym *s); + +/****************************************** + * Return number of bytes consumed in OBJ file by a name. + */ + +#if SCPP +inline +#endif +int cv_stringbytes(const char *name) +{ size_t len; + + len = strlen(name); + if (len > CVIDMAX) + len = CVIDMAX; + return len + ((len > 255) ? 4 : 1); +} + +/****************************************** + * Stuff a namestring into p. + * Returns: + * number of bytes consumed + */ + +int cv_namestring(unsigned char *p,const char *name) +{ unsigned len; + + len = strlen(name); + if (len > 255) + { p[0] = 0xFF; + p[1] = 0; + if (len > CVIDMAX) + len = CVIDMAX; + TOWORD(p + 2,len); + memcpy(p + 4,name,len); + len += 4; + } + else + { p[0] = len; + memcpy(p + 1,name,len); + len++; + } + return len; +} + +/*********************************** + * Compute debug register number for symbol s. + * Returns: + * 0..7 byte registers + * 8..15 word registers + * 16..23 dword registers + */ + +STATIC int cv_regnum(symbol *s) +{ unsigned reg; + + reg = s->Sreglsw; +#if SCPP + if (s->Sclass == SCpseudo) + { + reg = pseudoreg[reg]; + } + else +#endif + { + assert(reg < 8); + assert(s->Sfl == FLreg); + switch (type_size(s->Stype)) + { + case LONGSIZE: + case 3: reg += 8; + case SHORTSIZE: reg += 8; + case CHARSIZE: break; + + case LLONGSIZE: + reg += (s->Sregmsw << 8) + (16 << 8) + 16; + if (config.fulltypes == CV4) + reg += (1 << 8); + break; + + default: +#if 0 + symbol_print(s); + type_print(s->Stype); + printf("size = %d\n",type_size(s->Stype)); +#endif + assert(0); + } + } + if (config.fulltypes == CV4) + reg++; + return reg; +} + +/*********************************** + * Allocate a debtyp_t. + */ + +debtyp_t * debtyp_alloc(unsigned length) +{ + debtyp_t *d; + + //printf("len = %u, x%x\n", length, length); +#ifdef DEBUG + unsigned len = sizeof(debtyp_t) - sizeof(d->data) + length; + assert(len < 4 * 4096 - 100); + d = (debtyp_t *) mem_malloc(len /*+ 1*/); + memset(d, 0xAA, len); +// ((char*)d)[len] = 0x2E; +#else + assert(length < 0x10000); + d = (debtyp_t *) malloc(sizeof(debtyp_t) - sizeof(d->data) + length); +#endif + d->length = length; + //printf("debtyp_alloc(%d) = %p\n", length, d); + return d; +} + +/*********************************** + * Free a debtyp_t. + */ + +STATIC void debtyp_free(debtyp_t *d) +{ + //printf("debtyp_free(length = %d, %p)\n", d->length, d); + //fflush(stdout); +#ifdef DEBUG + unsigned len = sizeof(debtyp_t) - sizeof(d->data) + d->length; + assert(len < 4 * 4096 - 100); +// assert(((char*)d)[len] == 0x2E); + memset(d, 0x55, len); + mem_free(d); +#else + free(d); +#endif +} + +#if 0 +void debtyp_check(debtyp_t *d,int linnum) +{ int i; + static volatile char c; + + //printf("linnum = %d\n",linnum); + //printf(" length = %d\n",d->length); + for (i = 0; i < d->length; i++) + c = d->data[i]; +} + +#define debtyp_check(d) debtyp_check(d,__LINE__); +#else +#define debtyp_check(d) +#endif + +/*********************************** + * Search for debtyp_t in debtyp[]. If it is there, return the index + * of it, and free d. Otherwise, add it. + * Returns: + * index in debtyp[] + */ + +idx_t cv_debtyp(debtyp_t *d) +{ unsigned u; + unsigned short length; + unsigned hashi; + + assert(d); + length = d->length; + //printf("length = %3d\n",length); +#if OMFOBJ && TDB + if (config.fulltypes == CVTDB) + { + idx_t result; + +#if 1 + assert(length); + debtyp_check(d); + result = tdb_typidx(&d->length); +#else + unsigned char *buf; + + // Allocate buffer + buf = malloc(6 + length); + if (!buf) + err_nomem(); // out of memory + + // Fill the buffer + TOLONG(buf,cgcv.signature); + memcpy(buf + 4,(char *)d + sizeof(unsigned),2 + length); + +#if 0 +{int i; + for (i=0;i= sizeof(unsigned)) + { + // Hash consists of the sum of the first 4 bytes with the last 4 bytes + union { unsigned char* cp; unsigned* up; } u; + u.cp = d->data; + hash += *u.up; + u.cp += length - sizeof(unsigned); + hash += *u.up; + } + hashi = hash % DEBTYPHASHDIM; + hash %= DEBTYPVECDIM; + + if (vec_testbit(hash,debtypvec)) + { +//printf(" test"); +#if 1 + // Threaded list is much faster + for (u = debtyphash[hashi]; u; u = debtyp[u]->prev) +#else + for (u = debtyptop; u--; ) +#endif + { + if (length == debtyp[u]->length && + memcmp(d->data,debtyp[u]->data,length) == 0) + { debtyp_free(d); +//printf(" match %d\n",u); + return u + cgcv.deb_offset; + } + } + } + else + vec_setbit(hash,debtypvec); + } + else + hashi = 1; +//printf(" add %d\n",debtyptop); + d->prev = debtyphash[hashi]; + debtyphash[hashi] = debtyptop; + + /* It's not already in the array, so add it */ +L1: + if (debtyptop == debtypmax) + { + //printf("reallocate debtyp[] %p\n", debtyp); +#ifdef DEBUG + debtypmax += 10; +#else + debtypmax += debtypmax + 16; +#if __INTSIZE == 4 + if (debtypmax > 0xE000) + debtypmax = 0xE000; +#if SCPP + if (debtyptop >= debtypmax) + err_fatal(EM_2manytypes,debtypmax); // too many types +#endif +#endif +#endif + // Don't use MEM here because we can allocate pretty big + // arrays with this, and we don't want to overflow the PH + // page size. + debtyp = (debtyp_t **) util_realloc(debtyp,sizeof(*debtyp),debtypmax); + } + debtyp[debtyptop] = d; + return debtyptop++ + cgcv.deb_offset; +} + +/**************************** + * Store a null record at DEB_NULL. + */ + +void cv_init() +{ debtyp_t *d; + + //printf("cv_init()\n"); + + // Initialize statics + debtyp = NULL; + debtyptop = 0; + debtypmax = 0; + if (!ftdbname) + ftdbname = (char *)"symc.tdb"; + + memset(&cgcv,0,sizeof(cgcv)); + cgcv.sz_idx = 2; + cgcv.LCFDoffset = LCFD32offset; + cgcv.LCFDpointer = LCFD16pointer; + + debtypvec = vec_calloc(DEBTYPVECDIM); + memset(debtyphash,0,sizeof(debtyphash)); + + /* Reset for different OBJ file formats */ + if (I32) + { + // Adjust values in old CV tables for 32 bit ints + dttab[TYenum] = dttab[TYlong]; + dttab[TYint] = dttab[TYlong]; + dttab[TYuint] = dttab[TYulong]; + + // Adjust Codeview 4 values for 32 bit ints and 32 bit pointer offsets + dttab4[TYenum] = 0x74; + dttab4[TYint] = 0x74; + dttab4[TYuint] = 0x75; + dttab4[TYptr] = 0x400; + dttab4[TYnptr] = 0x400; + dttab4[TYjhandle] = 0x400; +#if TARGET_SEGMENTED + dttab4[TYsptr] = 0x400; + dttab4[TYcptr] = 0x400; + dttab4[TYfptr] = 0x500; +#endif + + if (config.flags & CFGeasyomf) + { cgcv.LCFDoffset = EASY_LCFDoffset; + cgcv.LCFDpointer = EASY_LCFDpointer; + assert(config.fulltypes == CVOLD); + } + else + cgcv.LCFDpointer = LCFD32pointer; + + if (config.exe & EX_flat) + cgcv.FD_code = 0x10; + } + + if (config.fulltypes >= CV4) + { int flags; + static unsigned short memmodel[5] = {0,0x100,0x20,0x120,0x120}; + char version[1 + sizeof(VERSION)]; + unsigned char debsym[8 + sizeof(version)]; + const char *x = "1MYS"; + + // Put out signature indicating CV4 format + cgcv.signature = (config.fulltypes == CV4) ? 1 : *(int *) x; + + cgcv.deb_offset = 0x1000; + + if (config.fulltypes >= CVSYM) + { cgcv.sz_idx = 4; + if (!(config.flags2 & CFG2phgen)) + cgcv.deb_offset = 0x80000000; + } + + obj_write_bytes(SegData[DEBSYM],4,&cgcv.signature); + + // Allocate an LF_ARGLIST with no arguments + if (config.fulltypes == CV4) + { d = debtyp_alloc(4); + TOWORD(d->data,LF_ARGLIST); + TOWORD(d->data + 2,0); + } + else + { d = debtyp_alloc(6); + TOWORD(d->data,LF_ARGLIST); + TOLONG(d->data + 2,0); + } + + // Put out S_COMPILE record + TOWORD(debsym + 2,S_COMPILE); + switch (config.target_cpu) + { case TARGET_8086: debsym[4] = 0; break; + case TARGET_80286: debsym[4] = 2; break; + case TARGET_80386: debsym[4] = 3; break; + case TARGET_80486: debsym[4] = 4; break; + case TARGET_Pentium: + case TARGET_PentiumMMX: + debsym[4] = 5; break; + case TARGET_PentiumPro: + case TARGET_PentiumII: + debsym[4] = 6; break; + default: assert(0); + } + debsym[5] = (CPP != 0); // 0==C, 1==C++ + flags = (config.inline8087) ? (0<<3) : (1<<3); + if (I32) + flags |= 0x80; // 32 bit addresses + flags |= memmodel[config.memmodel]; + TOWORD(debsym + 6,flags); + version[0] = 'Z'; + strcpy(version + 1,VERSION); + cv_namestring(debsym + 8,version); + TOWORD(debsym,6 + sizeof(version)); + obj_write_bytes(SegData[DEBSYM],8 + sizeof(version),debsym); + +#if OMFOBJ && TDB + // Put out S_TDBNAME record + if (config.fulltypes == CVTDB) + { + unsigned char *ds; + size_t len; + + pstate.STtdbtimestamp = tdb_gettimestamp(); + len = cv_stringbytes(ftdbname); + ds = (unsigned char *) alloca(8 + len); + TOWORD(ds,6 + len); + TOWORD(ds + 2,S_TDBNAME); + TOLONG(ds + 4,pstate.STtdbtimestamp); + cv_namestring(ds + 8,ftdbname); + obj_write_bytes(SegData[DEBSYM],8 + len,ds); + } +#endif + } + else + { + assert(0); + } +#if TDB + if (config.fulltypes == CVTDB) + cgcv.deb_offset = cv_debtyp(d); + else +#endif + cv_debtyp(d); +} + +/////////////////////////// CodeView 4 /////////////////////////////// + +/*********************************** + * Return number of bytes required to store a numeric leaf. + */ + +inline unsigned cv4_numericbytes(targ_size_t value) +{ unsigned u; + + if (value < 0x8000) + u = 2; + else if (value < 0x10000) + u = 4; + else + u = 6; + return u; +} + +/******************************** + * Store numeric leaf. + * Must use exact same number of bytes as cv4_numericbytes(). + */ + +void cv4_storenumeric(unsigned char *p,targ_size_t value) +{ + if (value < 0x8000) + TOWORD(p,value); + else if (value < 0x10000) + { TOWORD(p,LF_USHORT); + p += 2; + TOWORD(p,value); + } + else + { TOWORD(p,LF_ULONG); + *(targ_ulong *)(p + 2) = (unsigned long) value; + } +} + +/********************************* + * Generate a type index for a parameter list. + */ + +idx_t cv4_arglist(type *t,unsigned *pnparam) +{ unsigned u; + unsigned nparam; + idx_t paramidx; + debtyp_t *d; + param_t *p; + + // Compute nparam, number of parameters + nparam = 0; + for (p = t->Tparamtypes; p; p = p->Pnext) + nparam++; + *pnparam = nparam; + + // Construct an LF_ARGLIST of those parameters + if (nparam == 0) + paramidx = DEB_NULL; + else + { + if (config.fulltypes == CV4) + { d = debtyp_alloc(2 + 2 + nparam * 2); + TOWORD(d->data,LF_ARGLIST); + TOWORD(d->data + 2,nparam); + + p = t->Tparamtypes; + for (u = 0; u < nparam; u++) + { TOWORD(d->data + 4 + u * 2,cv4_typidx(p->Ptype)); + p = p->Pnext; + } + } + else + { d = debtyp_alloc(2 + 4 + nparam * 4); + TOWORD(d->data,LF_ARGLIST); + TOLONG(d->data + 2,nparam); + + p = t->Tparamtypes; + for (u = 0; u < nparam; u++) + { TOLONG(d->data + 6 + u * 4,cv4_typidx(p->Ptype)); + p = p->Pnext; + } + } + paramidx = cv_debtyp(d); + } + return paramidx; +} + +/***************************** + * Build LF_METHODLIST for overloaded member function. + * Output: + * *pcount # of entries in method list + * Returns: + * type index of method list + * 0 don't do this one + */ + +#if SCPP + +STATIC int cv4_methodlist(symbol *sf,int *pcount) +{ int count; + int mlen; + symbol *s; + debtyp_t *d; + unsigned char *p; + unsigned short attribute; + + symbol_debug(sf); + + // First, compute how big the method list is + count = 0; + mlen = 2; + for (s = sf; s; s = s->Sfunc->Foversym) + { + if (s->Sclass == SCtypedef || s->Sclass == SCfunctempl) + continue; + if (s->Sfunc->Fflags & Fnodebug) + continue; + if (s->Sfunc->Fflags & Fintro) + mlen += 4; + mlen += cgcv.sz_idx * 2; + count++; + } + + if (!count) + return 0; + + // Allocate and fill it in + d = debtyp_alloc(mlen); + p = d->data; + TOWORD(p,LF_METHODLIST); + p += 2; + for (s = sf; s; s = s->Sfunc->Foversym) + { + if (s->Sclass == SCtypedef || s->Sclass == SCfunctempl) + continue; + if (s->Sfunc->Fflags & Fnodebug) + continue; + attribute = SFLtoATTR(s->Sflags); + // Make sure no overlapping bits + assert((Fvirtual | Fpure | Fintro | Fstatic) == (Fvirtual ^ Fpure ^ Fintro ^ Fstatic)); + switch ((s->Sfunc->Fflags & (Fvirtual | Fstatic)) | + (s->Sfunc->Fflags & (Fpure | Fintro))) + { + // BUG: should we have 0x0C, friend functions? + case Fstatic: attribute |= 0x08; break; + case Fvirtual: attribute |= 0x04; break; + case Fvirtual | Fintro: attribute |= 0x10; break; + case Fvirtual | Fpure: attribute |= 0x14; break; + case Fvirtual | Fintro | Fpure: attribute |= 0x18; break; + case 0: + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + TOIDX(p,attribute); + p += cgcv.sz_idx; + TOIDX(p,cv4_symtypidx(s)); + p += cgcv.sz_idx; + if (s->Sfunc->Fflags & Fintro) + { TOLONG(p,cpp_vtbloffset((Classsym *)s->Sscope,s)); + p += 4; + } + } + assert(p - d->data == mlen); + + *pcount = count; + return cv_debtyp(d); +} + +#endif + +/********************************** + * Pretty-print indentifier for CV4 types. + */ + +#if SCPP + +STATIC char * cv4_prettyident(symbol *s) +{ symbol *stmp; + char *p; + + stmp = s->Sscope; + s->Sscope = NULL; // trick cpp_prettyident into leaving off :: + p = cpp_prettyident(s); + s->Sscope = (Classsym *)stmp; + return p; +} + +#endif + +/**************************** + * Return type index of struct. + * Input: + * s struct tag symbol + * flags + * 0 generate a reference to s + * 1 just saw the definition of s + * 2 saw key function for class s + * 3 no longer have a key function for class s + */ + +idx_t cv4_struct(Classsym *s,int flags) +{ targ_size_t size; + debtyp_t *d,*dt; + unsigned len; + unsigned nfields,fnamelen; + idx_t typidx; + type *t; + symlist_t sl; + struct_t *st; + char *id; +#if SCPP + baseclass_t *b; +#endif + unsigned numidx; + unsigned leaf; + unsigned property; + unsigned attribute; + unsigned char *p; + int refonly; + int i; + int count; // COUNT field in LF_CLASS + + _chkstack(); + symbol_debug(s); + assert(config.fulltypes >= CV4); + st = s->Sstruct; + if (st->Sflags & STRanonymous) // if anonymous class/union + return 0; + + //dbg_printf("cv4_struct(%s,%d)\n",s->Sident,flags); + t = s->Stype; + //printf("t = %p, Tflags = x%x\n", t, t->Tflags); + type_debug(t); + + // Determine if we should do a reference or a definition + refonly = 1; // assume reference only + if (MARS || t->Tflags & TFsizeunknown || st->Sflags & STRoutdef) + { + //printf("ref only\n"); + } + else + { + // We have a definition that we have not put out yet + switch (flags) + { case 0: // reference to s +#if SCPP + if (!CPP || + config.flags2 & (CFG2fulltypes | CFG2hdrdebug) || + !(st->Sflags & STRvtblext)) + refonly = 0; +#else + refonly = 0; +#endif + break; + case 1: // saw def of s + if (!s->Stypidx) // if not forward referenced + return 0; +#if SCPP + if (!CPP || + config.flags2 & CFG2fulltypes || + !(st->Sflags & STRvtblext)) + refonly = 0; +#endif + break; +#if SCPP + case 2: // saw key func for s + if (config.flags2 & CFG2fulltypes) + return 0; + refonly = 0; + break; + case 3: // no longer have key func for s + if (!s->Stypidx || config.flags2 & CFG2fulltypes) + return 0; + refonly = 0; + break; +#endif + default: + assert(0); + } + } + + if (MARS || refonly) + { + if (s->Stypidx) // if reference already generated + { //assert(s->Stypidx - cgcv.deb_offset < debtyptop); + return s->Stypidx; // use already existing reference + } + size = 0; + property = 0x80; // class is forward referenced + } + else + { size = type_size(t); + st->Sflags |= STRoutdef; + property = 0; + } + +#if SCPP + if (CPP) + { + if (s->Sscope) // if class is nested + property |= 8; + if (st->Sctor || st->Sdtor) + property |= 2; // class has ctors and/or dtors + if (st->Sopoverload) + property |= 4; // class has overloaded operators + if (st->Scastoverload) + property |= 0x40; // class has casting methods + if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug)) + property |= 0x20; // class has overloaded assignment + } +#endif + id = prettyident(s); + if (config.fulltypes == CV4) + { numidx = (st->Sflags & STRunion) ? 8 : 12; + len = numidx + cv4_numericbytes(size); + d = debtyp_alloc(len + cv_stringbytes(id)); + cv4_storenumeric(d->data + numidx,size); + } + else + { numidx = (st->Sflags & STRunion) ? 10 : 18; + len = numidx + 4; + d = debtyp_alloc(len + cv_stringbytes(id)); + TOLONG(d->data + numidx,size); + } + len += cv_namestring(d->data + len,id); + switch (s->Sclass) + { case SCstruct: + leaf = LF_STRUCTURE; + if (st->Sflags & STRunion) + { leaf = LF_UNION; + break; + } + if (st->Sflags & STRclass) + leaf = LF_CLASS; + goto L1; + L1: + if (config.fulltypes == CV4) + TOWORD(d->data + 8,0); // dList + else + TOLONG(d->data + 10,0); // dList +#if SCPP + if (CPP) + { debtyp_t *vshape; + unsigned n; + unsigned char descriptor; + list_t vl; + + vl = st->Svirtual; + n = list_nitems(vl); + if (n == 0) // if no virtual functions + { + if (config.fulltypes == CV4) + TOWORD(d->data + 10,0); // vshape is 0 + else + TOLONG(d->data + 14,0); // vshape is 0 + } + else + { + vshape = debtyp_alloc(4 + (n + 1) / 2); + TOWORD(vshape->data,LF_VTSHAPE); + TOWORD(vshape->data + 2,1); + + n = 0; + descriptor = 0; + for (; vl; vl = list_next(vl)) + { mptr_t *m; + tym_t ty; + + m = list_mptr(vl); + symbol_debug(m->MPf); + ty = tybasic(m->MPf->ty()); + assert(tyfunc(ty)); + if (intsize == 4) + descriptor |= 5; + if (tyfarfunc(ty)) + descriptor++; + vshape->data[4 + n / 2] = descriptor; + descriptor <<= 4; + n++; + } + if (config.fulltypes == CV4) + TOWORD(d->data + 10,cv_debtyp(vshape)); // vshape + else + TOLONG(d->data + 14,cv_debtyp(vshape)); // vshape + } + } + else +#endif + { + if (config.fulltypes == CV4) + TOWORD(d->data + 10,0); // vshape + else + TOLONG(d->data + 14,0); // vshape + } + break; + default: +#if DEBUG && SCPP + symbol_print(s); +#endif + assert(0); + } + TOWORD(d->data,leaf); + + // Assign a number to prevent infinite recursion if a struct member + // references the same struct. +#if OMFOBJ && TDB + if (config.fulltypes == CVTDB) + { + TOWORD(d->data + 2,0); // number of fields + TOLONG(d->data + 6,0); // field list is 0 + TOWORD(d->data + 4,property | 0x80); // set fwd ref bit +#if 0 +printf("fwd struct ref\n"); +{int i; + printf("len = %d, length = %d\n",len,d->length); + for (i=0;ilength;i++) + printf("%02x ",d->data[i]); + printf("\n"); +} +#endif + debtyp_check(d); + s->Stypidx = tdb_typidx(&d->length); // forward reference it + } + else +#endif + { + d->length = 0; // so cv_debtyp() will allocate new + s->Stypidx = cv_debtyp(d); + d->length = len; // restore length + } + + if (refonly) // if reference only + { + //printf("refonly\n"); + TOWORD(d->data + 2,0); // count: number of fields is 0 + if (config.fulltypes == CV4) + { TOWORD(d->data + 4,0); // field list is 0 + TOWORD(d->data + 6,property); + } + else + { TOLONG(d->data + 6,0); // field list is 0 + TOWORD(d->data + 4,property); + } + return s->Stypidx; + } + +#if MARS + util_progress(); +#else + file_progress(); +#endif + + // Compute the number of fields, and the length of the fieldlist record + nfields = 0; + fnamelen = 2; +#if SCPP + if (CPP) + { + // Base classes come first + for (b = st->Sbase; b; b = b->BCnext) + { + if (b->BCflags & BCFvirtual) // skip virtual base classes + continue; + nfields++; + fnamelen += ((config.fulltypes == CV4) ? 6 : 8) + + cv4_numericbytes(b->BCoffset); + } + + // Now virtual base classes (direct and indirect) + for (b = st->Svirtbase; b; b = b->BCnext) + { + nfields++; + fnamelen += ((config.fulltypes == CV4) ? 8 : 12) + + cv4_numericbytes(st->Svbptr_off) + + cv4_numericbytes(b->BCvbtbloff / intsize); + } + + // Now friend classes + i = list_nitems(st->Sfriendclass); + nfields += i; + fnamelen += i * ((config.fulltypes == CV4) ? 4 : 8); + + // Now friend functions + for (sl = st->Sfriendfuncs; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + + symbol_debug(sf); + if (sf->Sclass == SCfunctempl) + continue; + nfields++; + fnamelen += ((config.fulltypes == CV4) ? 4 : 6) + + cv_stringbytes(cpp_unmangleident(sf->Sident)); + } + } +#endif + count = nfields; + for (sl = st->Sfldlst; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + targ_size_t offset; + char *id; + unsigned len; + + symbol_debug(sf); + id = sf->Sident; + switch (sf->Sclass) + { case SCmember: + case SCfield: +#if SCPP + if (CPP && sf == s->Sstruct->Svptr) + fnamelen += ((config.fulltypes == CV4) ? 4 : 8); + else +#endif + { offset = sf->Smemoff; + fnamelen += ((config.fulltypes == CV4) ? 6 : 8) + + cv4_numericbytes(offset) + cv_stringbytes(id); + } + break; +#if SCPP + case SCstruct: + if (sf->Sstruct->Sflags & STRanonymous) + continue; + if (sf->Sstruct->Sflags & STRnotagname) + id = cpp_name_none; + property |= 0x10; // class contains nested classes + goto Lnest2; + + case SCenum: + if (sf->Senum->SEflags & SENnotagname) + id = cpp_name_none; + goto Lnest2; + + case SCtypedef: + Lnest2: + fnamelen += ((config.fulltypes == CV4) ? 4 : 8) + + cv_stringbytes(id); + break; + + case SCextern: + case SCcomdef: + case SCglobal: + case SCstatic: + case SCinline: + case SCsinline: + case SCeinline: + case SCcomdat: + if (tyfunc(sf->ty())) + { symbol *so; + int nfuncs; + + nfuncs = 0; + for (so = sf; so; so = so->Sfunc->Foversym) + { + if (so->Sclass == SCtypedef || + so->Sclass == SCfunctempl || + so->Sfunc->Fflags & Fnodebug) // if compiler generated + continue; // skip it + nfuncs++; + } + if (nfuncs == 0) + continue; + + if (nfuncs > 1) + count += nfuncs - 1; + + id = cv4_prettyident(sf); + } + fnamelen += ((config.fulltypes == CV4) ? 6 : 8) + + cv_stringbytes(id); + break; +#endif + default: + continue; + } + nfields++; + count++; + } + + TOWORD(d->data + 2,count); + if (config.fulltypes == CV4) + TOWORD(d->data + 6,property); + else + TOWORD(d->data + 4,property); + + // Generate fieldlist type record + dt = debtyp_alloc(fnamelen); + p = dt->data; + TOWORD(p,LF_FIELDLIST); + + // And fill it in + p += 2; +#if SCPP + if (CPP) + { + // Put out real base classes + for (b = st->Sbase; b; b = b->BCnext) + { targ_size_t offset; + + if (b->BCflags & BCFvirtual) // skip virtual base classes + continue; + offset = b->BCoffset; + typidx = cv4_symtypidx(b->BCbase); + + attribute = (b->BCflags & BCFpmask); + if (attribute & 4) + attribute = 1; + else + attribute = 4 - attribute; + + TOWORD(p,LF_BCLASS); + if (config.fulltypes == CV4) + { TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + p += 6; + } + else + { TOLONG(p + 4,typidx); + TOWORD(p + 2,attribute); + p += 8; + } + + cv4_storenumeric(p,offset); + p += cv4_numericbytes(offset); + } + + // Now direct followed by indirect virtual base classes + i = LF_VBCLASS; + do + { + for (b = st->Svirtbase; b; b = b->BCnext) + { targ_size_t vbpoff,vboff; + type *vbptype; // type of virtual base pointer + idx_t vbpidx; + + if (baseclass_find(st->Sbase,b->BCbase)) // if direct vbase + { if (i == LF_IVBCLASS) + continue; + } + else + { if (i == LF_VBCLASS) + continue; + } + + typidx = cv4_symtypidx(b->BCbase); + + vbptype = type_allocn(TYarray,tsint); + vbptype->Tflags |= TFsizeunknown; + vbptype = newpointer(vbptype); + vbptype->Tcount++; + vbpidx = cv4_typidx(vbptype); + type_free(vbptype); + + attribute = (b->BCflags & BCFpmask); + if (attribute & 4) + attribute = 1; + else + attribute = 4 - attribute; + + vbpoff = st->Svbptr_off; + vboff = b->BCvbtbloff / intsize; + + if (config.fulltypes == CV4) + { TOWORD(p,i); + TOWORD(p + 2,typidx); + TOWORD(p + 4,vbpidx); + TOWORD(p + 6,attribute); + p += 8; + } + else + { TOWORD(p,i); + TOLONG(p + 4,typidx); // btype + TOLONG(p + 8,vbpidx); // vbtype + TOWORD(p + 2,attribute); + p += 12; + } + + cv4_storenumeric(p,vbpoff); + p += cv4_numericbytes(vbpoff); + cv4_storenumeric(p,vboff); + p += cv4_numericbytes(vboff); + } + i ^= LF_VBCLASS ^ LF_IVBCLASS; // toggle between them + } while (i != LF_VBCLASS); + + // Now friend classes + for (sl = s->Sstruct->Sfriendclass; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + + symbol_debug(sf); + typidx = cv4_symtypidx(sf); + if (config.fulltypes == CV4) + { TOWORD(p,LF_FRIENDCLS); + TOWORD(p + 2,typidx); + p += 4; + } + else + { TOLONG(p,LF_FRIENDCLS); + TOLONG(p + 4,typidx); + p += 8; + } + } + + // Now friend functions + for (sl = s->Sstruct->Sfriendfuncs; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + + symbol_debug(sf); + if (sf->Sclass == SCfunctempl) + continue; + typidx = cv4_symtypidx(sf); + TOWORD(p,LF_FRIENDFCN); + if (config.fulltypes == CV4) + { TOWORD(p + 2,typidx); + p += 4; + } + else + { TOLONG(p + 2,typidx); + p += 6; + } + p += cv_namestring(p,cpp_unmangleident(sf->Sident)); + } + } +#endif + for (sl = s->Sstruct->Sfldlst; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + targ_size_t offset; + char *id; + + symbol_debug(sf); + id = sf->Sident; + switch (sf->Sclass) + { case SCfield: + { debtyp_t *db; + + if (config.fulltypes == CV4) + { db = debtyp_alloc(6); + TOWORD(db->data,LF_BITFIELD); + db->data[2] = sf->Swidth; + db->data[3] = sf->Sbit; + TOWORD(db->data + 4,cv4_symtypidx(sf)); + } + else + { db = debtyp_alloc(8); + TOWORD(db->data,LF_BITFIELD); + db->data[6] = sf->Swidth; + db->data[7] = sf->Sbit; + TOLONG(db->data + 2,cv4_symtypidx(sf)); + } + typidx = cv_debtyp(db); + goto L3; + } + case SCmember: + typidx = cv4_symtypidx(sf); + L3: +#if SCPP + if (CPP && sf == s->Sstruct->Svptr) + { + if (config.fulltypes == CV4) + { TOWORD(p,LF_VFUNCTAB); + TOWORD(p + 2,typidx); + p += 4; + } + else + { TOLONG(p,LF_VFUNCTAB); // 0 fill 2 bytes + TOLONG(p + 4,typidx); + p += 8; + } + break; + } +#endif + offset = sf->Smemoff; + TOWORD(p,LF_MEMBER); +#if SCPP + attribute = CPP ? SFLtoATTR(sf->Sflags) : 0; + assert((attribute & ~3) == 0); +#else + attribute = 0; +#endif + if (config.fulltypes == CV4) + { TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + p += 6; + } + else + { TOLONG(p + 4,typidx); + TOWORD(p + 2,attribute); + p += 8; + } + cv4_storenumeric(p,offset); + p += cv4_numericbytes(offset); + p += cv_namestring(p,id); + break; +#if SCPP + case SCstruct: + if (sf->Sstruct->Sflags & STRanonymous) + continue; + if (sf->Sstruct->Sflags & STRnotagname) + id = cpp_name_none; + goto Lnest; + + case SCenum: + if (sf->Senum->SEflags & SENnotagname) + id = cpp_name_none; + goto Lnest; + + case SCtypedef: + Lnest: + TOWORD(p,LF_NESTTYPE); + typidx = cv4_symtypidx(sf); + if (config.fulltypes == CV4) + { TOWORD(p + 2,typidx); + p += 4; + } + else + { TOLONG(p + 4,typidx); + p += 8; + } + L2: + p += cv_namestring(p,id); + break; + + case SCextern: + case SCcomdef: + case SCglobal: + case SCstatic: + case SCinline: + case SCsinline: + case SCeinline: + case SCcomdat: + if (tyfunc(sf->ty())) + { int count; + + typidx = cv4_methodlist(sf,&count); + if (!typidx) + break; + id = cv4_prettyident(sf); + TOWORD(p,LF_METHOD); + TOWORD(p + 2,count); + p += 4; + TOIDX(p,typidx); + p += cgcv.sz_idx; + goto L2; + } + else + { + TOWORD(p,LF_STMEMBER); + typidx = cv4_symtypidx(sf); + attribute = SFLtoATTR(sf->Sflags); + if (config.fulltypes == CV4) + { TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + p += 6; + } + else + { TOLONG(p + 4,typidx); + TOWORD(p + 2,attribute); + p += 8; + } + goto L2; + } + break; +#endif + default: + continue; + } + } + //dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data); + assert(p - dt->data == fnamelen); + if (config.fulltypes == CV4) + TOWORD(d->data + 4,cv_debtyp(dt)); + else + TOLONG(d->data + 6,cv_debtyp(dt)); + +#if TDB + if (config.fulltypes == CVTDB) + s->Stypidx = cv_debtyp(d); +#endif +#if SCPP + if (CPP) + { + symbol_debug(s); + if (st->Sflags & STRglobal) + list_prepend(&cgcv.list,s); + else + cv4_outsym(s); + } +#endif + return s->Stypidx; +} + +/**************************** + * Return type index of enum. + */ + +#if SCPP + +STATIC unsigned cv4_enum(symbol *s) +{ + debtyp_t *d,*dt; + unsigned nfields,fnamelen; + unsigned len; + type *t; + type *tbase; + symlist_t sl; + unsigned property; + unsigned attribute; + int i; + char *id; + + _chkstack(); + symbol_debug(s); + if (s->Stypidx) // if already converted + { //assert(s->Stypidx - cgcv.deb_offset < debtyptop); + return s->Stypidx; + } + + //dbg_printf("cv4_enum(%s)\n",s->Sident); + t = s->Stype; + type_debug(t); + tbase = t->Tnext; + property = 0; + if (s->Senum->SEflags & SENforward) + property |= 0x80; // enum is forward referenced + + id = s->Sident; + if (s->Senum->SEflags & SENnotagname) + id = cpp_name_none; + if (config.fulltypes == CV4) + { len = 10; + d = debtyp_alloc(len + cv_stringbytes(id)); + TOWORD(d->data,LF_ENUM); + TOWORD(d->data + 4,cv4_typidx(tbase)); + TOWORD(d->data + 8,property); + } + else + { len = 14; + d = debtyp_alloc(len + cv_stringbytes(id)); + TOWORD(d->data,LF_ENUM); + TOLONG(d->data + 6,cv4_typidx(tbase)); + TOWORD(d->data + 4,property); + } + len += cv_namestring(d->data + len,id); + + // Assign a number to prevent infinite recursion if an enum member + // references the same enum. +#if OMFOBJ && TDB + if (config.fulltypes == CVTDB) + { debtyp_t *df; + + TOWORD(d->data + 2,0); + TOWORD(d->data + 6,0); + debtyp_check(d); + s->Stypidx = tdb_typidx(&d->length); // forward reference it + } + else +#endif + { + d->length = 0; // so cv_debtyp() will allocate new + s->Stypidx = cv_debtyp(d); + d->length = len; // restore length + } + + // Compute the number of fields, and the length of the fieldlist record + nfields = 0; + fnamelen = 2; + for (sl = s->Senumlist; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + unsigned long value; + + symbol_debug(sf); + value = el_tolongt(sf->Svalue); + nfields++; + fnamelen += 4 + cv4_numericbytes(value) + cv_stringbytes(sf->Sident); + } + + TOWORD(d->data + 2,nfields); + + // If forward reference, then field list is 0 + if (s->Senum->SEflags & SENforward) + { + TOWORD(d->data + 6,0); + return s->Stypidx; + } + + // Generate fieldlist type record + dt = debtyp_alloc(fnamelen); + TOWORD(dt->data,LF_FIELDLIST); + + // And fill it in + i = 2; + for (sl = s->Senumlist; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + unsigned long value; + + symbol_debug(sf); + value = el_tolongt(sf->Svalue); + TOWORD(dt->data + i,LF_ENUMERATE); + attribute = SFLtoATTR(sf->Sflags); + TOWORD(dt->data + i + 2,attribute); + cv4_storenumeric(dt->data + i + 4,value); + i += 4 + cv4_numericbytes(value); + i += cv_namestring(dt->data + i,sf->Sident); + + // If enum is not a member of a class, output enum members as constants + if (!isclassmember(s)) + { symbol_debug(sf); + cv4_outsym(sf); + } + } + assert(i == fnamelen); + if (config.fulltypes == CV4) + TOWORD(d->data + 6,cv_debtyp(dt)); + else + TOLONG(d->data + 10,cv_debtyp(dt)); + + symbol_debug(s); + if (CPP) + cv4_outsym(s); + return s->Stypidx; +} + +#endif + +/************************************************ + * Return 'calling convention' type of function. + */ + +unsigned char cv4_callconv(type *t) +{ unsigned char call; + + switch (tybasic(t->Tty)) + { +#if TARGET_SEGMENTED + case TYffunc: call = 1; break; + case TYfpfunc: call = 3; break; + case TYf16func: call = 3; break; + case TYfsfunc: call = 8; break; + case TYnsysfunc: call = 9; break; + case TYfsysfunc: call = 10; break; +#endif + case TYnfunc: call = 0; break; + case TYnpfunc: call = 2; break; + case TYnsfunc: call = 7; break; + case TYifunc: call = 1; break; + case TYjfunc: call = 2; break; + case TYmfunc: call = 11; break; // this call + default: + assert(0); + } + return call; +} + +/********************************************** + * Return type index for the type of a symbol. + */ + +#if MARS + +STATIC unsigned cv4_symtypidx(symbol *s) +{ + return cv4_typidx(s->Stype); +} + +#endif + +#if SCPP + +STATIC unsigned cv4_symtypidx(symbol *s) +{ type *t; + debtyp_t *d; + unsigned char *p; + + if (!CPP) + return cv4_typidx(s->Stype); + symbol_debug(s); + if (isclassmember(s)) + { t = s->Stype; + if (tyfunc(t->Tty)) + { param_t *pa; + unsigned nparam; + idx_t paramidx; + idx_t thisidx; + unsigned u; + func_t *f; + unsigned char call; + + // It's a member function, which gets a special type record + + f = s->Sfunc; + if (f->Fflags & Fstatic) + thisidx = dttab4[TYvoid]; + else + { type *tthis = cpp_thistype(s->Stype,(Classsym *)s->Sscope); + + thisidx = cv4_typidx(tthis); + type_free(tthis); + } + + paramidx = cv4_arglist(t,&nparam); + call = cv4_callconv(t); + + if (config.fulltypes == CV4) + { + d = debtyp_alloc(18); + p = d->data; + TOWORD(p,LF_MFUNCTION); + TOWORD(p + 2,cv4_typidx(t->Tnext)); + TOWORD(p + 4,cv4_symtypidx(s->Sscope)); + TOWORD(p + 6,thisidx); + p[8] = call; + p[9] = 0; // reserved + TOWORD(p + 10,nparam); + TOWORD(p + 12,paramidx); + TOLONG(p + 14,0); // thisadjust + } + else + { + d = debtyp_alloc(26); + p = d->data; + TOWORD(p,LF_MFUNCTION); + TOLONG(p + 2,cv4_typidx(t->Tnext)); + TOLONG(p + 6,cv4_symtypidx(s->Sscope)); + TOLONG(p + 10,thisidx); + p[14] = call; + p[15] = 0; // reserved + TOWORD(p + 16,nparam); + TOLONG(p + 18,paramidx); + TOLONG(p + 22,0); // thisadjust + } + return cv_debtyp(d); + } + } + return cv4_typidx(s->Stype); +} + +#endif + +/*********************************** + * Return CV4 type index for a type. + */ + +unsigned cv4_typidx(type *t) +{ unsigned typidx; + unsigned u; + unsigned next; + unsigned key; + debtyp_t *d; + targ_size_t size; + tym_t tym; + tym_t tycv; + tym_t tymnext; + type *tv; + unsigned dt; + unsigned attribute; + unsigned char call; + + //dbg_printf("cv4_typidx(%p)\n",t); + if (!t) + return dttab4[TYint]; // assume int + type_debug(t); + next = cv4_typidx(t->Tnext); + tycv = t->Tty; + tym = tybasic(tycv); + tycv &= mTYconst | mTYvolatile | mTYimmutable; + attribute = 0; +L1: + dt = dttab4[tym]; + switch (tym) + { + case TYllong: + if (t->Tnext) + goto Ldelegate; + assert(dt); + typidx = dt; + break; + + case TYullong: + if (t->Tnext) + goto Ldarray; + assert(dt); + typidx = dt; + break; + + case TYvoid: + case TYchar: + case TYschar: + case TYuchar: + case TYchar16: + case TYshort: + case TYushort: + case TYint: + case TYuint: + case TYulong: + case TYlong: + case TYfloat: + case TYdouble: + case TYdouble_alias: + case TYldouble: + case TYifloat: + case TYidouble: + case TYildouble: + case TYcfloat: + case TYcdouble: + case TYcldouble: + case TYbool: + case TYwchar_t: + case TYdchar: + assert(dt); + typidx = dt; + break; + +#if JHANDLE + case TYjhandle: +#if TDB + if (config.fulltypes == CVTDB) { + attribute |= 20; + goto L2; + } +#endif + goto Lptr; +#endif + case TYnptr: +#if MARS + if (t->Tkey) + goto Laarray; +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + Lptr: + attribute |= I32 ? 10 : 0; goto L2; +#if TARGET_SEGMENTED + case TYfptr: + case TYvptr: attribute |= I32 ? 11 : 1; goto L2; + case TYhptr: attribute |= 2; goto L2; +#endif + + L2: +#if 1 + // This is a hack to duplicate bugs in VC, so that the VC + // debugger will work. + tymnext = t->Tnext->Tty; + if (tymnext & (mTYconst | mTYimmutable | mTYvolatile) && + !tycv && + tyarithmetic(tymnext) && + !(attribute & 0xE0) + ) + { + typidx = dt | dttab4[tybasic(tymnext)]; + break; + } +#endif + if ((next & 0xFF00) == 0 && !(attribute & 0xE0)) + typidx = next | dt; + else + { + if (tycv & (mTYconst | mTYimmutable)) + attribute |= 0x400; + if (tycv & mTYvolatile) + attribute |= 0x200; + tycv = 0; + if (config.fulltypes == CV4) + { d = debtyp_alloc(6); + TOWORD(d->data,LF_POINTER); + TOWORD(d->data + 2,attribute); + TOWORD(d->data + 4,next); + } + else + { d = debtyp_alloc(10); + TOWORD(d->data,LF_POINTER); + TOLONG(d->data + 2,attribute); + TOLONG(d->data + 6,next); + } + typidx = cv_debtyp(d); + } + break; + + Ldarray: + assert(config.fulltypes == CV4); +#if 1 + d = debtyp_alloc(12); + TOWORD(d->data, LF_OEM); + TOWORD(d->data + 2, OEM); + TOWORD(d->data + 4, 1); // 1 = dynamic array + TOWORD(d->data + 6, 2); // count of type indices to follow + TOWORD(d->data + 8, 0x12); // index type, T_LONG + TOWORD(d->data + 10, next); // element type +#else + d = debtyp_alloc(6); + TOWORD(d->data,LF_DYN_ARRAY); + TOWORD(d->data + 2, 0x12); // T_LONG + TOWORD(d->data + 4, next); +#endif + typidx = cv_debtyp(d); + break; + + Laarray: + assert(config.fulltypes == CV4); +#if MARS + key = cv4_typidx(t->Tkey); +#if 1 + d = debtyp_alloc(12); + TOWORD(d->data, LF_OEM); + TOWORD(d->data + 2, OEM); + TOWORD(d->data + 4, 2); // 2 = associative array + TOWORD(d->data + 6, 2); // count of type indices to follow + TOWORD(d->data + 8, key); // key type + TOWORD(d->data + 10, next); // element type +#else + d = debtyp_alloc(6); + TOWORD(d->data,LF_ASSOC_ARRAY); + TOWORD(d->data + 2, key); // key type + TOWORD(d->data + 4, next); // element type +#endif + typidx = cv_debtyp(d); +#endif + break; + + Ldelegate: + assert(config.fulltypes == CV4); + tv = type_fake(TYnptr); + tv->Tcount++; + key = cv4_typidx(tv); + type_free(tv); +#if 1 + d = debtyp_alloc(12); + TOWORD(d->data, LF_OEM); + TOWORD(d->data + 2, OEM); + TOWORD(d->data + 4, 3); // 3 = delegate + TOWORD(d->data + 6, 2); // count of type indices to follow + TOWORD(d->data + 8, key); // type of 'this', which is void* + TOWORD(d->data + 10, next); // function type +#else + d = debtyp_alloc(6); + TOWORD(d->data,LF_DELEGATE); + TOWORD(d->data + 2, key); // type of 'this', which is void* + TOWORD(d->data + 4, next); // function type +#endif + typidx = cv_debtyp(d); + break; + + case TYarray: + if (t->Tflags & TFsizeunknown) + size = 0; // don't complain if don't know size + else + size = type_size(t); + u = cv4_numericbytes(size); + if (config.fulltypes == CV4) + { + d = debtyp_alloc(6 + u + 1); + TOWORD(d->data,LF_ARRAY); + TOWORD(d->data + 2,next); + TOWORD(d->data + 4,I32 ? 0x12 : 0x11); // T_LONG : T_SHORT + d->data[6 + u] = 0; // no name + cv4_storenumeric(d->data + 6,size); + } + else + { + d = debtyp_alloc(10 + u + 1); + TOWORD(d->data,LF_ARRAY); + TOLONG(d->data + 2,next); + TOLONG(d->data + 6,I32 ? 0x12 : 0x11); // T_LONG : T_SHORT + d->data[10 + u] = 0; // no name + cv4_storenumeric(d->data + 10,size); + } + typidx = cv_debtyp(d); + break; + +#if TARGET_SEGMENTED + case TYffunc: + case TYfpfunc: + case TYf16func: + case TYfsfunc: + case TYnsysfunc: + case TYfsysfunc: +#endif + case TYnfunc: + case TYnpfunc: + case TYnsfunc: + case TYmfunc: + case TYjfunc: + case TYifunc: + { param_t *p; + unsigned nparam; + idx_t paramidx; + unsigned u; + + call = cv4_callconv(t); + paramidx = cv4_arglist(t,&nparam); + + // Construct an LF_PROCEDURE + if (config.fulltypes == CV4) + { d = debtyp_alloc(2 + 2 + 1 + 1 + 2 + 2); + TOWORD(d->data,LF_PROCEDURE); + TOWORD(d->data + 2,next); // return type + d->data[4] = call; + d->data[5] = 0; // reserved + TOWORD(d->data + 6,nparam); + TOWORD(d->data + 8,paramidx); + } + else + { d = debtyp_alloc(2 + 4 + 1 + 1 + 2 + 4); + TOWORD(d->data,LF_PROCEDURE); + TOLONG(d->data + 2,next); // return type + d->data[6] = call; + d->data[7] = 0; // reserved + TOWORD(d->data + 8,nparam); + TOLONG(d->data + 10,paramidx); + } + + typidx = cv_debtyp(d); + break; + } + + case TYstruct: + { int foo = t->Ttag->Stypidx; + typidx = cv4_struct(t->Ttag,0); + //printf("struct '%s' %x %x\n", t->Ttag->Sident, foo, typidx); + break; + } + + case TYenum: +#if SCPP + if (CPP) + typidx = cv4_enum(t->Ttag); + else +#endif + typidx = dttab4[t->Tnext->Tty]; + break; + +#if SCPP + case TYvtshape: + { unsigned count; + unsigned char *p; + unsigned char descriptor; + + count = 1 + list_nitems(t->Ttag->Sstruct->Svirtual); + d = debtyp_alloc(4 + ((count + 1) >> 1)); + p = d->data; + TOWORD(p,LF_VTSHAPE); + TOWORD(p + 2,count); + descriptor = I32 ? 0x55 : (LARGECODE ? 0x11 : 0); + memset(p + 4,descriptor,(count + 1) >> 1); + + typidx = cv_debtyp(d); + break; + } + + case TYref: + case TYnref: + case TYfref: + attribute |= 0x20; // indicate reference pointer + case TYmemptr: + tym = tybasic(tym_conv(t)); // convert to C data type + goto L1; // and try again +#endif +#if MARS + case TYref: + attribute |= 0x20; // indicate reference pointer + tym = TYnptr; // convert to C data type + goto L1; // and try again +#endif + case TYnullptr: + tym = TYnptr; + next = cv4_typidx(tsvoid); // rewrite as void* + t = tspvoid; + goto L1; + + default: +#ifdef DEBUG + WRTYxx(tym); +#endif + assert(0); + } + + // Add in const and/or volatile modifiers + if (tycv & (mTYconst | mTYimmutable | mTYvolatile)) + { unsigned modifier; + + modifier = (tycv & (mTYconst | mTYimmutable)) ? 1 : 0; + modifier |= (tycv & mTYvolatile) ? 2 : 0; + if (config.fulltypes == CV4) + { + d = debtyp_alloc(6); + TOWORD(d->data,LF_MODIFIER); + TOWORD(d->data + 2,modifier); + TOWORD(d->data + 4,typidx); + } + else + { + d = debtyp_alloc(10); + TOWORD(d->data,LF_MODIFIER); + TOLONG(d->data + 2,modifier); + TOLONG(d->data + 6,typidx); + } + typidx = cv_debtyp(d); + } + + assert(typidx); + return typidx; +} + +/****************************************** + * Write out symbol s. + */ + +STATIC void cv4_outsym(symbol *s) +{ + unsigned len; + type *t; + unsigned length; + unsigned u; + tym_t tym; + const char *id; + unsigned char __ss *debsym; + + //dbg_printf("cv4_outsym(%s)\n",s->Sident); + symbol_debug(s); +#if MARS + if (s->Sflags & SFLnodebug) + return; +#endif + t = s->Stype; + type_debug(t); + tym = tybasic(t->Tty); + if (tyfunc(tym) && s->Sclass != SCtypedef) + { int framedatum,targetdatum,fd; + char idfree; + idx_t typidx; + + if (s != funcsym_p) + return; +#if SCPP + if (CPP && isclassmember(s)) // if method + { Outbuffer buf; + + param_tostring(&buf,s->Stype); + buf.prependBytes(cpp_prettyident(s)); + id = alloca_strdup(buf.toString()); + } + else + { + id = prettyident(s); + } +#else + id = s->prettyIdent ? s->prettyIdent : s->Sident; +#endif + len = cv_stringbytes(id); + + // Length of record + length = 2 + 2 + 4 * 3 + intsize * 4 + 2 + cgcv.sz_idx + 1; + debsym = (unsigned char __ss *) alloca(length + len); + memset(debsym,0,length + len); + + // Symbol type + u = (s->Sclass == SCstatic) ? S_LPROC16 : S_GPROC16; + if (I32) + u += S_GPROC32 - S_GPROC16; + TOWORD(debsym + 2,u); + + if (config.fulltypes == CV4) + { + // Offsets + if (I32) + { TOLONG(debsym + 16,s->Ssize); // proc length + TOLONG(debsym + 20,startoffset); // debug start + TOLONG(debsym + 24,retoffset); // debug end + u = 28; // offset to fixup + } + else + { TOWORD(debsym + 16,s->Ssize); // proc length + TOWORD(debsym + 18,startoffset); // debug start + TOWORD(debsym + 20,retoffset); // debug end + u = 22; // offset to fixup + } + length += cv_namestring(debsym + u + intsize + 2 + cgcv.sz_idx + 1,id); + typidx = cv4_symtypidx(s); + TOIDX(debsym + u + intsize + 2,typidx); // proc type + debsym[u + intsize + 2 + cgcv.sz_idx] = tyfarfunc(tym) ? 4 : 0; + TOWORD(debsym,length - 2); + } + else + { + // Offsets + if (I32) + { TOLONG(debsym + 16 + cgcv.sz_idx,s->Ssize); // proc length + TOLONG(debsym + 20 + cgcv.sz_idx,startoffset); // debug start + TOLONG(debsym + 24 + cgcv.sz_idx,retoffset); // debug end + u = 28; // offset to fixup + } + else + { TOWORD(debsym + 16 + cgcv.sz_idx,s->Ssize); // proc length + TOWORD(debsym + 18 + cgcv.sz_idx,startoffset); // debug start + TOWORD(debsym + 20 + cgcv.sz_idx,retoffset); // debug end + u = 22; // offset to fixup + } + u += cgcv.sz_idx; + length += cv_namestring(debsym + u + intsize + 2 + 1,id); + typidx = cv4_symtypidx(s); + TOIDX(debsym + 16,typidx); // proc type + debsym[u + intsize + 2] = tyfarfunc(tym) ? 4 : 0; + TOWORD(debsym,length - 2); + } + + unsigned soffset = Offset(DEBSYM); + obj_write_bytes(SegData[DEBSYM],length,debsym); + + // Put out fixup for function start offset + reftoident(DEBSYM,soffset + u,s,0,CFseg | CFoff); + } + else + { targ_size_t base; + int reg; + unsigned fd; + unsigned idx1,idx2; + unsigned long value; + unsigned fixoff; + idx_t typidx; + + typidx = cv4_typidx(t); +#if MARS + id = s->prettyIdent ? s->prettyIdent : prettyident(s); +#else + id = prettyident(s); +#endif + len = strlen(id); + debsym = (unsigned char __ss *) alloca(39 + IDOHD + len); + switch (s->Sclass) + { + case SCparameter: + case SCregpar: + if (s->Sfl == FLreg) + { + s->Sfl = FLpara; + cv4_outsym(s); + s->Sfl = FLreg; + goto case_register; + } + base = Poff - BPoff; // cancel out add of BPoff + goto L1; + case SCauto: + if (s->Sfl == FLreg) + goto case_register; + case_auto: + base = Aoff; + L1: + TOWORD(debsym + 2,I32 ? S_BPREL32 : S_BPREL16); + if (config.fulltypes == CV4) + { TOOFFSET(debsym + 4,s->Soffset + base + BPoff); + TOIDX(debsym + 4 + intsize,typidx); + } + else + { TOOFFSET(debsym + 4 + cgcv.sz_idx,s->Soffset + base + BPoff); + TOIDX(debsym + 4,typidx); + } + length = 2 + 2 + intsize + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + break; + case SCbprel: + base = -BPoff; + goto L1; + case SCfastpar: + case SCregister: + if (s->Sfl != FLreg) + goto case_auto; + case SCpseudo: + case_register: + TOWORD(debsym + 2,S_REGISTER); + reg = cv_regnum(s); + TOIDX(debsym + 4,typidx); + TOWORD(debsym + 4 + cgcv.sz_idx,reg); + length = 2 * 3 + cgcv.sz_idx; + length += 1 + cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + break; + + case SCextern: + case SCcomdef: + // Common blocks have a non-zero Sxtrnnum and an UNKNOWN seg + if (!(s->Sxtrnnum && s->Sseg == UNKNOWN)) // if it's not really a common block + { + return; + } + /* FALL-THROUGH */ + case SCglobal: + case SCcomdat: + u = S_GDATA16; + goto L2; + case SCstatic: + case SClocstat: + u = S_LDATA16; + L2: + if (I32) + u += S_GDATA32 - S_GDATA16; + TOWORD(debsym + 2,u); + if (config.fulltypes == CV4) + { + fixoff = 4; + length = 2 + 2 + intsize + 2; + TOOFFSET(debsym + fixoff,s->Soffset); + TOWORD(debsym + fixoff + intsize,0); + TOIDX(debsym + length,typidx); + } + else + { + fixoff = 8; + length = 2 + 2 + intsize + 2; + TOOFFSET(debsym + fixoff,s->Soffset); + TOWORD(debsym + fixoff + intsize,0); // segment + TOIDX(debsym + 4,typidx); + } + length += cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + assert(length <= 40 + len); + + if (s->Sseg == UNKNOWN || s->Sclass == SCcomdat) // if common block + { + if (config.exe & EX_flat) + { + fd = 0x16; + idx1 = DGROUPIDX; + idx2 = s->Sxtrnnum; + } + else + { + fd = 0x26; + idx1 = idx2 = s->Sxtrnnum; + } + } +#if TARGET_SEGMENTED + else if (s->ty() & (mTYfar | mTYcs)) + { fd = 0x04; + idx1 = idx2 = SegData[s->Sseg]->segidx; + } +#endif + else + { fd = 0x14; + idx1 = DGROUPIDX; + idx2 = SegData[s->Sseg]->segidx; + } + /* Because of the linker limitations, the length cannot + * exceed 0x1000. + * See optlink\cv\cvhashes.asm + */ + assert(length <= 0x1000); + if (idx2 != 0) + { unsigned offset = Offset(DEBSYM); + obj_write_bytes(SegData[DEBSYM],length,debsym); + obj_long(DEBSYM,offset + fixoff,s->Soffset, + cgcv.LCFDpointer + fd,idx1,idx2); + } + return; + +#if 1 + case SCtypedef: + s->Stypidx = typidx; + goto L4; + + case SCstruct: + if (s->Sstruct->Sflags & STRnotagname) + return; + goto L4; + + case SCenum: +#if SCPP + if (CPP && s->Senum->SEflags & SENnotagname) + return; +#endif + L4: + // Output a 'user-defined type' for the tag name + TOWORD(debsym + 2,S_UDT); + TOIDX(debsym + 4,typidx); + length = 2 + 2 + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + list_subtract(&cgcv.list,s); + break; + + case SCconst: + // The only constants are enum members + value = el_tolongt(s->Svalue); + TOWORD(debsym + 2,S_CONST); + TOIDX(debsym + 4,typidx); + length = 4 + cgcv.sz_idx; + cv4_storenumeric(debsym + length,value); + length += cv4_numericbytes(value); + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + break; +#endif + default: + return; + } + assert(length <= 40 + len); + obj_write_bytes(SegData[DEBSYM],length,debsym); + } +} + +/****************************************** + * Write out any deferred symbols. + */ + +STATIC void cv_outlist() +{ + while (cgcv.list) + cv_outsym((Symbol *) list_pop(&cgcv.list)); +} + +/****************************************** + * Write out symbol table for current function. + */ + +STATIC void cv4_func(Funcsym *s) +{ + SYMIDX si; + int endarg; + + cv4_outsym(s); // put out function symbol + + // Put out local symbols + endarg = 0; + for (si = 0; si < globsym.top; si++) + { //printf("globsym.tab[%d] = %p\n",si,globsym.tab[si]); + symbol *sa = globsym.tab[si]; +#if MARS + if (endarg == 0 && sa->Sclass != SCparameter && sa->Sclass != SCfastpar) + { static unsigned short endargs[] = { 2,S_ENDARG }; + + obj_write_bytes(SegData[DEBSYM],sizeof(endargs),endargs); + endarg = 1; + } +#endif + cv4_outsym(sa); + } + + // Put out function return record + if (1) + { unsigned char sreturn[2+2+2+1+1+4]; + unsigned short flags; + unsigned char style; + tym_t ty; + tym_t tyret; + unsigned u; + + u = 2+2+1; + ty = tybasic(s->ty()); + + flags = tyrevfunc(ty) ? 0 : 1; + flags |= typfunc(ty) ? 0 : 2; + TOWORD(sreturn + 4,flags); + + tyret = tybasic(s->Stype->Tnext->Tty); + switch (tyret) + { + case TYvoid: + default: + style = 0; + break; + case TYbool: + case TYchar: + case TYschar: + case TYuchar: + sreturn[7] = 1; + sreturn[8] = 1; // AL + goto L1; + + case TYwchar_t: + case TYchar16: + case TYshort: + case TYushort: + goto case_ax; + + case TYint: + case TYuint: +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + case TYnullptr: + case TYnptr: + if (I32) + goto case_eax; + else + goto case_ax; + + case TYfloat: + case TYifloat: + if (config.exe & EX_flat) + goto case_st0; + case TYlong: + case TYulong: + case TYdchar: + if (I32) + goto case_eax; + else + goto case_dxax; + +#if TARGET_SEGMENTED + case TYfptr: + case TYhptr: + if (I32) + goto case_edxeax; + else + goto case_dxax; + + case TYvptr: + if (I32) + goto case_edxebx; + else + goto case_dxbx; +#endif + + case TYdouble: + case TYidouble: + case TYdouble_alias: + if (config.exe & EX_flat) + goto case_st0; + if (I32) + goto case_edxeax; + else + goto case_axbxcxdx; + + case TYllong: + case TYullong: + assert(I32); + goto case_edxeax; + + case TYldouble: + case TYildouble: + goto case_st0; + + case TYcfloat: + case TYcdouble: + case TYcldouble: + goto case_st01; + + case_ax: + sreturn[7] = 1; + sreturn[8] = 9; // AX + goto L1; + + case_eax: + sreturn[7] = 1; + sreturn[8] = 17; // EAX + goto L1; + + + case_dxax: + sreturn[7] = 2; + sreturn[8] = 11; // DX + sreturn[9] = 9; // AX + goto L1; + + case_dxbx: + sreturn[7] = 2; + sreturn[8] = 11; // DX + sreturn[9] = 12; // BX + goto L1; + + case_axbxcxdx: + sreturn[7] = 4; + sreturn[8] = 9; // AX + sreturn[9] = 12; // BX + sreturn[10] = 10; // CX + sreturn[11] = 11; // DX + goto L1; + + case_edxeax: + sreturn[7] = 2; + sreturn[8] = 19; // EDX + sreturn[9] = 17; // EAX + goto L1; + + case_edxebx: + sreturn[7] = 2; + sreturn[8] = 19; // EDX + sreturn[9] = 20; // EBX + goto L1; + + case_st0: + sreturn[7] = 1; + sreturn[8] = 128; // ST0 + goto L1; + + case_st01: + sreturn[7] = 2; + sreturn[8] = 128; // ST0 (imaginary) + sreturn[9] = 129; // ST1 (real) + goto L1; + + L1: + style = 1; + u += sreturn[7] + 1; + break; + } + sreturn[6] = style; + + TOWORD(sreturn,u); + TOWORD(sreturn + 2,S_RETURN); + obj_write_bytes(SegData[DEBSYM],u + 2,sreturn); + } + + // Put out end scope + { static unsigned short endproc[] = { 2,S_END }; + + obj_write_bytes(SegData[DEBSYM],sizeof(endproc),endproc); + } + + cv_outlist(); +} + +////////////////////////////////////////////////////////// + +/****************************************** + * Write out data to .OBJ file. + */ + +void cv_term() +{ unsigned u; + + //printf("cv_term(): debtyptop = %d\n",debtyptop); + cv_outlist(); + switch (config.fulltypes) + { + case CV4: + case CVSYM: + obj_write_bytes(SegData[DEBTYP],4,&cgcv.signature); + if (debtyptop != 1) + { + for (u = 0; u < debtyptop; u++) + { debtyp_t *d = debtyp[u]; + + obj_write_bytes(SegData[DEBTYP],2 + d->length,(char *)d + sizeof(unsigned)); +#if TERMCODE || _WIN32 || MARS + debtyp_free(d); +#endif + } + } + else if (debtyptop) + { +#if TERMCODE || _WIN32 || MARS + debtyp_free(debtyp[0]); +#endif + } + break; + +#if _WIN32 && TDB + case CVTDB: +#if 1 + tdb_term(); +#else + { unsigned char *buf; + unsigned char *p; + size_t len; + + // Calculate size of buffer + len = 4; + for (u = 0; u < debtyptop; u++) + { debtyp_t *d = debtyp[u]; + + len += 2 + d->length; + } + + // Allocate buffer + buf = malloc(len); + if (!buf) + err_nomem(); // out of memory + + // Fill the buffer + TOLONG(buf,cgcv.signature); + p = buf + 4; + for (u = 0; u < debtyptop; u++) + { debtyp_t *d = debtyp[u]; + + len = 2 + d->length; + memcpy(p,(char *)d + sizeof(unsigned),len); + p += len; + } + + tdb_write(buf,len,debtyptop); + } +#endif + break; +#endif + default: + assert(0); + } +#if TERMCODE || _WIN32 || MARS + util_free(debtyp); + debtyp = NULL; + vec_free(debtypvec); + debtypvec = NULL; +#endif +} + +/****************************************** + * Write out symbol table for current function. + */ + +#if TARGET_WINDOS +void cv_func(Funcsym *s) +{ +#if SCPP + if (errcnt) // if we had any errors + return; // don't bother putting stuff in .OBJ file +#endif + + //dbg_printf("cv_func('%s')\n",s->Sident); +#if MARS + if (s->Sflags & SFLnodebug) + return; +#else + if (CPP && s->Sfunc->Fflags & Fnodebug) // if don't generate debug info + return; +#endif + switch (config.fulltypes) + { + case CV4: + case CVSYM: + case CVTDB: + cv4_func(s); + break; + default: + assert(0); + } +} +#endif + +/****************************************** + * Write out symbol table for current function. + */ + +#if TARGET_WINDOS +void cv_outsym(symbol *s) +{ + //dbg_printf("cv_outsym('%s')\n",s->Sident); + symbol_debug(s); +#if MARS + if (s->Sflags & SFLnodebug) + return; +#endif + switch (config.fulltypes) + { + case CV4: + case CVSYM: + case CVTDB: + cv4_outsym(s); + break; + default: + assert(0); + } +} +#endif + +/****************************************** + * Return cv type index for a type. + */ + +unsigned cv_typidx(type *t) +{ unsigned ti; + + //dbg_printf("cv_typidx(%p)\n",t); + switch (config.fulltypes) + { + case CV4: + case CVTDB: + case CVSYM: + ti = cv4_typidx(t); + break; + default: +#ifdef DEBUG + printf("fulltypes = %d\n",config.fulltypes); +#endif + assert(0); + } + return ti; +} + +#endif // !SPP + + diff --git a/backend/cgcv.h b/backend/cgcv.h new file mode 100644 index 00000000..9af3727c --- /dev/null +++ b/backend/cgcv.h @@ -0,0 +1,76 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/* Header for cgcv.c */ + +#ifndef CGCV_H +#define CGCV_H +//#pragma once + +extern char *ftdbname; + +void cv_init ( void ); +unsigned cv_typidx ( type *t ); +void cv_outsym ( Symbol *s ); +void cv_func ( Symbol *s ); +void cv_term ( void ); +unsigned long cv4_struct(Classsym *,int); + + +/* =================== Added for MARS compiler ========================= */ + +typedef unsigned long idx_t; // type of type index + +/* Data structure for a type record */ + +#pragma pack(1) + +typedef struct DEBTYP_T +{ + unsigned prev; // previous debtyp_t with same hash + unsigned short length; // length of following array + unsigned char data[2]; // variable size array +} debtyp_t; + +#pragma pack() + +struct Cgcv +{ + long signature; + symlist_t list; // deferred list of symbols to output + idx_t deb_offset; // offset added to type index + unsigned sz_idx; // size of stored type index + int LCFDoffset; + int LCFDpointer; + int FD_code; // frame for references to code +}; + +extern Cgcv cgcv; + +debtyp_t * debtyp_alloc(unsigned length); +int cv_stringbytes(const char *name); +inline unsigned cv4_numericbytes(targ_size_t value); +void cv4_storenumeric(unsigned char *p,targ_size_t value); +idx_t cv_debtyp ( debtyp_t *d ); +int cv_namestring ( unsigned char *p , const char *name ); +unsigned cv4_typidx(type *t); +idx_t cv4_arglist(type *t,unsigned *pnparam); +unsigned char cv4_callconv(type *t); + +#define TOIDX(a,b) ((cgcv.sz_idx == 4) ? TOLONG(a,b) : TOWORD(a,b)) + +#define DEBSYM 5 /* segment of symbol info */ +#define DEBTYP 6 /* segment of type info */ + + +#endif + diff --git a/backend/cgelem.c b/backend/cgelem.c new file mode 100644 index 00000000..b72a8f89 --- /dev/null +++ b/backend/cgelem.c @@ -0,0 +1,4522 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include "cc.h" +#include "oper.h" +#include "global.h" +#include "el.h" +#include "dt.h" +#include "code.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +extern void error(const char *filename, unsigned linnum, const char *format, ...); + +STATIC elem * optelem(elem *,HINT); +STATIC elem * elarray(elem *e); +STATIC elem * eldiv(elem *); + +CEXTERN elem * evalu8(elem *); + +static int expgoal; +static int again; +static int cgelem_goal; + +/***************************** + */ + +STATIC elem * cgel_lvalue(elem *e) +{ elem *e1; + elem *e11; + int op; + + //printf("cgel_lvalue()\n"); elem_print(e); + e1 = e->E1; + op = e->Eoper; + if (e1->Eoper == OPbit) + { + e11 = e1->E1; + + if (e11->Eoper == OPcomma) + { + // Replace (((e,v) bit x) op e2) with (e,((v bit x) op e2)) + e1->E1 = e11->E2; + e11->E2 = e; + e11->Ety = e->Ety; + e11->ET = e->ET; + e = e11; + goto L1; + } + else if (OTassign(e11->Eoper)) + { + // Replace (((e op= v) bit x) op e2) with ((e op= v) , ((e bit x) op e2)) + e1->E1 = el_copytree(e11->E1); + e = el_bin(OPcomma,e->Ety,e11,e); + goto L1; + } + } + else if (e1->Eoper == OPcomma) + { + // Replace ((e,v) op e2) with (e,(v op e2)) + e->Eoper = OPcomma; + e1->Eoper = op; + e1->Ety = e->Ety; + e1->ET = e->ET; + e->E1 = e1->E1; + e1->E1 = e1->E2; + e1->E2 = e->E2; + e->E2 = e1; + goto L1; + } + else if (OTassign(e1->Eoper)) + { + // Replace ((e op= v) op e2) with ((e op= v) , (e op e2)) + e->E1 = el_copytree(e1->E1); + e = el_bin(OPcomma,e->Ety,e1,e); + L1: + e = optelem(e,TRUE); + } + return e; +} + + +/****************************** + * Scan down commas. + */ + +STATIC elem * elscancommas(elem *e) +{ + while (e->Eoper == OPcomma +#if SCPP + || e->Eoper == OPinfo +#endif + ) + e = e->E2; + return e; +} + +/************************* + * Return TRUE if elem is the constant 1. + */ + +int elemisone(elem *e) +{ + if (e->Eoper == OPconst) + { switch (tybasic(e->Ety)) + { + case TYchar: + case TYuchar: + case TYschar: + case TYchar16: + case TYshort: + case TYushort: + case TYint: + case TYuint: + case TYlong: + case TYulong: + case TYllong: + case TYullong: + case TYnullptr: +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYhptr: + case TYfptr: + case TYvptr: +#endif + case TYnptr: + case TYbool: + case TYwchar_t: + case TYdchar: + if (el_tolong(e) != 1) + goto nomatch; + break; + case TYldouble: + case TYildouble: + if (e->EV.Vldouble != 1) + goto nomatch; + break; + case TYdouble: + case TYidouble: + case TYdouble_alias: + if (e->EV.Vdouble != 1) + goto nomatch; + break; + case TYfloat: + case TYifloat: + if (e->EV.Vfloat != 1) + goto nomatch; + break; + default: + goto nomatch; + } + return TRUE; + } + +nomatch: + return FALSE; +} + +/************************* + * Return TRUE if elem is the constant -1. + */ + +int elemisnegone(elem *e) +{ + if (e->Eoper == OPconst) + { switch (tybasic(e->Ety)) + { + case TYchar: + case TYuchar: + case TYschar: + case TYchar16: + case TYshort: + case TYushort: + case TYint: + case TYuint: + case TYlong: + case TYulong: + case TYllong: + case TYullong: + case TYnullptr: + case TYnptr: +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYhptr: + case TYfptr: + case TYvptr: +#endif + case TYbool: + case TYwchar_t: + case TYdchar: + if (el_tolong(e) != -1) + goto nomatch; + break; + case TYldouble: + //case TYildouble: + if (e->EV.Vldouble != -1) + goto nomatch; + break; + case TYdouble: + //case TYidouble: + case TYdouble_alias: + if (e->EV.Vdouble != -1) + goto nomatch; + break; + case TYfloat: + //case TYifloat: + if (e->EV.Vfloat != -1) + goto nomatch; + break; + default: + goto nomatch; + } + return TRUE; + } + +nomatch: + return FALSE; +} + +/********************************** + * Swap relational operators (like if we swapped the leaves). + */ + +unsigned swaprel(unsigned op) +{ + assert(op < (unsigned) OPMAX); + if (OTrel(op)) + op = rel_swap(op); + return op; +} + +/************************** + * Replace e1 by t=e1, replace e2 by t. + */ + +STATIC void fixside(elem **pe1,elem **pe2) +{ tym_t tym; + elem *tmp,*e2; + + tym = (*pe1)->Ety; + tmp = el_alloctmp(tym); + *pe1 = el_bin(OPeq,tym,tmp,*pe1); + e2 = el_copytree(tmp); + el_free(*pe2); + *pe2 = e2; +} + + + +/**************************** + * Compute the 'cost' of evaluating a elem. Could be done + * as Sethi-Ullman numbers, but that ain't worth the bother. + * We'll fake it. + */ + +#define cost(n) (opcost[n->Eoper]) + +/******************************* + * For floating point expressions, the cost would be the number + * of registers in the FPU stack needed. + */ + +int fcost(elem *e) +{ + int cost; + int cost1; + int cost2; + + //printf("fcost()\n"); + switch (e->Eoper) + { + case OPadd: + case OPmin: + case OPmul: + case OPdiv: + cost1 = fcost(e->E1); + cost2 = fcost(e->E2); + cost = cost2 + 1; + if (cost1 > cost) + cost = cost1; + break; + + case OPcall: + case OPucall: + cost = 8; + break; + + case OPneg: + case OPabs: + return fcost(e->E1); + + case OPvar: + case OPconst: + case OPind: + default: + return 1; + } + if (cost > 8) + cost = 8; + return cost; +} + +/******************************* + * The lvalue of an op= is a conversion operator. Since the code + * generator cannot handle this, we will have to fix it here. The + * general strategy is: + * (conv) e1 op= e2 => e1 = (conv) e1 op e2 + * Since e1 can only be evaluated once, if it is an expression we + * must use a temporary. + */ + +STATIC elem *fixconvop(elem *e) +{ elem *e1,*e2,*ed,*T; + elem *ex; + elem **pe; + unsigned cop,icop,op; + tym_t tycop,tym,tyme; + static unsigned char invconvtab[] = + { + OPbool, // OPb_8 + OPs32_d, // OPd_s32 + OPd_s32, // OPs32_d + OPs16_d, /* OPd_s16 */ + OPd_s16, /* OPs16_d */ + OPu16_d, // OPd_u16 + OPd_u16, // OPu16_d + OPu32_d, /* OPd_u32 */ + OPd_u32, /* OPu32_d */ + OPs64_d, // OPd_s64 + OPd_s64, // OPs64_d + OPu64_d, // OPd_u64 + OPd_u64, // OPu64_d + OPf_d, // OPd_f + OPd_f, // OPf_d + OP32_16, // OPs16_32 + OP32_16, // OPu16_32 + OPs16_32, // OP32_16 + OP16_8, // OPu8_16 + OP16_8, // OPs8_16 + OPs8_16, // OP16_8 + OP64_32, // OPu32_64 + OP64_32, // OPs32_64 + OPs32_64, // OP64_32 + OP128_64, // OPu64_128 + OP128_64, // OPs64_128 + OPs64_128, // OP128_64 +#if TARGET_SEGMENTED + 0, /* OPvp_fp */ + 0, /* OPcvp_fp */ + OPnp_fp, /* OPoffset */ + OPoffset, /* OPnp_fp */ + OPf16p_np, /* OPnp_f16p */ + OPnp_f16p, /* OPf16p_np */ +#endif + OPd_ld, // OPld_d + OPld_d, // OPd_ld + OPu64_d, // OPld_u64 + }; + +//dbg_printf("fixconvop before\n"); +//elem_print(e); + assert(arraysize(invconvtab) == CNVOPMAX - CNVOPMIN + 1); + assert(e); + tyme = e->Ety; + cop = e->E1->Eoper; /* the conversion operator */ + assert(cop <= CNVOPMAX); + + if (e->E1->E1->Eoper == OPcomma) + { /* conv(a,b) op= e2 + * => + * a, (conv(b) op= e2) + */ + elem *ecomma = e->E1->E1; + e->E1->E1 = ecomma->E2; + e->E1->E1->Ety = ecomma->Ety; + ecomma->E2 = e; + ecomma->Ety = e->Ety; + return optelem(ecomma, TRUE); + } + + tycop = e->E1->Ety; + tym = e->E1->E1->Ety; + e->E1 = el_selecte1(e->E1); /* dump it for now */ + e1 = e->E1; + e1->Ety = tym; + e2 = e->E2; + assert(e1 && e2); + /* select inverse conversion operator */ + icop = invconvtab[convidx(cop)]; + + /* First, let's see if we can just throw it away. */ + /* (unslng or shtlng) e op= e2 => e op= (lngsht) e2 */ + if (OTwid(e->Eoper) && + (cop == OPs16_32 || cop == OPu16_32 || + cop == OPu8_16 || cop == OPs8_16)) + { if (e->Eoper != OPshlass && e->Eoper != OPshrass && e->Eoper != OPashrass) + e->E2 = el_una(icop,tym,e2); +//dbg_printf("after1\n"); +//elem_print(e); + return e; + } + + /* Oh well, just split up the op and the =. */ + op = opeqtoop(e->Eoper); /* convert op= to op */ + e->Eoper = OPeq; /* just plain = */ + ed = el_copytree(e1); /* duplicate e1 */ + /* make: e1 = (icop) ((cop) ed op e2)*/ + e->E2 = el_una(icop,e1->Ety, + el_bin(op,tycop,el_una(cop,tycop,ed), + e2)); + +//printf("after1\n"); +//elem_print(e); + + if (op == OPdiv && + tybasic(e2->Ety) == TYcdouble) + { + if (tycop == TYdouble) + { + e->E2->E1->Ety = tybasic(e2->Ety); + e->E2->E1 = el_una(OPc_r, tycop, e->E2->E1); + } + else if (tycop == TYidouble) + { + e->E2->E1->Ety = tybasic(e2->Ety); + e->E2->E1 = el_una(OPc_i, tycop, e->E2->E1); + } + } + + if (op == OPdiv && + tybasic(e2->Ety) == TYcfloat) + { + if (tycop == TYfloat) + { + e->E2->E1->Ety = tybasic(e2->Ety); + e->E2->E1 = el_una(OPc_r, tycop, e->E2->E1); + } + else if (tycop == TYifloat) + { + e->E2->E1->Ety = tybasic(e2->Ety); + e->E2->E1 = el_una(OPc_i, tycop, e->E2->E1); + } + } + + /* Handle case of multiple conversion operators on lvalue */ + /* (such as (intdbl 8int char += double)) */ + ex = e; + pe = &e; + while (OTconv(ed->Eoper)) + { unsigned copx = ed->Eoper; + tym_t tymx; + + icop = invconvtab[convidx(copx)]; + tymx = ex->E1->E1->Ety; + ex->E1 = el_selecte1(ex->E1); // dump it for now + e1 = ex->E1; + e1->Ety = tymx; + ex->E2 = el_una(icop,e1->Ety,ex->E2); + ex->Ety = tymx; + tym = tymx; + + if (ex->Ety != tyme) + { *pe = el_una(copx, ed->Ety, ex); + pe = &(*pe)->E1; + } + + ed = ed->E1; + } +//dbg_printf("after2\n"); +//elem_print(e); + + e->Ety = tym; + if (tym != tyme && + !(tyintegral(tym) && tyintegral(tyme) && tysize(tym) == tysize(tyme))) + e = el_una(cop, tyme, e); + + if (ed->Eoper == OPbit) /* special handling */ + { + ed = ed->E1; + e1 = e1->E1; /* go down one */ + } + /* If we have a *, must assign a temporary to the expression */ + /* underneath it (even if it's a var, as e2 may modify the var). */ + if (ed->Eoper == OPind) + { T = el_alloctmp(ed->E1->Ety); /* make temporary */ + ed->E1 = el_bin(OPeq,T->Ety,T,ed->E1); /* ed: *(T=e) */ + el_free(e1->E1); + e1->E1 = el_copytree(T); + } +//dbg_printf("after3\n"); +//elem_print(e); + return e; +} + +STATIC elem * elerr(elem *e) +{ +#ifdef DEBUG + elem_print(e); +#endif + assert(0); + return (elem *)NULL; +} + +/* For ops with no optimizations */ + +STATIC elem * elzot(elem *e) +{ return e; } + +/**************************** + */ + +STATIC elem * elstring(elem *e) +{ +#if 0 // now handled by el_convert() + if (!OPTIMIZER) + el_convstring(e); // convert string to OPrelconst +#endif + return e; +} + +/************************ + */ + +#if TX86 + +/************************ + * Convert far pointer to pointer. + */ + +STATIC void eltonear(elem **pe) +{ tym_t ty; + elem *e = *pe; + + ty = e->E1->Ety; + e = el_selecte1(e); + e->Ety = ty; + *pe = optelem(e,TRUE); +} + +/************************ + */ + +STATIC elem * elstrcpy(elem *e) +{ tym_t ty; + + elem_debug(e); + switch (e->E2->Eoper) + { +#if TARGET_SEGMENTED + case OPnp_fp: + if (OPTIMIZER) + { + eltonear(&e->E2); + e = optelem(e,TRUE); + } + break; +#endif + case OPstring: + /* Replace strcpy(e1,"string") with memcpy(e1,"string",sizeof("string")) */ +#if 0 + // As memcpy + e->Eoper = OPmemcpy; + elem *en = el_long(TYsize_t, strlen(e->E2->EV.ss.Vstring) + 1); + e->E2 = el_bin(OPparam,TYvoid,e->E2,en); +#else + // As streq + e->Eoper = OPstreq; + type *t = type_allocn(TYarray, tschar); + t->Tdim = strlen(e->E2->EV.ss.Vstring) + 1; + e->ET = t; + t->Tcount++; + e->E1 = el_una(OPind,TYstruct,e->E1); + e->E2 = el_una(OPind,TYstruct,e->E2); + + e = el_bin(OPcomma,e->Ety,e,el_copytree(e->E1->E1)); + if (el_sideeffect(e->E2)) + fixside(&e->E1->E1->E1,&e->E2); +#endif + e = optelem(e,TRUE); + break; + } + return e; +} + +/************************ + */ + +STATIC elem * elstrcmp(elem *e) +{ + elem_debug(e); + if (OPTIMIZER) + { +#if TARGET_SEGMENTED + if (e->E1->Eoper == OPnp_fp) + eltonear(&e->E1); +#endif + switch (e->E2->Eoper) + { +#if TARGET_SEGMENTED + case OPnp_fp: + eltonear(&e->E2); + break; +#endif + + case OPstring: + // Replace strcmp(e1,"string") with memcmp(e1,"string",sizeof("string")) + e->Eoper = OPparam; + e = el_bin(OPmemcmp,e->Ety,e,el_long(TYint,strlen(e->E2->EV.ss.Vstring) + 1)); + e = optelem(e,TRUE); + break; + } + } + return e; +} + +/**************************** + * For OPmemcmp, OPmemcpy, OPmemset. + */ + +STATIC elem * elmemxxx(elem *e) +{ + elem_debug(e); + if (OPTIMIZER) + { elem *ex; + + ex = e->E1; + switch (e->Eoper) + { case OPmemcmp: +#if TARGET_SEGMENTED + if (ex->E1->Eoper == OPnp_fp) + eltonear(&ex->E1); + if (ex->E2->Eoper == OPnp_fp) + eltonear(&ex->E2); +#endif + break; + + case OPmemset: +#if TARGET_SEGMENTED + if (ex->Eoper == OPnp_fp) + eltonear(&ex); + else +#endif + { + // lvalue OPmemset (nbytes param value) + elem *enbytes = e->E2->E1; + elem *evalue = e->E2->E2; + +#if MARS && TX86 + if (enbytes->Eoper == OPconst && evalue->Eoper == OPconst + /* && tybasic(e->E1->Ety) == TYstruct*/) + { tym_t tym; + tym_t ety; + int nbytes = el_tolong(enbytes); + targ_llong value = el_tolong(evalue); + elem *e1 = e->E1; + elem *tmp; + + if (e1->Eoper == OPcomma || OTassign(e1->Eoper)) + return cgel_lvalue(e); // replace (e,v)op=e2 with e,(v op= e2) + + switch (nbytes) + { + case CHARSIZE: tym = TYchar; goto L1; + case SHORTSIZE: tym = TYshort; goto L1; + case LONGSIZE: tym = TYlong; goto L1; +#if LONGLONG + case LLONGSIZE: if (intsize == 2) + goto Ldefault; + tym = TYllong; goto L1; +#endif + L1: + ety = e->Ety; + memset(&value, value & 0xFF, sizeof(value)); + evalue->EV.Vullong = value; + evalue->Ety = tym; + e->Eoper = OPeq; + e->Ety = (e->Ety & ~mTYbasic) | tym; + if (tybasic(e1->Ety) == TYstruct) + e1->Ety = tym; + else + e->E1 = el_una(OPind, tym, e1); + tmp = el_same(&e->E1); + tmp = el_una(OPaddr, ety, tmp); + e->E2->Ety = tym; + e->E2 = el_selecte2(e->E2); + e = el_combine(e, tmp); + e = optelem(e,TRUE); + break; + + default: + Ldefault: + break; + } + } +#endif + } + break; + + case OPmemcpy: +#if TARGET_SEGMENTED + if (ex->Eoper == OPnp_fp) + eltonear(&e->E1); +#endif + ex = e->E2; +#if TARGET_SEGMENTED + if (ex->E1->Eoper == OPnp_fp) + eltonear(&ex->E1); +#endif + if (ex->E2->Eoper == OPconst) + { + if (!boolres(ex->E2)) + { // Copying 0 bytes, so remove memcpy + e->E2 = e->E1; + e->E1 = ex->E1; + ex->E1 = NULL; + e->Eoper = OPcomma; + el_free(ex); + return optelem(e, TRUE); + } +#if 1 + // Convert OPmemcpy to OPstreq + e->Eoper = OPstreq; + type *t = type_allocn(TYarray, tschar); + t->Tdim = el_tolong(ex->E2); + e->ET = t; + t->Tcount++; + e->E1 = el_una(OPind,TYstruct,e->E1); + e->E2 = el_una(OPind,TYstruct,ex->E1); + ex->E1 = NULL; + el_free(ex); + ex = el_copytree(e->E1->E1); +#if TARGET_SEGMENTED + if (tysize(e->Ety) > tysize(ex->Ety)) + ex = el_una(OPnp_fp,e->Ety,ex); +#endif + e = el_bin(OPcomma,e->Ety,e,ex); + if (el_sideeffect(e->E2)) + fixside(&e->E1->E1->E1,&e->E2); + return optelem(e,TRUE); +#endif + } + break; + + default: + assert(0); + } + } + return e; +} + +#endif + +/*********************** + * + # (combine offsets with addresses) + * / \ => | + * # c v,c + * | + * v + */ + +STATIC elem * eladd(elem *e) +{ elem *e1,*e2; + int sz; + + //printf("eladd(%p)\n",e); + targ_size_t ptrmask = ~(targ_size_t)0; + if (NPTRSIZE <= 4) + ptrmask = 0xFFFFFFFF; +L1: + e1 = e->E1; + e2 = e->E2; + if (e2->Eoper == OPconst) + { +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (e1->Eoper == OPrelconst && e1->EV.sp.Vsym->Sfl == FLgot) + goto ret; +#endif + if (e1->Eoper == OPrelconst /* if (&v) + c */ + || e1->Eoper == OPstring + ) + { + e1->EV.sp.Voffset += e2->EV.Vpointer; + e1->EV.sp.Voffset &= ptrmask; + e = el_selecte1(e); + goto ret; + } + } + else if (e1->Eoper == OPconst) + { +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (e2->Eoper == OPrelconst && e2->EV.sp.Vsym->Sfl == FLgot) + goto ret; +#endif + if (e2->Eoper == OPrelconst /* if c + (&v) */ + || e2->Eoper == OPstring + ) + { + e2->EV.sp.Voffset += e1->EV.Vpointer; + e2->EV.sp.Voffset &= ptrmask; + e = el_selecte2(e); + goto ret; + } + } + + if (!OPTIMIZER) + goto ret; + + /* Replace ((e + &v) + c) with (e + (&v+c)) */ + if (e2->Eoper == OPconst && e1->Eoper == OPadd && + (e1->E2->Eoper == OPrelconst || e1->E2->Eoper == OPstring)) + { + e1->E2->EV.sp.Voffset += e2->EV.Vpointer; + e1->E2->EV.sp.Voffset &= ptrmask; + e = el_selecte1(e); + goto L1; + } + /* Replace ((e + c) + &v) with (e + (&v+c)) */ + else if ((e2->Eoper == OPrelconst || e2->Eoper == OPstring) && + e1->Eoper == OPadd && cnst(e1->E2)) + { + e2->EV.sp.Voffset += e1->E2->EV.Vpointer; + e2->EV.sp.Voffset &= ptrmask; + e->E1 = el_selecte1(e1); + goto L1; /* try and find some more */ + } + /* Replace (e1 + -e) with (e1 - e) */ + else if (e2->Eoper == OPneg) + { e->E2 = el_selecte1(e2); + e->Eoper = OPmin; + again = 1; + return e; + } + /* Replace (-v + e) with (e + -v) */ + else if (e1->Eoper == OPneg && OTleaf(e1->E1->Eoper)) + { e->E1 = e2; + e->E2 = e1; /* swap leaves */ + goto L1; + } + /* Replace ((e - e2) + e2) with (e) */ + /* The optimizer sometimes generates this case */ + else if (!tyfloating(e->Ety) && /* no floating bugs */ + e1->Eoper == OPmin && + el_match(e1->E2,e2) && + !el_sideeffect(e2)) + { tym_t tym = e->Ety; + + e = el_selecte1(el_selecte1(e)); + e->Ety = tym; /* retain original type */ + return e; + } + /* Replace ((e - #v+c1) + #v+c2) with ((e - c1) + c2) */ + else if (e2->Eoper == OPrelconst && + e1->Eoper == OPmin && + e1->E2->Eoper == OPrelconst && + e1->E2->EV.sp.Vsym == e2->EV.sp.Vsym) + { e2->Eoper = OPconst; + e2->Ety = TYint; + e1->Ety = e1->E1->Ety; + e1->E2->Eoper = OPconst; + e1->E2->Ety = TYint; + { +#if TARGET_SEGMENTED + /* Watch out for pointer types changing, requiring a conversion */ + tym_t ety,e11ty; + + ety = tybasic(e->Ety); + e11ty = tybasic(e1->E1->Ety); + if (typtr(ety) && typtr(e11ty) && + tysize[ety] != tysize[e11ty]) + { + e = el_una((tysize[ety] > tysize[e11ty]) ? OPnp_fp : OPoffset, + e->Ety,e); + e->E1->Ety = e1->Ety; + } +#endif + } + again = 1; + return e; + } + /* Replace (e + e) with (e * 2) */ + else if (el_match(e1,e2) && !el_sideeffect(e1) && !tyfloating(e->Ety)) + { + e->Eoper = OPmul; + el_free(e2); + e->E2 = el_long(e->Ety,2); + again = 1; + return e; + } + // Replace ((e11 + c) + e2) with ((e11 + e2) + c) + if (e1->Eoper == OPadd && e1->E2->Eoper == OPconst && + (e2->Eoper == OPvar || !OTleaf(e2->Eoper)) && + tysize(e1->Ety) == tysize(e2->Ety) && + tysize(e1->E2->Ety) == tysize(e2->Ety)) + { + e->E2 = e1->E2; + e1->E2 = e2; + e1->Ety = e->Ety; + goto ret; + } + + // Replace ((e11 - e12) + e2) with ((e11 + e2) - e12) + // (this should increase the number of LEA possibilities) + sz = tysize(e->Ety); + if (e1->Eoper == OPmin && + tysize(e1->Ety) == sz && + tysize(e2->Ety) == sz && + tysize(e1->E1->Ety) == sz && + tysize(e1->E2->Ety) == sz && + !tyfloating(e->Ety) + ) + { + e->Eoper = OPmin; + e->E2 = e1->E2; + e1->E2 = e2; + e1->Eoper = OPadd; + } + +ret: + return e; +} + + +/************************ + * Multiply (for OPmul && OPmulass) + * e * (c**2) => e << c ;replace multiply by power of 2 with shift + */ + +STATIC elem * elmul(elem *e) +{ + tym_t tym = e->Ety; + + if (OPTIMIZER) + { + // Replace -a*-b with a*b. + // This is valid for all floating point types as well as integers. + if (tyarithmetic(tym) && e->E2->Eoper == OPneg && e->E1->Eoper == OPneg) + { + e->E1 = el_selecte1(e->E1); + e->E2 = el_selecte1(e->E2); + } + } + + elem *e2 = e->E2; + if (e2->Eoper == OPconst) /* try to replace multiplies with shifts */ + { + if (OPTIMIZER) + { + elem *e1 = e->E1; + unsigned op1 = e1->Eoper; + + if (tyintegral(tym) && // skip floating types + OTbinary(op1) && + e1->E2->Eoper == OPconst + ) + { + /* Attempt to replace ((e + c1) * c2) with (e * c2 + (c1 * c2)) + * because the + can be frequently folded out (merged into an + * array offset, for example. + */ + if (op1 == OPadd) + { + e->Eoper = OPadd; + e1->Eoper = OPmul; + e->E2 = el_bin(OPmul,tym,e1->E2,e2); + e1->E2 = el_copytree(e2); + again = 1; + return e; + } + + // ((e << c1) * c2) => e * ((1 << c1) * c2) + if (op1 == OPshl) + { + e2->EV.Vullong *= (targ_ullong)1 << el_tolong(e1->E2); + e1->E2->EV.Vullong = 0; + again = 1; + return e; + } + } + + if (elemisnegone(e2)) + { + e->Eoper = (e->Eoper == OPmul) ? OPneg : OPnegass; + e->E2 = NULL; + el_free(e2); + return e; + } + } + + if (tyintegral(tym)) + { int i; + + i = ispow2(el_tolong(e2)); /* check for power of 2 */ + if (i != -1) /* if it is a power of 2 */ + { e2->EV.Vint = i; + e2->Ety = TYint; + e->Eoper = (e->Eoper == OPmul) /* convert to shift left */ + ? OPshl : OPshlass; + again = 1; + return e; + } + else if (el_allbits(e2,-1)) + goto Lneg; + } + else if (elemisnegone(e2) && !tycomplex(e->E1->Ety)) + { + goto Lneg; + } + } + return e; + +Lneg: + e->Eoper = (e->Eoper == OPmul) /* convert to negate */ + ? OPneg : OPnegass; + el_free(e->E2); + e->E2 = NULL; + again = 1; + return e; +} + +/************************ + * Subtract + * - + + * / \ => / \ (propagate minuses) + * e c e -c + */ + +STATIC elem * elmin(elem *e) +{ elem *e2; + +L1: + e2 = e->E2; + + if (OPTIMIZER) + { + elem *e1; + tym_t tym; + + tym = e->Ety; + e1 = e->E1; + if (e2->Eoper == OPrelconst) + { if (e1->Eoper == OPrelconst && e1->EV.sp.Vsym == e2->EV.sp.Vsym) + { e->Eoper = OPconst; + e->EV.Vint = e1->EV.sp.Voffset - e2->EV.sp.Voffset; + el_free(e1); + el_free(e2); + return e; + } + } + + /* Convert subtraction of long pointers to subtraction of integers */ + if (tyfv(e2->Ety) && tyfv(e1->Ety)) + { e->E1 = el_una(OP32_16,tym,e1); + e->E2 = el_una(OP32_16,tym,e2); + return optelem(e,TRUE); + } + + /* Replace (0 - e2) with (-e2) */ + if (cnst(e1) && !boolres(e1)) + { el_free(e1); + e->E1 = e2; + e->E2 = NULL; + e->Eoper = OPneg; + return optelem(e,TRUE); + } + + /* Replace (e - e) with (0) */ + if (el_match(e1,e2) && !el_sideeffect(e1)) + { el_free(e); + e = el_calloc(); + e->Eoper = OPconst; + e->Ety = tym; + return e; + } + + /* Replace (e1 + c1) - (e2 + c2) with (e1 - e2) + (c1 - c2), but not */ + /* for floating or far or huge pointers! */ + if (e1->Eoper == OPadd && e2->Eoper == OPadd && + cnst(e1->E2) && cnst(e2->E2) && + (tyintegral(tym) || tybasic(tym) == TYjhandle || tybasic(tym) == TYnptr +#if TARGET_SEGMENTED + || tybasic(tym) == TYsptr +#endif + )) + { elem *tmp; + + e->Eoper = OPadd; + e1->Eoper = OPmin; + e2->Eoper = OPmin; + tmp = e1->E2; + e1->E2 = e2->E1; + e2->E1 = tmp; + return optelem(e,TRUE); + } + } + +#if TX86 && !(MARS) + if (tybasic(e2->Ety) == TYhptr && tybasic(e->E1->Ety) == TYhptr) + { // Convert to _aNahdiff(e1,e2) + static symbol hdiff = SYMBOLY(FLfunc,mBX|mCX|mSI|mDI|mBP|mES,"_aNahdiff",0); + + if (LARGECODE) + hdiff.Sident[2] = 'F'; + hdiff.Stype = tsclib; + e->Eoper = OPcall; + e->E2 = el_bin(OPparam,TYint,e2,e->E1); + e->E1 = el_var(&hdiff); + return e; + } +#endif + + /* Disallow the optimization on doubles. The - operator is not */ + /* rearrangable by K+R, and can cause floating point problems if */ + /* converted to an add ((a + 1.0) - 1.0 shouldn't be folded). */ + if (cnst(e2) && !tyfloating(e2->Ety)) + { e->E2 = el_una(OPneg,e2->Ety,e2); + e->Eoper = OPadd; + return optelem(e,TRUE); + } + return e; +} + +/***************************** + * Attempt to 'shrink' bitwise expressions. + * Good for & | ^. + * This should be expanded to include long type stuff. + */ + +STATIC elem * elbitwise(elem *e) +{ elem *e1,*e2; + targ_short i; + targ_ulong ul; + int op; + unsigned sz; + + e2 = e->E2; + e1 = e->E1; + op = e1->Eoper; + if (e2->Eoper == OPconst) + { + sz = tysize(e2->Ety); + switch (sz) + { + tym_t tym; + case CHARSIZE: + /* Replace (c & 0xFF) with (c) */ + if (OPTIMIZER && e2->EV.Vuchar == CHARMASK) + { + L1: + switch (e->Eoper) + { case OPand: /* (c & 0xFF) => (c) */ + return el_selecte1(e); + case OPor: /* (c | 0xFF) => (0xFF) */ + return el_selecte2(e); + case OPxor: /* (c ^ 0xFF) => (~c) */ + tym = e->Ety; + return el_una(OPcom,tym,el_selecte1(e)); + default: + assert(0); + } + } + break; + + case LONGSIZE: + if (!OPTIMIZER) + break; + ul = e2->EV.Vulong; + + if (ul == 0xFFFFFFFF) /* if e1 & 0xFFFFFFFF */ + goto L1; + /* (x >> 16) & 0xFFFF => ((unsigned long)x >> 16) */ + if (ul == 0xFFFF && e->Eoper == OPand && (op == OPshr || op == OPashr) && + e1->E2->Eoper == OPconst && el_tolong(e1->E2) == 16) + { elem *e11 = e1->E1; + + e11->Ety = touns(e11->Ety) | (e11->Ety & ~mTYbasic); + goto L1; + } + + /* Replace (L & 0x0000XXXX) with (unslng)((lngsht) & 0xXXXX) */ + if (intsize < LONGSIZE && + e->Eoper == OPand && + ul <= SHORTMASK) + { tym = e->Ety; + e->E1 = el_una(OP32_16,TYushort,e->E1); + e->E2 = el_una(OP32_16,TYushort,e->E2); + e->Ety = TYushort; + e = el_una(OPu16_32,tym,e); + goto Lopt; + } + + // Replace ((s8sht)L & 0xFF) with (u8sht)L + if (ul == 0xFF && intsize == LONGSIZE && e->Eoper == OPand && + (op == OPs8_16 || op == OPu8_16) + ) + { + e1->Eoper = OPu8_16; + e = el_selecte1(e); + goto Lopt; + } + + break; + + case SHORTSIZE: + i = e2->EV.Vshort; + if (i == (targ_short)SHORTMASK) // e2 & 0xFFFF + goto L1; + + /* (x >> 8) & 0xFF => ((unsigned short)x >> 8) */ + if (OPTIMIZER && i == 0xFF && e->Eoper == OPand && + (op == OPshr || op == OPashr) && e1->E2->Eoper == OPconst && e1->E2->EV.Vint == 8) + { elem *e11 = e1->E1; + + e11->Ety = touns(e11->Ety) | (e11->Ety & ~mTYbasic); + goto L1; + } + + // (s8_16(e) & 0xFF) => u8_16(e) + if (OPTIMIZER && op == OPs8_16 && e->Eoper == OPand && + i == 0xFF) + { + e1->Eoper = OPu8_16; + e = el_selecte1(e); + goto Lopt; + } + + if ( + /* OK for unsigned if AND or high bits of i are 0 */ + op == OPu8_16 && (e->Eoper == OPand || !(i & ~0xFF)) || + /* OK for signed if i is 'sign-extended' */ + op == OPs8_16 && (targ_short)(targ_schar)i == i + ) + { + /* Convert ((u8int) e) & i) to (u8int)(e & (int8) i) */ + /* or similar for s8int */ + e = el_una(e1->Eoper,e->Ety,e); + e->E1->Ety = e1->Ety = e1->E1->Ety; + e->E1->E1 = el_selecte1(e1); + e->E1->E2 = el_una(OP16_8,e->E1->Ety,e->E1->E2); + goto Lopt; + } + break; + +#if __INTSIZE == 4 + case LLONGSIZE: + if (OPTIMIZER) + { + if (e2->EV.Vullong == LLONGMASK) + goto L1; + } + break; +#endif + } + if (OPTIMIZER && sz < 16) + { targ_ullong ul = el_tolong(e2); + + if (e->Eoper == OPor && op == OPand && e1->E2->Eoper == OPconst) + { + // ((x & c1) | c2) => (x | c2) + targ_ullong c3; + + c3 = ul | e1->E2->EV.Vullong; + switch (sz) + { case CHARSIZE: + if ((c3 & CHARMASK) == CHARMASK) + goto L2; + break; + case SHORTSIZE: + if ((c3 & SHORTMASK) == SHORTMASK) + goto L2; + break; + case LONGSIZE: + if ((c3 & LONGMASK) == LONGMASK) + { + L2: + e1->E2->EV.Vullong = c3; + e->E1 = elbitwise(e1); + goto Lopt; + } + break; +#if __INTSIZE == 4 + case LLONGSIZE: + if ((c3 & LLONGMASK) == LLONGMASK) + goto L2; + break; +#endif + default: + assert(0); + } + } + +#if __INTSIZE == 4 + if (op == OPs16_32 && (ul & 0xFFFFFFFFFFFF8000LL) == 0 || + op == OPu16_32 && (ul & 0xFFFFFFFFFFFF0000LL) == 0 || + op == OPs8_16 && (ul & 0xFFFFFFFFFFFFFF80LL) == 0 || + op == OPu8_16 && (ul & 0xFFFFFFFFFFFFFF00LL) == 0 || + op == OPs32_64 && (ul & 0xFFFFFFFF80000000LL) == 0 || + op == OPu32_64 && (ul & 0xFFFFFFFF00000000LL) == 0 + ) +#else + if (op == OPs16_32 && (ul & 0xFFFF8000) == 0 || + op == OPu16_32 && (ul & 0xFFFF0000) == 0 || + op == OPs8_16 && (ul & 0xFFFFFF80) == 0 || + op == OPu8_16 && (ul & 0xFFFFFF00) == 0) +#endif + { + if (e->Eoper == OPand) + { if (op == OPs16_32 && (ul & 0x8000) == 0) + e1->Eoper = OPu16_32; + else if (op == OPs8_16 && (ul & 0x80) == 0) + e1->Eoper = OPu8_16; +#if __INTSIZE == 4 + else if (op == OPs32_64 && (ul & 0x80000000) == 0) + e1->Eoper = OPu32_64; +#endif + } + + // ((shtlng)s & c) => ((shtlng)(s & c) + e1->Ety = e->Ety; + e->Ety = e2->Ety = e1->E1->Ety; + e->E1 = e1->E1; + e1->E1 = e; + e = e1; + goto Lopt; + } + + // Replace (((a & b) ^ c) & d) with ((a ^ c) & e), where + // e is (b&d). + if (e->Eoper == OPand && op == OPxor && e1->E1->Eoper == OPand && + e1->E1->E2->Eoper == OPconst) + { + e2->EV.Vullong &= e1->E1->E2->EV.Vullong; + e1->E1 = el_selecte1(e1->E1); + goto Lopt; + } + } + } + return e; + +Lopt: +#ifdef DEBUG + static int nest; + nest++; + if (nest > 100) + { elem_print(e); + assert(0); + } + e = optelem(e,TRUE); + nest--; + return e; +#endif + return optelem(e,TRUE); +} + + +/************************************* + * Replace shift|shift with rotate. + */ + +STATIC elem *elor(elem *e) +{ + /* ROL: (a << shift) | (a >> (sizeof(a) * 8 - shift)) + * ROR: (a >> shift) | (a << (sizeof(a) * 8 - shift)) + */ + elem *e1 = e->E1; + elem *e2 = e->E2; + unsigned sz = tysize(e->Ety); + if (sz <= intsize) + { + if (e1->Eoper == OPshl && e2->Eoper == OPshr && + tyuns(e2->E1->Ety) && e2->E2->Eoper == OPmin && + e2->E2->E1->Eoper == OPconst && + el_tolong(e2->E2->E1) == sz * 8 && + el_match5(e1->E1, e2->E1) && + el_match5(e1->E2, e2->E2->E2) && + !el_sideeffect(e) + ) + { + e1->Eoper = OProl; + return el_selecte1(e); + } + if (e1->Eoper == OPshr && e2->Eoper == OPshl && + tyuns(e1->E1->Ety) && e2->E2->Eoper == OPmin && + e2->E2->E1->Eoper == OPconst && + el_tolong(e2->E2->E1) == sz * 8 && + el_match5(e1->E1, e2->E1) && + el_match5(e1->E2, e2->E2->E2) && + !el_sideeffect(e) + ) + { + e1->Eoper = OPror; + return el_selecte1(e); + } + } + return elbitwise(e); +} + +/************************************* + */ + +STATIC elem *elxor(elem *e) +{ + if (OPTIMIZER) + { + elem *e1 = e->E1; + elem *e2 = e->E2; + + /* Recognize: + * (a & c) ^ (b & c) => (a ^ b) & c + */ + if (e1->Eoper == OPand && e2->Eoper == OPand && + el_match5(e1->E2, e2->E2) && + (e2->E2->Eoper == OPconst || (!el_sideeffect(e2->E1) && !el_sideeffect(e2->E2)))) + { + el_free(e1->E2); + e1->E2 = e2->E1; + e1->Eoper = OPxor; + e->Eoper = OPand; + e->E2 = e2->E2; + e2->E1 = NULL; + e2->E2 = NULL; + el_free(e2); + return optelem(e, TRUE); + } + } + return elbitwise(e); +} + +/************************** + * Optimize nots. + * ! ! e => bool e + * ! bool e => ! e + * ! OTrel => !OTrel (invert the condition) + * ! OTconv => ! + */ + +STATIC elem * elnot(elem *e) +{ elem *e1; + unsigned op; + + e1 = e->E1; + op = e1->Eoper; + switch (op) + { case OPnot: // ! ! e => bool e + case OPbool: // ! bool e => ! e + e1->Eoper = op ^ (OPbool ^ OPnot); + /* That was a clever substitute for the following: */ + /* e->Eoper = (op == OPnot) ? OPbool : OPnot; */ + goto L1; + + default: + if (OTrel(op)) /* ! OTrel => !OTrel */ + { + /* Find the logical negation of the operator */ + op = rel_not(op); + if (!tyfloating(e1->E1->Ety)) + { op = rel_integral(op); + assert(OTrel(op)); + } + e1->Eoper = op; + + L1: e = optelem(el_selecte1(e),TRUE); + } + else if (tybasic(e1->Ety) == TYbool && tysize(e->Ety) == 1) + { + // !e1 => (e1 ^ 1) + e->Eoper = OPxor; + e->E2 = el_long(e1->Ety,1); + e = optelem(e,TRUE); + } +#if 0 +// Can't use this because what if OPd_s32? +// Note: !(long)(.1) != !(.1) + else if (OTconv(op)) // don't use case because of differ target + { // conversion operators + e1->Eoper = e->Eoper; + goto L1; + } +#endif + break; + + case OPs32_d: + case OPs16_d: + case OPu16_d: + case OPu32_d: + case OPf_d: + case OPs16_32: + case OPu16_32: + case OPu8_16: + case OPs8_16: + case OPu32_64: + case OPs32_64: +#if TARGET_SEGMENTED + case OPvp_fp: + case OPcvp_fp: + case OPnp_fp: +#endif + e1->Eoper = e->Eoper; + goto L1; + + case OPcomma: + /* !(a,b) => (a,!b) */ + e->Eoper = OPcomma; + e->E1 = e1->E1; // a + e->E2 = e1; // ! + e1->Eoper = OPnot; + e1->Ety = e->Ety; + e1->E1 = e1->E2; // b + e1->E2 = NULL; + e = optelem(e,TRUE); + break; + } + return e; +} + +/************************* + * Complement + * ~ ~ e => e + */ + +STATIC elem * elcom(elem *e) +{ elem *e1; + + e1 = e->E1; + if (e1->Eoper == OPcom) /* ~ ~ e => e */ + /* Typing problem here */ + e = el_selecte1(el_selecte1(e)); + return e; +} + +/************************* + * If it is a conditional of a constant + * then we know which exp to evaluate. + * BUG: + * doesn't detect ("string" ? et : ef) + */ + +STATIC elem * elcond(elem *e) +{ elem *e1; + elem *ex; + + e1 = e->E1; + switch (e1->Eoper) + { case OPconst: + if (boolres(e1)) + L1: + e = el_selecte1(el_selecte2(e)); + else + e = el_selecte2(el_selecte2(e)); + break; + case OPrelconst: + case OPstring: + goto L1; + + case OPcomma: + // ((a,b) ? c) => (a,(b ? c)) + e->Eoper = OPcomma; + e->E1 = e1->E1; + e1->E1 = e1->E2; + e1->E2 = e->E2; + e->E2 = e1; + e1->Eoper = OPcond; + e1->Ety = e->Ety; + return optelem(e,TRUE); + + case OPnot: + // (!a ? b : c) => (a ? c : b) + ex = e->E2->E1; + e->E2->E1 = e->E2->E2; + e->E2->E2 = ex; + goto L2; + + default: + if (OTboolnop(e1->Eoper)) + { + L2: + e->E1 = e1->E1; + e1->E1 = NULL; + el_free(e1); + return elcond(e); + } + { + if (OPTIMIZER) + { + elem *ec1,*ec2; + tym_t ty = e->Ety; + + ec1 = e->E2->E1; + ec2 = e->E2->E2; + if (tyintegral(ty) && ec1->Eoper == OPconst && ec2->Eoper == OPconst) + { targ_llong i1,i2; + targ_llong b; + + i1 = el_tolong(ec1); + i2 = el_tolong(ec2); + + /* If b is an integer with only 1 bit set then */ + /* replace ((a & b) ? b : 0) with (a & b) */ + /* replace ((a & b) ? 0 : b) with ((a & b) ^ b) */ + if (e1->Eoper == OPand && e1->E2->Eoper == OPconst && + tysize(ty) == tysize(ec1->Ety)) + { + b = el_tolong(e1->E2); + if (ispow2(b) != -1) /* if only 1 bit is set */ + { + if (b == i1 && i2 == 0) + { e = el_selecte1(e); + e->E1->Ety = ty; + e->E2->Ety = ty; + e->E2->EV.Vllong = b; + return optelem(e,TRUE); + } + else if (i1 == 0 && b == i2) + { + e1->Ety = ty; + e1->E1->Ety = ty; + e1->E2->Ety = ty; + e1->E2->EV.Vllong = b; + e->E1 = el_bin(OPxor,ty,e1,el_long(ty,b)); + e = el_selecte1(e); + return optelem(e,TRUE); + } + } + } + + /* Replace ((a relop b) ? 1 : 0) with (a relop b) */ + else if (OTrel(e1->Eoper) && + tysize(ty) <= tysize[TYint]) + { + if (i1 == 1 && i2 == 0) + e = el_selecte1(e); + else if (i1 == 0 && i2 == 1) + { + e->E1 = el_una(OPnot,ty,e1); + e = optelem(el_selecte1(e),TRUE); + } + } +#if TX86 + // The next two optimizations attempt to replace with an + // unsigned compare, which the code generator can generate + // code for without using jumps. + + // Try to replace (!e1) with (e1 < 1) + else if (e1->Eoper == OPnot && !OTrel(e1->E1->Eoper)) + { + e->E1 = el_bin(OPlt,TYint,e1->E1,el_long(touns(e1->E1->Ety),1)); + e1->E1 = NULL; + el_free(e1); + } + // Try to replace (e1) with (e1 >= 1) + else if (!OTrel(e1->Eoper)) + { + if (tyfv(e1->Ety)) + { + if (tysize(e->Ety) == tysize[TYint]) + { + if (i1 == 1 && i2 == 0) + { e->Eoper = OPbool; + el_free(e->E2); + e->E2 = NULL; + } + else if (i1 == 0 && i2 == 1) + { e->Eoper = OPnot; + el_free(e->E2); + e->E2 = NULL; + } + } + } + else if(tyintegral(e1->Ety)) + e->E1 = el_bin(OPge,TYint,e1,el_long(touns(e1->Ety),1)); + } +#endif + } + + // Try to detect absolute value expression + // (a < 0) -a : a + if ((e1->Eoper == OPlt || e1->Eoper == OPle) && + e1->E2->Eoper == OPconst && + !boolres(e1->E2) && + !tyuns(e1->E1->Ety) && + !tyuns(e1->E2->Ety) && + ec1->Eoper == OPneg && + !el_sideeffect(ec2) && + el_match(e->E1->E1,ec2) && + el_match(ec1->E1,ec2) && + tysize(ty) >= intsize + ) + { e->E2->E2 = NULL; + el_free(e); + e = el_una(OPabs,ty,ec2); + } + // (a >= 0) a : -a + else if ((e1->Eoper == OPge || e1->Eoper == OPgt) && + e1->E2->Eoper == OPconst && + !boolres(e1->E2) && + !tyuns(e1->E1->Ety) && + !tyuns(e1->E2->Ety) && + ec2->Eoper == OPneg && + !el_sideeffect(ec1) && + el_match(e->E1->E1,ec1) && + el_match(ec2->E1,ec1) && + tysize(ty) >= intsize + ) + { e->E2->E1 = NULL; + el_free(e); + e = el_una(OPabs,ty,ec1); + } + break; + } + } + } + return e; +} + + +/**************************** + * Comma operator. + * , e + * / \ => expression with no effect + * c e + * , , + * / \ => / \ operators with no effect + * + e , e + * / \ / \ + * e e e e + */ + +STATIC elem * elcomma(elem *e) +{ register elem *e1,**pe1; + elem *e2; + int e1op; + int changes; + + changes = -1; +L1: + changes++; +L2: + //printf("elcomma()\n"); + e2 = e->E2; + pe1 = &(e->E1); + e1 = *pe1; + e1op = e1->Eoper; + + /* c,e => e */ + if (OTleaf(e1op) && !OTsideff(e1op) && !(e1->Ety & mTYvolatile)) + { e2->Ety = e->Ety; + e = el_selecte2(e); + goto Lret; + } + + /* ((a op b),e2) => ((a,b),e2) if op has no side effects */ + if (!el_sideeffect(e1) && e1op != OPcomma && e1op != OPandand && + e1op != OPoror && e1op != OPcond) + { + if (OTunary(e1op)) + *pe1 = el_selecte1(e1); /* get rid of e1 */ + else + { e1->Eoper = OPcomma; + e1->Ety = e1->E2->Ety; + } + goto L1; + } + + if (!OPTIMIZER) + goto Lret; + + /* Replace (a,b),e2 with a,(b,e2) */ + if (e1op == OPcomma) + { + e1->Ety = e->Ety; + e->E1 = e1->E1; + e1->E1 = e1->E2; + e1->E2 = e2; + e->E2 = elcomma(e1); + goto L2; + } + + if ((OTopeq(e1op) || e1op == OPeq) && + (e1->E1->Eoper == OPvar || e1->E1->Eoper == OPind) && + !el_sideeffect(e1->E1) + ) + { + if (el_match(e1->E1,e2)) + // ((a = b),a) => (a = b) + e = el_selecte1(e); + else if (OTrel(e2->Eoper) && + OTleaf(e2->E2->Eoper) && + el_match(e1->E1,e2->E1) + ) + { // ((a = b),(a < 0)) => ((a = b) < 0) + e1->Ety = e2->E1->Ety; + e->E1 = e2->E1; + e2->E1 = e1; + goto L1; + } + else if ((e2->Eoper == OPandand || + e2->Eoper == OPoror || + e2->Eoper == OPcond) && + el_match(e1->E1,e2->E1) + ) + { + /* ((a = b),(a || c)) => ((a = b) || c) */ + e1->Ety = e2->E1->Ety; + e->E1 = e2->E1; + e2->E1 = e1; + e = el_selecte2(e); + changes++; + goto Lret; + } + else if (e1op == OPeq) + { + /* Replace ((a = b),(c = a)) with a,(c = (a = b)) */ + for (; e2->Eoper == OPcomma; e2 = e2->E1) + ; + if ((OTopeq(e2->Eoper) || e2->Eoper == OPeq) && + el_match(e1->E1,e2->E2) && +#if 0 + !(e1->E1->Eoper == OPvar && el_appears(e2->E1,e1->E1->EV.sp.Vsym)) && +#endif + ERTOL(e2)) + { + e->E1 = e2->E2; + e1->Ety = e2->E2->Ety; + e2->E2 = e1; + goto L1; + } + } + else + { +#if 1 // This optimization is undone in eleq(). + // Replace ((a op= b),(a op= c)) with (0,a = (a op b) op c) + for (; e2->Eoper == OPcomma; e2 = e2->E1) + ; + if ((OTopeq(e2->Eoper)) && + el_match(e1->E1,e2->E1)) + { elem *ex; + + e->E1 = el_long(TYint,0); + e1->Eoper = opeqtoop(e1op); + e2->E2 = el_bin(opeqtoop(e2->Eoper),e2->Ety,e1,e2->E2); + e2->Eoper = OPeq; + goto L1; + } +#endif + } + } +Lret: + again = changes != 0; + return e; +} + +/******************************** + */ + +STATIC elem * elremquo(elem *e) +{ +#if 0 && MARS + if (cnst(e->E2) && !boolres(e->E2)) + error(e->Esrcpos.Sfilename, e->Esrcpos.Slinnum, "divide by zero\n"); +#endif + return e; +} + +/******************************** + */ + +STATIC elem * elmod(elem *e) +{ + elem *e1; + elem *e2; + tym_t tym; + + tym = e->E1->Ety; + if (!tyfloating(tym)) + return eldiv(e); + return e; +} + +/***************************** + * Convert divides to >> if power of 2. + * Can handle OPdiv, OPdivass, OPmod. + */ + +STATIC elem * eldiv(elem *e) +{ elem *e2; + tym_t tym; + int uns; + + e2 = e->E2; + tym = e->E1->Ety; + uns = tyuns(tym) | tyuns(e2->Ety); + if (cnst(e2)) + { +#if 0 && MARS + if (!boolres(e2)) + error(e->Esrcpos.Sfilename, e->Esrcpos.Slinnum, "divide by zero\n"); +#endif + if (uns) + { int i; + + e2->Ety = touns(e2->Ety); + i = ispow2(el_tolong(e2)); + if (i != -1) + { int op; + + switch (e->Eoper) + { case OPdiv: + op = OPshr; + goto L1; + case OPdivass: + op = OPshrass; + L1: + e2->EV.Vint = i; + e2->Ety = TYint; + e->E1->Ety = touns(tym); + break; + + case OPmod: + op = OPand; + goto L3; + case OPmodass: + op = OPandass; + L3: + e2->EV.Vullong = el_tolong(e2) - 1; + break; + + default: + assert(0); + } + e->Eoper = op; + return optelem(e,TRUE); + } + } + } + + if (OPTIMIZER) + { + if (tyintegral(tym) && (e->Eoper == OPdiv || e->Eoper == OPmod)) + { int sz = tysize(tym); + + // See if we can replace with OPremquo + if (sz == REGSIZE /*&& !I64*/) // need cent and ucent working for I64 to work + { + // Don't do it if there are special code sequences in the + // code generator (see cdmul()) + int pow2; + if (e->E2->Eoper == OPconst && + sz == REGSIZE && !uns && + (pow2 = ispow2(el_tolong(e->E2))) != -1 && + !(config.target_cpu < TARGET_80286 && pow2 != 1 && e->Eoper == OPdiv) + ) + ; + else + { + assert(sz == 2 || sz == 4 || sz == 8); + int op = OPmsw; + if (e->Eoper == OPdiv) + { + op = (sz == 2) ? OP32_16 : (sz == 4) ? OP64_32 : OP128_64; + } + e->Eoper = OPremquo; + e = el_una(op, tym, e); + e->E1->Ety = (sz == 2) ? TYlong : (sz == 4) ? TYllong : TYcent; + } + } + } + } + + return e; +} + +/************************** + * Convert (a op b) op c to a op (b op c). + */ + +STATIC elem * swaplog(elem *e) +{ elem *e1; + + e1 = e->E1; + e->E1 = e1->E2; + e1->E2 = e; + return optelem(e1,TRUE); +} + +STATIC elem * eloror(elem *e) +{ elem *e1,*e2; + tym_t t; + tym_t ty1,ty2; + + e1 = e->E1; + if (OTboolnop(e1->Eoper)) + { + e->E1 = e1->E1; + e1->E1 = NULL; + el_free(e1); + return eloror(e); + } + e2 = e->E2; + if (OTboolnop(e2->Eoper)) + { + e->E2 = e2->E1; + e2->E1 = NULL; + el_free(e2); + return eloror(e); + } + if (OPTIMIZER) + { + if (e1->Eoper == OPbool) + { ty1 = e1->E1->Ety; + e1 = e->E1 = el_selecte1(e1); + e1->Ety = ty1; + } + if (e1->Eoper == OPoror) + { /* convert (a||b)||c to a||(b||c). This will find more CSEs. */ + return swaplog(e); + } + e2 = elscancommas(e2); + e1 = elscancommas(e1); + } + + t = e->Ety; + if (e2->Eoper == OPconst || e2->Eoper == OPrelconst || e2->Eoper == OPstring) + { + if (boolres(e2)) /* e1 || 1 => e1 , 1 */ + { if (e->E2 == e2) + goto L2; + } + else /* e1 || 0 => bool e1 */ + { if (e->E2 == e2) + { + el_free(e->E2); + e->E2 = NULL; + e->Eoper = OPbool; + goto L3; + } + } + } + + if (e1->Eoper == OPconst || e1->Eoper == OPrelconst || e1->Eoper == OPstring) + { + if (boolres(e1)) /* (x,1) || e2 => (x,1),1 */ + { + L2: + e->Eoper = OPcomma; + el_free(e->E2); + e->E2 = el_int(t,1); + } + else /* (x,0) || e2 => (x,0),(bool e2) */ + { e->Eoper = OPcomma; + if (tybasic(e->E2->Ety) != TYvoid) + e->E2 = el_una(OPbool,t,e->E2); + } + } + else if (OPTIMIZER && + e->E2->Eoper == OPvar && + !OTlogical(e1->Eoper) && + tysize(ty2 = e2->Ety) == tysize(ty1 = e1->Ety) && + tysize(ty1) <= intsize && + !tyfloating(ty2) && + !tyfloating(ty1) && + !(ty2 & mTYvolatile)) + { /* Convert (e1 || e2) => (e1 | e2) */ + e->Eoper = OPor; + e->Ety = ty1; + e = el_una(OPbool,t,e); + } + else if (OPTIMIZER && + e1->Eoper == OPand && e2->Eoper == OPand && + tysize(e1->Ety) == tysize(e2->Ety) && + el_match(e1->E1,e2->E1) && !el_sideeffect(e1->E1) && + !el_sideeffect(e2->E2) + ) + { // Convert ((a & b) || (a & c)) => bool(a & (b | c)) + e->Eoper = OPbool; + e->E2 = NULL; + e2->Eoper = OPor; + el_free(e2->E1); + e2->E1 = e1->E2; + e1->E2 = e2; + } + else + goto L1; +L3: + e = optelem(e,TRUE); +L1: + return e; +} + +STATIC elem * elandand(elem *e) +{ + elem *e1 = e->E1; + if (OTboolnop(e1->Eoper)) + { + e->E1 = e1->E1; + e1->E1 = NULL; + el_free(e1); + return elandand(e); + } + elem *e2 = e->E2; + if (OTboolnop(e2->Eoper)) + { + e->E2 = e2->E1; + e2->E1 = NULL; + el_free(e2); + return elandand(e); + } + if (OPTIMIZER) + { + /* Recognize: (a >= c1 && a < c2) + */ + if ((e1->Eoper == OPge || e1->Eoper == OPgt) && + (e2->Eoper == OPlt || e2->Eoper == OPle) && + e1->E2->Eoper == OPconst && e2->E2->Eoper == OPconst && + !el_sideeffect(e1->E1) && el_match(e1->E1, e2->E1) && + tyintegral(e1->E1->Ety) && + tybasic(e1->E2->Ety) == tybasic(e2->E2->Ety) && + tysize(e1->E1->Ety) == NPTRSIZE) + { + /* Replace with: ((a - c1) < (c2 - c1)) + */ + targ_llong c1 = el_tolong(e1->E2); + if (e1->Eoper == OPgt) + ++c1; + targ_llong c2 = el_tolong(e2->E2); + if (0 <= c1 && c1 <= c2) + { + e1->Eoper = OPmin; + e1->Ety = e1->E1->Ety; + e1->E2->EV.Vllong = c1; + e->E2 = el_long(touns(e2->E2->Ety), c2 - c1); + e->Eoper = e2->Eoper; + el_free(e2); + return optelem(e, TRUE); + } + } + + // Look for (!(e >>> c) && ...) + if (e1->Eoper == OPnot && e1->E1->Eoper == OPshr && + e1->E1->E2->Eoper == OPconst) + { + // Replace (e >>> c) with (e & x) + elem *e11 = e1->E1; + + targ_ullong shift = el_tolong(e11->E2); + if (shift < intsize * 8) + { targ_ullong m; + + m = ~0LL << (int)shift; + e11->Eoper = OPand; + e11->E2->EV.Vullong = m; + e11->E2->Ety = e11->Ety; + return optelem(e,TRUE); + } + } + + if (e1->Eoper == OPbool) + { tym_t t = e1->E1->Ety; + e1 = e->E1 = el_selecte1(e1); + e1->Ety = t; + } + if (e1->Eoper == OPandand) + { /* convert (a&&b)&&c to a&&(b&&c). This will find more CSEs. */ + return swaplog(e); + } + e2 = elscancommas(e2); + + while (1) + { e1 = elscancommas(e1); + if (e1->Eoper == OPeq) + e1 = e1->E2; + else + break; + } + } + + if (e2->Eoper == OPconst || e2->Eoper == OPrelconst || e2->Eoper == OPstring) + { if (boolres(e2)) /* e1 && (x,1) => e1 ? ((x,1),1) : 0 */ + { + if (e2 == e->E2) /* if no x, replace e with (bool e1) */ + { el_free(e2); + e->E2 = NULL; + e->Eoper = OPbool; + goto L3; + } + } + else /* e1 && (x,0) => e1 , (x,0) */ + { if (e2 == e->E2) + { e->Eoper = OPcomma; + goto L3; + } + } + } + + if (e1->Eoper == OPconst || e1->Eoper == OPrelconst || e1->Eoper == OPstring) + { + e->Eoper = OPcomma; + if (boolres(e1)) /* (x,1) && e2 => (x,1),bool e2 */ + { + e->E2 = el_una(OPbool,e->Ety,e->E2); + } + else /* (x,0) && e2 => (x,0),0 */ + { + el_free(e->E2); + e->E2 = el_int(e->Ety,0); + } + } + else + goto L1; +L3: + e = optelem(e,TRUE); +L1: + return e; +} + +/************************** + * Reference to bit field + * bit + * / \ => ((e << c) >> b) & m + * e w,b + * + * Note that this routine can handle long bit fields, though this may + * not be supported later on. + */ + +STATIC elem * elbit(elem *e) +{ unsigned wb,w,b,c; + targ_ullong m; + elem *e2; + tym_t tym1; + unsigned sz; + + tym1 = e->E1->Ety; + sz = tysize(tym1) * 8; + e2 = e->E2; + wb = e2->EV.Vuns; + + w = (wb >> 8) & 0xFF; /* width in bits of field */ + m = ((targ_ullong)1 << w) - 1; // mask w bits wide + b = wb & 0xFF; /* bits to right of field */ + c = 0; + assert(w + b <= sz); + + if (tyuns(tym1)) /* if unsigned bit field */ + { +#if 1 /* Should use a more general solution to this */ + if (w == 8 && sz == 16 && b == 0) + { + e->E1 = el_una(OP16_8,TYuchar,e->E1); + e->Eoper = OPu8_16; + e->E2 = NULL; + el_free(e2); + goto L1; + } +#endif + if (w + b == sz) /* if field is left-justified */ + m = ~(targ_ullong)0; // no need to mask + } + else /* signed bit field */ + { + if (w == 8 && sz == 16 && b == 0) + { +#if 1 + e->E1 = el_una(OP16_8,TYschar,e->E1); + e->Eoper = OPs8_16; + e->E2 = NULL; + el_free(e2); + goto L1; +#endif + } + m = ~(targ_ullong)0; + c = sz - (w + b); + b = sz - w; + } + + e->Eoper = OPand; + + e2->EV.Vullong = m; /* mask w bits wide */ + e2->Ety = e->Ety; + + e->E1 = el_bin(OPshr,tym1, + el_bin(OPshl,tym1,e->E1,el_int(TYint,c)), + el_int(TYint,b)); +L1: + return optelem(e,TRUE); /* optimize result */ +} + +/***************** + * Indirection + * * & e => e + */ + +STATIC elem * elind(elem *e) +{ elem *e1; + tym_t tym; + + tym = e->Ety; + e1 = e->E1; + switch (e1->Eoper) + { case OPrelconst: + { + e->E1->ET = e->ET; + e = el_selecte1(e); + e->Eoper = OPvar; + e->Ety = tym; /* preserve original type */ + } + break; + case OPadd: +#if TARGET_SEGMENTED + if (OPTIMIZER) + { /* Try to convert far pointer to stack pointer */ + elem *e12 = e1->E2; + + if (e12->Eoper == OPrelconst && + tybasic(e12->Ety) == TYfptr && + /* If symbol is located on the stack */ + sytab[e12->EV.sp.Vsym->Sclass] & SCSS) + { e1->Ety = (e1->Ety & (mTYconst | mTYvolatile | mTYimmutable | mTYshared | mTYLINK)) | TYsptr; + e12->Ety = (e12->Ety & (mTYconst | mTYvolatile | mTYimmutable | mTYshared | mTYLINK)) | TYsptr; + } + } +#endif + break; + case OPcomma: + // Replace (*(ea,eb)) with (ea,*eb) + e->E1->ET = e->ET; + type *t = e->ET; + e = el_selecte1(e); + e->Ety = tym; + e->E2 = el_una(OPind,tym,e->E2); + e->E2->ET = t; + again = 1; + return e; + } + return e; +} + +/***************** + * Address of. + * & v => &v + * & * e => e + * & (v1 = v2) => ((v1 = v2), &v1) + */ + +STATIC elem * eladdr(elem *e) +{ elem *e1; + tym_t tym; + + tym = e->Ety; + e1 = e->E1; + elem_debug(e1); + switch (e1->Eoper) + { + case OPvar: + e1->Eoper = OPrelconst; + e1->EV.sp.Vsym->Sflags &= ~(SFLunambig | GTregcand); + e1->Ety = tym; + e = optelem(el_selecte1(e),TRUE); + break; + case OPind: + { tym_t tym2; + int sz; + + tym2 = e1->E1->Ety; + +#if TARGET_SEGMENTED + /* Watch out for conversions between near and far pointers */ + sz = tysize(tym) - tysize(tym2); + if (sz != 0) + { int op; + + if (sz > 0) /* if &far * near */ + op = OPnp_fp; + else /* else &near * far */ + op = OPoffset; + e->Ety = tym2; + e = el_una(op,tym,e); + goto L1; + } +#endif + e = el_selecte1(el_selecte1(e)); + e->Ety = tym; + break; + } + case OPcomma: + /* Replace (&(ea,eb)) with (ea,&eb) */ + e = el_selecte1(e); + e->Ety = tym; + e->E2 = el_una(OPaddr,tym,e->E2); + L1: + e = optelem(e,TRUE); + break; + case OPnegass: + assert(0); + default: + if (OTassign(e1->Eoper)) + { + case OPstreq: + // & (v1 = e) => ((v1 = e), &v1) + if (e1->E1->Eoper == OPvar) + { elem *ex; + + e->Eoper = OPcomma; + e->E2 = el_una(OPaddr,tym,el_copytree(e1->E1)); + goto L1; + } + // & (*p1 = e) => ((*(t = p1) = e), t) + else if (e1->E1->Eoper == OPind) + { tym_t tym; + elem *tmp; + + tym = e1->E1->E1->Ety; + tmp = el_alloctmp(tym); + e1->E1->E1 = el_bin(OPeq,tym,tmp,e1->E1->E1); + e->Eoper = OPcomma; + e->E2 = el_copytree(tmp); + goto L1; + } + } + break; + case OPcond: + { /* Replace &(x ? y : z) with (x ? &y : &z) */ + elem *ecolon; + + ecolon = e1->E2; + ecolon->Ety = tym; + ecolon->E1 = el_una(OPaddr,tym,ecolon->E1); + ecolon->E2 = el_una(OPaddr,tym,ecolon->E2); + e = el_selecte1(e); + e = optelem(e,TRUE); + break; + } + } + return e; +} + +STATIC elem * elneg(elem *e) +{ + if (e->E1->Eoper == OPneg) + { e = el_selecte1(e); + e = el_selecte1(e); + } + else + e = evalu8(e); + return e; +} + +STATIC elem * elcall(elem *e) +{ + if (e->E1->Eoper == OPcomma || OTassign(e->E1->Eoper)) + e = cgel_lvalue(e); + return e; +} + +/*************************** + * Walk tree, converting types to tym. + */ + +STATIC void elstructwalk(elem *e,tym_t tym) +{ + tym_t ety; + + while ((ety = tybasic(e->Ety)) == TYstruct || + ety == TYarray) + { elem_debug(e); + e->Ety = (e->Ety & ~mTYbasic) | tym; + switch (e->Eoper) + { case OPcomma: + case OPcond: + case OPinfo: + break; + case OPeq: + case OPcolon: + case OPcolon2: + elstructwalk(e->E1,tym); + break; + default: + return; + } + e = e->E2; + } +} + +/******************************* + * See if we can replace struct operations with simpler ones. + * For OPstreq and OPstrpar. + */ + +CEXTERN elem * elstruct(elem *e) +{ tym_t tym; + elem *e2; + elem **pe2; + + //printf("elstruct(%p)\n", e); + if (e->Eoper == OPstreq && (e->E1->Eoper == OPcomma || OTassign(e->E1->Eoper))) + return cgel_lvalue(e); + //printf("\tnumbytes = %d\n", (int)e->Enumbytes); + if (e->ET) + switch ((int) type_size(e->ET)) + { +#if TX86 + case CHARSIZE: tym = TYchar; goto L1; + case SHORTSIZE: tym = TYshort; goto L1; + case LONGSIZE: tym = TYlong; goto L1; +#if LONGLONG + case LLONGSIZE: if (intsize == 2) + goto Ldefault; + tym = TYllong; goto L1; +#endif + L1: + switch (e->Eoper) + { case OPstreq: + e->Eoper = OPeq; + e->Ety = (e->Ety & ~mTYbasic) | tym; + elstructwalk(e->E1,tym); + elstructwalk(e->E2,tym); + e = optelem(e,TRUE); + break; + case OPstrpar: + e = el_selecte1(e); + /* FALL-THROUGH */ + default: /* called by doptelem() */ + e2 = e; + elstructwalk(e2,tym); + break; + } + break; +#endif + case 0: + if (e->Eoper == OPstreq) + { e->Eoper = OPcomma; + e = optelem(e,TRUE); + again = 1; + } + else + goto Ldefault; + break; + + default: + Ldefault: + if (e->Eoper == OPstreq) + pe2 = &e->E2; + else if (e->Eoper == OPstrpar) + pe2 = &e->E1; + else + break; + while ((*pe2)->Eoper == OPcomma) + pe2 = &(*pe2)->E2; + e2 = *pe2; + + // Convert (x streq (a?y:z)) to (x streq *(a ? &y : &z)) + if (e2->Eoper == OPcond) + { tym_t ty2 = e2->Ety; + tym_t typ; + + /* We should do the analysis to see if we can use + something simpler than TYfptr. + */ +#if TARGET_SEGMENTED + typ = (intsize == LONGSIZE) ? TYnptr : TYfptr; +#else + typ = TYnptr; +#endif + e2 = el_una(OPaddr,typ,e2); + e2 = optelem(e2,TRUE); /* distribute & to x and y leaves */ + *pe2 = el_una(OPind,ty2,e2); + break; + } + break; + } + return e; +} + +/************************** + * Assignment. Replace bit field assignment with + * equivalent tree. + * = + * / \ + * / r + * bit + * / \ + * l w,b + * + * becomes: + * , + * / \ + * = (r&m) + * / \ + * l | + * / \ + * (r&m)<E1; + + if (e1->Eoper == OPcomma || OTassign(e1->Eoper)) + return cgel_lvalue(e); + +#if 0 // Doesn't work too well, removed + // Replace (*p++ = e2) with ((*p = e2),*p++) + if (OPTIMIZER && e1->Eoper == OPind && + (e1->E1->Eoper == OPpostinc || e1->E1->Eoper == OPpostdec) && + !el_sideeffect(e1->E1->E1) + ) + { + e = el_bin(OPcomma,e->Ety,e,e1); + e->E1->E1 = el_una(OPind,e1->Ety,el_copytree(e1->E1->E1)); + return optelem(e,TRUE); + } +#endif + +#if 0 && LNGDBLSIZE == 12 + /* On Linux, long doubles are 12 bytes rather than 10. + * This means, on assignment, we need to set 12 bytes, + * so that garbage doesn't creep into the extra 2 bytes + * and throw off compares. + */ + tyl = tybasic(e1->Ety); + if (e1->Eoper == OPvar && (tyl == TYldouble || tyl == TYildouble || tyl == TYcldouble)) + { +#if 1 + elem *ex = el_copytree(e1); + ex->EV.sp.Voffset += 10; + ex = el_bin(OPeq, TYshort, ex, el_long(TYshort, 0)); + e = el_combine(ex, e); + if (tyl == TYcldouble) + { + ex = el_copytree(e1); + ex->EV.sp.Voffset += 10 + 12; + ex = el_bin(OPeq, TYshort, ex, el_long(TYshort, 0)); + e = el_combine(ex, e); + } + return optelem(e, TRUE); +#else + e->Eoper = OPstreq; + e->Enumbytes = tysize(tyl); + return elstruct(e); +#endif + } +#endif + + if (OPTIMIZER) + { elem *e2 = e->E2; + elem *ei; + int op2 = e2->Eoper; + + // Replace (e1 = *p++) with (e1 = *p, p++, e1) + ei = e2; + if (e1->Eoper == OPvar && + (op2 == OPind || (OTunary(op2) && (ei = e2->E1)->Eoper == OPind)) && + (ei->E1->Eoper == OPpostinc || ei->E1->Eoper == OPpostdec) && + !el_sideeffect(e1) && + !el_sideeffect(ei->E1->E1) + ) + { + e = el_bin(OPcomma,e->Ety, + e, + el_bin(OPcomma,e->Ety,ei->E1,el_copytree(e1))); + ei->E1 = el_copytree(ei->E1->E1); // copy p + return optelem(e,TRUE); + } + + /* Replace (e = e) with (e,e) */ + if (el_match(e1,e2)) + { e->Eoper = OPcomma; + L1: + return optelem(e,TRUE); + } + + // Replace (e1 = (e21 , e22)) with (e21 , (e1 = e22)) + if (op2 == OPcomma) + { + e2->Ety = e->Ety; + e->E2 = e2->E2; + e2->E2 = e; + e = e2; + goto L1; + } + + if (OTop(op2) && !el_sideeffect(e1) + && op2 != OPdiv && op2 != OPmod + ) + { tym_t ty; + int op3; + + // Replace (e1 = e1 op e) with (e1 op= e) + if (el_match(e1,e2->E1)) + { ty = e2->E2->Ety; + e->E2 = el_selecte2(e2); + L2: + e->E2->Ety = ty; + e->Eoper = optoopeq(op2); + goto L1; + } + if (OTcommut(op2)) + { + /* Replace (e1 = e op e1) with (e1 op= e) */ + if (el_match(e1,e2->E2)) + { ty = e2->E1->Ety; + e->E2 = el_selecte1(e2); + goto L2; + } + } + +#if 0 +// Note that this optimization is undone in elcomma(), this results in an +// infinite loop. This optimization is preferable if e1 winds up a register +// variable, the inverse in elcomma() is preferable if e1 winds up in memory. + // Replace (e1 = (e1 op3 ea) op2 eb) with (e1 op3= ea),(e1 op2= eb) + op3 = e2->E1->Eoper; + if (OTop(op3) && el_match(e1,e2->E1->E1) && !el_depends(e1,e2->E2)) + { + e->Eoper = OPcomma; + e->E1 = e2->E1; + e->E1->Eoper = optoopeq(op3); + e2->E1 = e1; + e1->Ety = e->E1->Ety; + e2->Eoper = optoopeq(op2); + e2->Ety = e->Ety; + goto L1; + } +#endif + } + + if (op2 == OPneg && el_match(e1,e2->E1) && !el_sideeffect(e1)) + { int offset; + + Ldef: + // Replace (i = -i) with (negass i) + e->Eoper = OPnegass; + e->E2 = NULL; + el_free(e2); + return optelem(e, TRUE); + } + + // Replace (x = (y ? z : x)) with ((y && (x = z)),x) + if (op2 == OPcond && el_match(e1,e2->E2->E2)) + { elem *e22 = e2->E2; // e22 is the OPcond + + e->Eoper = OPcomma; + e->E2 = e1; + e->E1 = e2; + e2->Eoper = OPandand; + e2->Ety = TYint; + e22->Eoper = OPeq; + e22->Ety = e->Ety; + e1 = e22->E1; + e22->E1 = e22->E2; + e22->E2 = e1; + return optelem(e,TRUE); + } + + // Replace (x = (y ? x : z)) with ((y || (x = z)),x) + if (op2 == OPcond && el_match(e1,e2->E2->E1)) + { elem *e22 = e2->E2; // e22 is the OPcond + + e->Eoper = OPcomma; + e->E2 = e1; + e->E1 = e2; + e2->Eoper = OPoror; + e2->Ety = TYint; + e22->Eoper = OPeq; + e22->Ety = e->Ety; + return optelem(e,TRUE); + } + + // If floating point, replace (x = -y) with (x = y ^ signbit) + if (op2 == OPneg && (tyreal(e2->Ety) || tyimaginary(e2->Ety)) && + (e2->E1->Eoper == OPvar || e2->E1->Eoper == OPind) && + /* Turned off for XMM registers because they don't play well with + * int registers. + */ + !config.fpxmmregs) + { elem *es; + tym_t ty; + + es = el_calloc(); + es->Eoper = OPconst; + switch (tysize(e2->Ety)) + { + case FLOATSIZE: + ty = TYlong; + es->EV.Vlong = 0x80000000; + break; + case DOUBLESIZE: +#if LONGLONG + if (I32) + { ty = TYllong; + es->EV.Vllong = 0x8000000000000000LL; + break; + } +#endif + default: + el_free(es); + goto L8; + } + es->Ety = ty; + e1->Ety = ty; + e2->Ety = ty; + e2->E1->Ety = ty; + e2->E2 = es; + e2->Eoper = OPxor; + return optelem(e,TRUE); + } + L8: ; + } + + if (e1->Eoper == OPcomma) + return cgel_lvalue(e); +#if MARS + // No bit fields to deal with + return e; +#else + if (e1->Eoper != OPbit) + return e; + if (e1->E1->Eoper == OPcomma || OTassign(e1->E1->Eoper)) + return cgel_lvalue(e); + t = e->Ety; + l = e1->E1; /* lvalue */ + r = e->E2; + tyl = l->Ety; + sz = tysize(tyl) * 8; + w = (e1->E2->EV.Vuns >> 8); /* width in bits of field */ + m = ((targ_ullong)1 << w) - 1; // mask w bits wide + b = e1->E2->EV.Vuns & 0xFF; /* bits to shift */ + + eres = el_bin(OPeq,t, + l, + el_bin(OPor,t, + el_bin(OPshl,t, + (r2 = el_bin(OPand,t,r,el_long(t,m))), + el_int(TYint,b) + ), + el_bin(OPand,t, + (l2 = el_copytree(l)), + el_long(t,~(m << b)) + ) + ) + ); + eres->Esrcpos = e->Esrcpos; // save line information + if (OPTIMIZER && w + b == sz) + r2->E2->EV.Vllong = ~ZEROLL; // no need to mask if left justified + if (wantres) + { unsigned c; + elem **pe; + elem *e2; + + r = el_copytree(r); + if (tyuns(tyl)) /* unsigned bit field */ + { + e2 = el_bin(OPand,t,r,el_long(t,m)); + pe = &e2->E1; + } + else /* signed bit field */ + { + c = sz - w; /* e2 = (r << c) >> c */ + e2 = el_bin(OPshr,t,el_bin(OPshl,tyl,r,el_long(TYint,c)),el_long(TYint,c)); + pe = &e2->E1->E1; + } + eres = el_bin(OPcomma,t,eres,e2); + if (EOP(r)) + fixside(&(r2->E1),pe); + } + + if (EOP(l) && EOP(l->E1)) + fixside(&(l2->E1),&(l->E1)); + e1->E1 = e->E2 = NULL; + el_free(e); + return optelem(eres,TRUE); +#endif +} + +/********************************** + */ + +STATIC elem * elnegass(elem *e) +{ + e = cgel_lvalue(e); + return e; +} + +/************************** + * Add assignment. Replace bit field assignment with + * equivalent tree. + * += + * / \ + * / r + * bit + * / \ + * l w,b + * + * becomes: + * = + * / \ + * l | + * / \ + * << \ + * / \ \ + * & b & + * / \ / \ + * op m l ~(m<> m + * / \ + * l b + */ + +STATIC elem * elopass(elem *e) +{ targ_llong m; + unsigned w,b,op; + tym_t t; + tym_t tyl; + elem *l,*r,*e1,*l2,*l3,*op2,*eres; + + e1 = e->E1; + if (OTconv(e1->Eoper)) + { e = fixconvop(e); + return optelem(e,TRUE); + } +#if SCPP // have bit fields to worry about? + int wantres = expgoal; + if (e1->Eoper == OPbit) + { + op = opeqtoop(e->Eoper); + + // Make sure t is unsigned + // so >> doesn't have to be masked + t = touns(e->Ety); + + assert(tyintegral(t)); + l = e1->E1; // lvalue + tyl = l->Ety; + r = e->E2; + w = (e1->E2->EV.Vuns >> 8) & 0xFF; // width in bits of field + m = ((targ_llong)1 << w) - 1; // mask w bits wide + b = e1->E2->EV.Vuns & 0xFF; // bits to shift + + if (tyuns(tyl)) + { + eres = el_bin(OPeq,t, + l, + el_bin(OPor,t, + (op2=el_bin(OPshl,t, + el_bin(OPand,t, + el_bin(op,t, + el_bin(OPand,t, + el_bin(OPshr,t, + (l2=el_copytree(l)), + el_long(TYint,b) + ), + el_long(t,m) + ), + r + ), + el_long(t,m) + ), + el_long(TYint,b) + )), + el_bin(OPand,t, + l3=el_copytree(l), + el_long(t,~(m << b)) + ) + ) + ); + + if (wantres) + { eres = el_bin(OPcomma,t,eres,el_copytree(op2->E1)); + fixside(&(op2->E1),&(eres->E2)); + } + } + else + { /* signed bit field + rewrite to: (l bit w,b) = ((l bit w,b) op r) + */ + e->Eoper = OPeq; + e->E2 = el_bin(op,t,el_copytree(e1),r); + if (l->Eoper == OPind) + fixside(&e->E2->E1->E1->E1,&l->E1); + eres = e; + goto ret; + } + + if (EOP(l) && EOP(l->E1)) + { fixside(&(l2->E1),&(l->E1)); + el_free(l3->E1); + l3->E1 = el_copytree(l->E1); + } + + e1->E1 = e->E2 = NULL; + el_free(e); + ret: + e = optelem(eres,TRUE); + } + else +#endif + { + if (e1->Eoper == OPcomma || OTassign(e1->Eoper)) + e = cgel_lvalue(e); // replace (e,v)op=e2 with e,(v op= e2) + else + { + switch (e->Eoper) + { case OPmulass: + e = elmul(e); + break; + case OPdivass: + // Replace r/=c with r=r/c + if (tycomplex(e->E2->Ety) && !tycomplex(e1->Ety)) + { elem *ed; + + e->Eoper = OPeq; + if (e1->Eoper == OPind) + { // ed: *(tmp=e1->E1) + // e1: *tmp + elem *tmp; + + tmp = el_alloctmp(e1->E1->Ety); + ed = el_bin(OPeq, tmp->Ety, tmp, e1->E1); + e1->E1 = el_copytree(tmp); + ed = el_una(OPind, e1->Ety, ed); + } + else + ed = el_copytree(e1); + // e: e1=ed/e2 + e->E2 = el_bin(OPdiv, e->E2->Ety, ed, e->E2); + if (tyreal(e1->Ety)) + e->E2 = el_una(OPc_r, e1->Ety, e->E2); + else + e->E2 = el_una(OPc_i, e1->Ety, e->E2); + return optelem(e, TRUE); + } + // Repace x/=y with x=x/y + if (OPTIMIZER && + tyintegral(e->E1->Ety) && + e->E1->Eoper == OPvar && + !el_sideeffect(e->E1)) + { + e->Eoper = OPeq; + e->E2 = el_bin(OPdiv, e->E2->Ety, el_copytree(e->E1), e->E2); + return optelem(e, TRUE); + } + e = eldiv(e); + break; + + case OPmodass: + // Repace x%=y with x=x%y + if (OPTIMIZER && + tyintegral(e->E1->Ety) && + e->E1->Eoper == OPvar && + !el_sideeffect(e->E1)) + { + e->Eoper = OPeq; + e->E2 = el_bin(OPmod, e->E2->Ety, el_copytree(e->E1), e->E2); + return optelem(e, TRUE); + } + break; + } + } + } + return e; +} + +/************************** + * Add assignment. Replace bit field post assignment with + * equivalent tree. + * (l bit w,b) ++ r + * becomes: + * (((l bit w,b) += r) - r) & m + */ + +STATIC elem * elpost(elem *e) +{ targ_llong r; + tym_t ty; + elem *e1; + targ_llong m; + unsigned w,b; + + e1 = e->E1; + if (e1->Eoper != OPbit) + { if (e1->Eoper == OPcomma || OTassign(e1->Eoper)) + return cgel_lvalue(e); // replace (e,v)op=e2 with e,(v op= e2) + return e; + } + + assert(e->E2->Eoper == OPconst); + r = el_tolong(e->E2); + + w = (e1->E2->EV.Vuns >> 8) & 0xFF; /* width in bits of field */ + m = ((targ_llong)1 << w) - 1; /* mask w bits wide */ + + ty = e->Ety; + e->Eoper = (e->Eoper == OPpostinc) ? OPaddass : ((r = -r), OPminass); + e = el_bin(OPmin,ty,e,el_long(ty,r)); + if (tyuns(e1->E1->Ety)) /* if unsigned bit field */ + e = el_bin(OPand,ty,e,el_long(ty,m)); + return optelem(e,TRUE); +} + +/*************************** + * Take care of compares. + * (e == 0) => (!e) + * (e != 0) => (bool e) + */ + +STATIC elem * elcmp(elem *e) +{ elem *e2 = e->E2; + elem *e1 = e->E1; + int uns; + + //printf("elcmp(%p)\n",e); elem_print(e); + +L1: + if (OPTIMIZER) + { + int op = e->Eoper; + + /* Convert comparison of OPrelconsts of the same symbol to comparisons */ + /* of their offsets. */ + if (e1->Eoper == OPrelconst && e2->Eoper == OPrelconst && + e1->EV.sp.Vsym == e2->EV.sp.Vsym) + { + e1->Eoper = OPconst; + e1->Ety = TYptrdiff; + e2->Eoper = OPconst; + e2->Ety = TYptrdiff; + return optelem(e,TRUE); + } + + // Convert comparison of long pointers to comparison of integers + if ((op == OPlt || op == OPle || op == OPgt || op == OPge) && + tyfv(e2->Ety) && tyfv(e1->Ety)) + { + e->E1 = el_una(OP32_16,e->Ety,e1); + e->E2 = el_una(OP32_16,e->Ety,e2); + return optelem(e,TRUE); + } + + // Convert ((e & 1) == 1) => (e & 1) + if (op == OPeqeq && e2->Eoper == OPconst && e1->Eoper == OPand) + { elem *e12 = e1->E2; + + if (e12->Eoper == OPconst && el_tolong(e2) == 1 && el_tolong(e12) == 1) + { tym_t ty1; + tym_t ty; + int sz1; + int sz; + + ty = e->Ety; + ty1 = e1->Ety; + e = el_selecte1(e); + e->Ety = ty1; + sz = tysize(ty); + for (sz1 = tysize(ty1); sz1 != sz; sz1 = tysize(e->Ety)) + { + switch (sz1) + { + case 1: + e = el_una(OPu8_16,TYshort,e); + break; + case 2: + if (sz > 2) + e = el_una(OPu16_32,TYlong,e); + else + e = el_una(OP16_8,TYuchar,e); + break; + case 4: + if (sz > 2) + e = el_una(OPu32_64,TYshort,e); + else + e = el_una(OP32_16,TYshort,e); + break; + case 8: + e = el_una(OP64_32,TYlong,e); + break; + default: + assert(0); + } + } + e->Ety = ty; + return optelem(e,TRUE); + } + } + } + + uns = tyuns(e1->Ety) | tyuns(e2->Ety); + if (cnst(e2)) + { + tym_t tym; + int sz; + + if (e1->Eoper == OPu16_32 && e2->EV.Vulong <= (targ_ulong) SHORTMASK || + e1->Eoper == OPs16_32 && + e2->EV.Vlong == (targ_short) e2->EV.Vlong) + { + tym = (uns || e1->Eoper == OPu16_32) ? TYushort : TYshort; + e->E2 = el_una(OP32_16,tym,e2); + goto L2; + } + + /* Try to convert to byte/word comparison for ((x & c)==d) + when mask c essentially casts x to a smaller type + */ + if (OPTIMIZER && + e1->Eoper == OPand && + e1->E2->Eoper == OPconst && + (sz = tysize(e2->Ety)) > CHARSIZE) + { int op; + + assert(tyintegral(e2->Ety) || typtr(e2->Ety)); +#if TX86 /* ending up with byte ops in A regs */ + if (!(el_tolong(e2) & ~CHARMASK) && + !(el_tolong(e1->E2) & ~CHARMASK) + ) + { + if (sz == LLONGSIZE) + { e1->E1 = el_una(OP64_32,TYulong,e1->E1); + e1->E1 = el_una(OP32_16,TYushort,e1->E1); + } + else if (sz == LONGSIZE) + e1->E1 = el_una(OP32_16,TYushort,e1->E1); + tym = TYuchar; + op = OP16_8; + goto L4; + } +#endif + if ( +#if TX86 + intsize == SHORTSIZE && /* not a win when regs are long */ +#endif + sz == LONGSIZE && + !(e2->EV.Vulong & ~SHORTMASK) && + !(e1->E2->EV.Vulong & ~SHORTMASK) + ) + { + tym = TYushort; + op = OP32_16; + L4: + e2->Ety = tym; + e1->Ety = tym; + e1->E2->Ety = tym; + e1->E1 = el_una(op,tym,e1->E1); + e = optelem(e,TRUE); + goto ret; + } + } + + if (e1->Eoper == OPu8_16 && e2->EV.Vuns < 256 || + e1->Eoper == OPs8_16 && + e2->EV.Vint == (targ_schar) e2->EV.Vint) + { + tym = (uns || e1->Eoper == OPu8_16) ? TYuchar : TYschar; + e->E2 = el_una(OP16_8,tym,e2); + L2: + tym |= e1->Ety & ~mTYbasic; + e->E1 = el_selecte1(e1); + e->E1->Ety = tym; + e = optelem(e,TRUE); + } + else if (!boolres(e2)) + { + switch (e->Eoper) + { + targ_int i; + + case OPle: /* (u <= 0) becomes (u == 0) */ + if (!uns) + break; + /* FALL-THROUGH */ + case OPeqeq: + e->Eoper = OPnot; + goto L5; + case OPgt: /* (u > 0) becomes (u != 0) */ + if (!uns) + break; + /* FALL-THROUGH */ + case OPne: + e->Eoper = OPbool; + L5: el_free(e2); + e->E2 = NULL; + e = optelem(e,TRUE); + break; + + case OPge: + i = 1; /* (u >= 0) becomes (u,1) */ + goto L3; + case OPlt: /* (u < 0) becomes (u,0) */ + i = 0; + L3: + if (uns) + { + e2->EV.Vint = i; + e2->Ety = TYint; + e->Eoper = OPcomma; + e = optelem(e,TRUE); + } + break; + } + } + else if (OPTIMIZER && uns && tysize(e2->Ety) == 2 && + (unsigned short)e2->EV.Vuns == 0x8000 && + (e->Eoper == OPlt || e->Eoper == OPge) + ) + { // Convert to signed comparison against 0 + tym_t ty; + + ty = tybasic(e2->Ety); + switch (tysize[ty]) + { case 1: ty = TYschar; break; + case 2: ty = TYshort; break; + default: assert(0); + } + e->Eoper ^= (OPlt ^ OPge); // switch between them + e2->EV.Vuns = 0; + e2->Ety = ty | (e2->Ety & ~mTYbasic); + e1->Ety = ty | (e1->Ety & ~mTYbasic); + } + else if (OPTIMIZER && e1->Eoper == OPeq && + e1->E2->Eoper == OPconst) + { // Convert ((x = c1) rel c2) to ((x = c1),(c1 rel c2) + elem *ec; + + ec = el_copytree(e1->E2); + ec->Ety = e1->Ety; + e->E1 = ec; + e = el_bin(OPcomma,e->Ety,e1,e); + e = optelem(e,TRUE); + } + } + else if (( + (e1->Eoper == OPu8_16 || e1->Eoper == OPs8_16) + || (e1->Eoper == OPu16_32 || e1->Eoper == OPs16_32) + ) && e1->Eoper == e2->Eoper) + { if (uns) + { e1->E1->Ety = touns(e1->E1->Ety); + e2->E1->Ety = touns(e2->E1->Ety); + } + e1->Ety = e1->E1->Ety; + e2->Ety = e2->E1->Ety; + e->E1 = el_selecte1(e1); + e->E2 = el_selecte1(e2); + e = optelem(e,TRUE); + } +ret: + return e; +} + +/***************************** + * Boolean operator. + * bool c => (bool c) + * bool logical_operator e => logical_operator e + */ + +STATIC elem * elbool(elem *e) +{ + if (OTlogical(e->E1->Eoper) || + (tybasic(e->E1->Ety) == TYbool && tysize(e->Ety) == 1) + ) + return el_selecte1(e); + if (OPTIMIZER) + { + // Replace bool(x,1) with (x,1),1 + elem *e1 = elscancommas(e->E1); + if (cnst(e1) || e1->Eoper == OPrelconst) + { + int i = boolres(e1) != 0; + e->Eoper = OPcomma; + e->E2 = el_int(e->Ety,i); + e = optelem(e,TRUE); + } + + // Replace bool(e & 1) with (unsigned char)(e & 1) + else if (e->E1->Eoper == OPand && e->E1->E2->Eoper == OPconst && el_tolong(e->E1->E2) == 1) + { unsigned sz = tysize(e->E1->Ety); + tym_t ty = e->Ety; + switch (sz) + { + case 1: + e = el_selecte1(e); + break; + case 2: + e->Eoper = OP16_8; + break; + case 4: + e->Eoper = OP32_16; + e->Ety = TYushort; + e = el_una(OP16_8, ty, e); + break; + case 8: + e->Eoper = OP64_32; + e->Ety = TYulong; + e = el_una(OP32_16, TYushort, e); + e = el_una(OP16_8, ty, e); + break; + default: + assert(0); + } + e = optelem(e,TRUE); + } + + // Replace bool(e % 2) with (unsigned char)(e & 1) + else if (e->E1->Eoper == OPmod && e->E1->E2->Eoper == OPconst && el_tolong(e->E1->E2) == 2) + { unsigned sz = tysize(e->E1->Ety); + tym_t ty = e->Ety; + e->E1->Eoper = OPand; + e->E1->E2->EV.Vullong = 1; + switch (sz) + { + case 1: + e = el_selecte1(e); + break; + case 2: + e->Eoper = OP16_8; + break; + case 4: + e->Eoper = OP32_16; + e->Ety = TYushort; + e = el_una(OP16_8, ty, e); + break; + case 8: + e->Eoper = OP64_32; + e->Ety = TYulong; + e = el_una(OP32_16, TYushort, e); + e = el_una(OP16_8, ty, e); + break; + default: + assert(0); + } + e = optelem(e,TRUE); + } + } + return e; +} + + +#if TARGET_SEGMENTED +/********************************* + * Conversions of pointers to far pointers. + */ + +STATIC elem * elptrlptr(elem *e) +{ + if (e->E1->Eoper == OPrelconst || e->E1->Eoper == OPstring) + { + e->E1->Ety = e->Ety; + e = el_selecte1(e); + } + return e; +} + +/********************************* + * Conversions of handle pointers to far pointers. + */ +STATIC elem * elvptrfptr(elem *e) +{ elem *e1; + elem *e12; + int op; + + e1 = e->E1; + if (e1->Eoper == OPadd || e1->Eoper == OPmin) + { + e12 = e1->E2; + if (tybasic(e12->Ety) != TYvptr) + { + /* Rewrite (vtof(e11 + e12)) to (vtof(e11) + e12) */ + op = e->Eoper; + e->Eoper = e1->Eoper; + e->E2 = e12; + e1->Ety = e->Ety; + e1->Eoper = op; + e1->E2 = NULL; + e = optelem(e,TRUE); + } + } + return e; +} + +#endif + +/************************ + * Optimize conversions of longs to ints. + * Also used for (OPoffset) (TYfptr|TYvptr). + * Also used for conversions of ints to bytes. + */ + +STATIC elem * ellngsht(elem *e) +{ elem *e1; + tym_t ty; + + ty = e->Ety; + e1 = e->E1; + switch (e1->Eoper) + { case OPs16_32: + case OPu16_32: + case OPu8_16: + case OPs8_16: + /* This fix is not quite right. For example, it fails */ + /* if e->Ety != e->E1->E1->Ety. The difference is when */ + /* one is unsigned and the other isn't. */ + if (tysize(ty) != tysize(e->E1->E1->Ety)) + break; + e = el_selecte1(el_selecte1(e)); + e->Ety = ty; + return e; + case OPvar: /* simply paint type of variable */ + /* Do not paint type of ints into bytes, as this causes */ + /* many CSEs to be missed, resulting in bad code. */ + /* Loading a word anyway is just as fast as loading a byte. */ + /* for 68000 byte is swapped, load byte != load word */ + if (e->Eoper == OP16_8) + { + /* Mark symbol as being used sometimes as a byte to */ + /* 80X86 - preclude using SI or DI */ + /* 68000 - preclude using An */ + e1->EV.sp.Vsym->Sflags |= GTbyte; + } + else + e1->Ety = ty; + e = el_selecte1(e); + break; + case OPind: + e = el_selecte1(e); + break; + +#if TARGET_SEGMENTED + case OPnp_fp: + if (e->Eoper != OPoffset) + goto case_default; + // Replace (offset)(ptrlptr)e11 with e11 + e = el_selecte1(el_selecte1(e)); + e->Ety = ty; // retain original type + break; +#endif + + default: /* operator */ + case_default: + /* Attempt to replace (lngsht)(a op b) with */ + /* ((lngsht)a op (lngsht)b). */ + /* op is now an integer op, which is cheaper. */ + if (OTwid(e1->Eoper) && !OTassign(e1->Eoper)) + { tym_t ty1; + + ty1 = e1->E1->Ety; + switch (e->Eoper) + { case OP16_8: + /* Make sure e1->E1 is of the type we're converting from */ + if (tysize(ty1) <= intsize) + { + ty1 = (tyuns(ty1) ? TYuchar : TYschar) | + (ty1 & ~mTYbasic); + e1->E1 = el_una(e->Eoper,ty1,e1->E1); + } + /* Rvalue may be an int if it is a shift operator */ + if (OTbinary(e1->Eoper)) + { tym_t ty2 = e1->E2->Ety; + + if (tysize(ty2) <= intsize) + { + ty2 = (tyuns(ty2) ? TYuchar : TYschar) | + (ty2 & ~mTYbasic); + e1->E2 = el_una(e->Eoper,ty2,e1->E2); + } + } + break; +#if TARGET_SEGMENTED + case OPoffset: + if (intsize == LONGSIZE) + { + /* Make sure e1->E1 is of the type we're converting from */ + if (tysize(ty1) > LONGSIZE) + { + ty1 = (tyuns(ty1) ? TYuint : TYint) | (ty1 & ~mTYbasic); + e1->E1 = el_una(e->Eoper,ty1,e1->E1); + } + /* Rvalue may be an int if it is a shift operator */ + if (OTbinary(e1->Eoper)) + { tym_t ty2 = e1->E2->Ety; + + if (tysize(ty2) > LONGSIZE) + { + ty2 = (tyuns(ty2) ? TYuint : TYint) | + (ty2 & ~mTYbasic); + e1->E2 = el_una(e->Eoper,ty2,e1->E2); + } + } + break; + } + /* FALL-THROUGH */ +#endif + case OP32_16: + /* Make sure e1->E1 is of the type we're converting from */ + if (tysize(ty1) == LONGSIZE) + { + ty1 = (tyuns(ty1) ? TYushort : TYshort) | (ty1 & ~mTYbasic); + e1->E1 = el_una(e->Eoper,ty1,e1->E1); + } + /* Rvalue may be an int if it is a shift operator */ + if (OTbinary(e1->Eoper)) + { tym_t ty2 = e1->E2->Ety; + + if (tysize(ty2) == LONGSIZE) + { + ty2 = (tyuns(ty2) ? TYushort : TYshort) | + (ty2 & ~mTYbasic); + e1->E2 = el_una(e->Eoper,ty2,e1->E2); + } + } + break; + default: + assert(0); + } + e1->Ety = ty; + e = el_selecte1(e); + again = 1; + return e; + } + break; + } + return e; +} + + +/************************ + * Optimize conversions of long longs to ints. + * OP64_32, OP128_64 + */ + +STATIC elem * el64_32(elem *e) +{ + tym_t ty = e->Ety; + elem *e1 = e->E1; + switch (e1->Eoper) + { + case OPs32_64: + case OPu32_64: + case OPs64_128: + case OPu64_128: + case OPpair: + if (tysize(ty) != tysize(e->E1->E1->Ety)) + break; + e = el_selecte1(el_selecte1(e)); + e->Ety = ty; + break; + + case OPrpair: + if (tysize(ty) != tysize(e->E1->E2->Ety)) + break; + e = el_selecte2(el_selecte1(e)); + e->Ety = ty; + break; + + case OPvar: // simply paint type of variable + case OPind: + e = el_selecte1(e); + break; + + case OPshr: // OP64_32(x >> 32) => OPmsw(x) + if (e1->E2->Eoper == OPconst && + (e->Eoper == OP64_32 && el_tolong(e1->E2) == 32 && !I64 || + e->Eoper == OP128_64 && el_tolong(e1->E2) == 64 && I64) + ) + { + e->Eoper = OPmsw; + e->E1 = el_selecte1(e->E1); + } + break; + } + return e; +} + + +/******************************* + * Convert complex to real. + */ + +STATIC elem *elc_r(elem *e) +{ + elem *e1 = e->E1; + + if (e1->Eoper == OPvar || e1->Eoper == OPind) + { + e1->Ety = e->Ety; + e = el_selecte1(e); + } + return e; +} + +/******************************* + * Convert complex to imaginary. + */ + +STATIC elem *elc_i(elem *e) +{ + elem *e1 = e->E1; + + if (e1->Eoper == OPvar) + { + e1->Ety = e->Ety; + e1->EV.sp.Voffset += tysize(e->Ety); + e = el_selecte1(e); + } + else if (e1->Eoper == OPind) + { + e1->Ety = e->Ety; + e = el_selecte1(e); + e->E1 = el_bin(OPadd, e->E1->Ety, e->E1, el_long(TYint, tysize(e->Ety))); + return optelem(e, TRUE); + } + + return e; +} + +/****************************** + * Handle OPu8_16 and OPs8_16. + */ + +STATIC elem * elbyteint(elem *e) +{ + if (OTlogical(e->E1->Eoper)) + { + e->E1->Ety = e->Ety; + e = el_selecte1(e); + } + return e; +} + +/************************ + * Handle <<, OProl and OPror + */ + +STATIC elem *elshl(elem *e) +{ + if (e->E1->Eoper == OPconst && !boolres(e->E1)) // if e1 is 0 + { e->E1->Ety = e->Ety; + e = el_selecte1(e); // (0 << e2) => 0 + } + return e; +} + +/************************ + * Handle >> + * OPshr, OPashr + */ + +STATIC elem * elshr(elem *e) +{ +#if TX86 + tym_t ty = e->Ety; + elem *e1 = e->E1; + elem *e2 = e->E2; + + // (x >> 16) replaced with ((shtlng) x+2) + if (OPTIMIZER && + e2->Eoper == OPconst && e2->EV.Vshort == SHORTSIZE * 8 && + tysize(ty) == LONGSIZE) + { + if (e1->Eoper == OPvar) + { + Symbol *s = e1->EV.sp.Vsym; + + if (s->Sclass != SCfastpar) + { + e1->EV.sp.Voffset += SHORTSIZE; // address high word in long + if (I32) + // Cannot independently address high word of register + s->Sflags &= ~GTregcand; + goto L1; + } + } + else if (e1->Eoper == OPind) + { + /* Replace (*p >> 16) with (shtlng)(*(&*p + 2)) */ + e->E1 = el_una(OPind,TYshort, + el_bin(OPadd,e1->E1->Ety, + el_una(OPaddr,e1->E1->Ety,e1), + el_int(TYint,SHORTSIZE))); + L1: + e->Eoper = tyuns(e1->Ety) ? OPu16_32 : OPs16_32; + el_free(e2); + e->E2 = NULL; + e1->Ety = TYshort; + e = optelem(e,TRUE); + } + } + + // (x >> 32) replaced with ((lngllng) x+4) + if (e2->Eoper == OPconst && e2->EV.Vlong == LONGSIZE * 8 && + tysize(ty) == LLONGSIZE) + { + if (e1->Eoper == OPvar) + { + e1->EV.sp.Voffset += LONGSIZE; // address high dword in longlong + if (I64) + // Cannot independently address high word of register + e1->EV.sp.Vsym->Sflags &= ~GTregcand; + goto L2; + } + else if (e1->Eoper == OPind) + { + // Replace (*p >> 32) with (lngllng)(*(&*p + 4)) + e->E1 = el_una(OPind,TYlong, + el_bin(OPadd,e1->E1->Ety, + el_una(OPaddr,e1->E1->Ety,e1), + el_int(TYint,LONGSIZE))); + L2: + e->Eoper = tyuns(e1->Ety) ? OPu32_64 : OPs32_64; + el_free(e2); + e->E2 = NULL; + e1->Ety = TYlong; + e = optelem(e,TRUE); + } + } +#endif + return e; +} + +/*********************************** + * Handle OPpair, OPrpair. + */ + +elem *elpair(elem *e) +{ + elem *e1; + + //printf("elpair()\n"); + e1 = e->E1; + if (e1->Eoper == OPconst) + { + e->E1 = e->E2; + e->E2 = e1; + e->Eoper ^= OPpair ^ OPrpair; + } + return e; +} + +/******************************** + * Handle OPddtor + */ + +elem *elddtor(elem *e) +{ + return e; +} + +/******************************** + * Handle OPinfo, OPmark, OPctor, OPdtor + */ + +STATIC elem * elinfo(elem *e) +{ + //printf("elinfo()\n"); +#if NTEXCEPTIONS && SCPP + if (funcsym_p->Sfunc->Fflags3 & Fnteh) + { // Eliminate cleanup info if using NT structured EH + if (e->Eoper == OPinfo) + e = el_selecte2(e); + else + { el_free(e); + e = el_long(TYint,0); + } + } +#endif + return e; +} + +/******************************************** + */ + +STATIC elem * elhstring(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elnullcheck(elem *e) +{ + return e; +} + + +/******************************************** + */ + +STATIC elem * elclassinit(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elnewarray(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elmultinewarray(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elinstanceof(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elfinalinstanceof(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elcheckcast(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elarraylength(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elarray(elem *e) +{ + return e; +} + +/******************************************** + */ + +STATIC elem * elfield(elem *e) +{ + return e; +} + +/****************************************** + * OPparam + */ + +STATIC void elparamx(elem *e) +{ + //printf("elparam()\n"); + if (e->E1->Eoper == OPrpair) + { + e->E1->Eoper = OPparam; + } + else if (e->E1->Eoper == OPpair && !el_sideeffect(e->E1)) + { + e->E1->Eoper = OPparam; + elem *ex = e->E1->E2; + e->E1->E2 = e->E1->E1; + e->E1->E1 = ex; + } +#if 0 + // Unfortunately, these don't work because if the last parameter + // is a pair, and it is a D function, the last parameter will get + // passed in EAX. + else if (e->E2->Eoper == OPrpair) + { + e->E2->Eoper = OPparam; + } + else if (e->E2->Eoper == OPpair) + { + e->E2->Eoper = OPparam; + elem *ex = e->E2->E2; + e->E2->E2 = e->E2->E1; + e->E2->E1 = ex; + } +#endif +} + +STATIC elem * elparam(elem *e) +{ + if (!OPTIMIZER) + { + if (!I64) + elparamx(e); + } + return e; +} + +/******************************** + * Optimize an element. This routine is recursive! + * Be careful not to do this if VBEs have been done (else the VBE + * work will be undone), or if DAGs have been built (will crash if + * there is more than one parent for an elem). + * If (goal) + * we care about the result. + */ + +STATIC elem * optelem(elem *e,HINT goal) +{ elem *e1,*e2; + unsigned op; +#include "elxxx.c" /* jump table */ + +beg: +#if MARS + util_progress(); +#else + if (controlc_saw) + util_exit(EXIT_BREAK); +#endif + //{ printf("xoptelem: %p ",e); WROP(e->Eoper); dbg_printf(" goal %d\n", goal); } + assert(e); + elem_debug(e); + assert(e->Ecount == 0); // no CSEs + + if (OPTIMIZER) + { + if (goal) + e->Nflags &= ~NFLnogoal; + else + e->Nflags |= NFLnogoal; + } + + op = e->Eoper; + if (OTleaf(op)) // if not an operator node + { + if (goal || OTsideff(op) || e->Ety & mTYvolatile) + { + return e; + } + else + { + retnull: + el_free(e); + return NULL; + } + } + else if (OTbinary(op)) // if binary operator + { HINT leftgoal = 1; + HINT rightgoal; + + /* Determine goals for left and right subtrees */ + rightgoal = (goal || OTsideff(op)); + switch (op) + { case OPcomma: + e1 = e->E1 = optelem(e->E1,FALSE); +// if (e1 && !OTsideff(e1->Eoper)) +// e1 = e->E1 = optelem(e1, FALSE); + e2 = e->E2 = optelem(e->E2,rightgoal); + if (!e1) + { if (!e2) + goto retnull; + if (!goal) + e->Ety = e->E2->Ety; + e = el_selecte2(e); + return e; + } + if (!e2) + { e->Ety = e->E1->Ety; + return el_selecte1(e); + } + if (!goal) + e->Ety = e2->Ety; + return e; + + case OPcond: + if (!goal) + { // Transform x?y:z into x&&y or x||z + if (!el_sideeffect(e->E2->E1)) + { e->Eoper = OPoror; + e->E2 = el_selecte2(e->E2); + e->Ety = TYint; + goto beg; + } + else if (!el_sideeffect(e->E2->E2)) + { e->Eoper = OPandand; + e->E2 = el_selecte1(e->E2); + e->Ety = TYint; + goto beg; + } + } + goto Llog; + + case OPandand: + case OPoror: /* case (c || f()) with no goal */ + Llog: + if (goal || el_sideeffect(e->E2)) + leftgoal = TRUE; + break; + + default: + leftgoal = rightgoal; + break; + case OPcolon: + case OPcolon2: + if (!goal && !el_sideeffect(e)) + goto retnull; + leftgoal = rightgoal; + break; +#if TX86 + case OPmemcmp: + if (!goal) + { // So OPmemcmp is removed cleanly + assert(e->E1->Eoper == OPparam); + e->E1->Eoper = OPcomma; + } + leftgoal = rightgoal; + break; +#endif + } + + e1 = e->E1; + if (OTassign(op)) + { elem *ex = e1; + + while (OTconv(ex->Eoper)) + ex = ex->E1; + if (ex->Eoper == OPbit) + ex->E1 = optelem(ex->E1, leftgoal); + else + e1 = e->E1 = optelem(e1,leftgoal); + } + else + e1 = e->E1 = optelem(e1,leftgoal); + + e2 = e->E2 = optelem(e->E2,rightgoal); + if (!e1) + { if (!e2) + goto retnull; + return el_selecte2(e); + } + if (!e2) + { + if (!leftgoal) + e->Ety = e1->Ety; + return el_selecte1(e); + } + if (op == OPparam && !goal) + e->Eoper = OPcomma; // DMD bug 6733 + + if (cnst(e1) && cnst(e2)) + { + e = evalu8(e); + return e; + } + if (OPTIMIZER) + { + if (OTassoc(op)) + { + /* Replace (a op1 (b op2 c)) with ((a op2 b) op1 c) + (this must come before the leaf swapping, or we could cause + infinite loops) + */ + if (e2->Eoper == op && + e2->E2->Eoper == OPconst && + tysize(e2->E1->Ety) == tysize(e2->E2->Ety) && + (!tyfloating(e1->Ety) || e1->Ety == e2->Ety) + ) + { + e->E1 = e2; + e->E2 = e2->E2; + e2->E2 = e2->E1; + e2->E1 = e1; + if (op == OPadd) /* fix types */ + { + e1 = e->E1; + if (typtr(e1->E2->Ety)) + e1->Ety = e1->E2->Ety; + else + /* suppose a and b are ints, and c is a pointer */ + /* then this will fix the type of op2 to be int */ + e1->Ety = e1->E1->Ety; + } + goto beg; + } + + // Replace ((a op c1) op c2) with (a op (c2 op c1)) + if (e1->Eoper == op && + e2->Eoper == OPconst && + e1->E2->Eoper == OPconst && + e1->E1->Eoper != OPconst && + tysize(e2->Ety) == tysize(e1->E2->Ety)) + { + e->E1 = e1->E1; + e1->E1 = e2; + e1->Ety = e2->Ety; + e->E2 = e1; + + if (tyfloating(e1->Ety)) + { + e1 = evalu8(e1); + if (EOP(e1)) // if failed to fold the constants + { // Undo the changes so we don't infinite loop + e->E2 = e1->E1; + e1->E1 = e->E1; + e->E1 = e1; + } + else + { e->E2 = e1; + goto beg; + } + } + else + goto beg; + } + } + + if (!OTrtol(op) && op != OPparam && op != OPcolon && op != OPcolon2 && + e1->Eoper == OPcomma) + { // Convert ((a,b) op c) to (a,(b op c)) + e1->Ety = e->Ety; + e1->ET = e->ET; + e->E1 = e1->E2; + e1->E2 = e; + e = e1; + goto beg; + } + } + + if (OTcommut(op)) // if commutative + { + /* see if we should swap the leaves */ +#if 0 + if (tyfloating(e1->Ety)) + { + if (fcost(e2) > fcost(e1)) + { e->E1 = e2; + e2 = e->E2 = e1; + e1 = e->E1; // reverse the leaves + op = e->Eoper = swaprel(op); + } + } + else +#endif + if ( +#if MARS + cost(e2) > cost(e1) + /* Swap only if order of evaluation can be proved + * to not matter, as we must evaluate Left-to-Right + */ + && (e1->Eoper == OPconst || + e1->Eoper == OPrelconst || + /* Local variables that are not aliased + * and are not assigned to in e2 + */ + (e1->Eoper == OPvar && e1->EV.sp.Vsym->Sflags & SFLunambig && !el_appears(e2,e1->EV.sp.Vsym)) || + !(el_sideeffect(e1) || el_sideeffect(e2)) + ) +#else + cost(e2) > cost(e1) +#endif + ) + { + e->E1 = e2; + e2 = e->E2 = e1; + e1 = e->E1; // reverse the leaves + op = e->Eoper = swaprel(op); + } + if (OTassoc(op)) // if commutative and associative + { + if (EOP(e1) && + op == e1->Eoper && + e1->E2->Eoper == OPconst && + e->Ety == e1->Ety && + tysize(e1->E2->Ety) == tysize(e2->Ety) +#if MARS + // Reordering floating point can change the semantics + && !tyfloating(e1->Ety) +#endif + ) + { + // look for ((e op c1) op c2), + // replace with (e op (c1 op c2)) + if (e2->Eoper == OPconst) + { + e->E1 = e1->E1; + e->E2 = e1; + e1->E1 = e1->E2; + e1->E2 = e2; + e1->Ety = e2->Ety; + + e1 = e->E1; + e2 = e->E2 = evalu8(e->E2); + } + else + { // Replace ((e op c) op e2) with ((e op e2) op c) + e->E2 = e1->E2; + e1->E2 = e2; + e2 = e->E2; + } + } + } + } + + if (e2->Eoper == OPconst && // if right operand is a constant + !(OTopeq(op) && OTconv(e1->Eoper)) + ) + { +#ifdef DEBUG + assert(!(OTeop0e(op) && (OTeop00(op)))); +#endif + if (OTeop0e(op)) /* if e1 op 0 => e1 */ + { + if (!boolres(e2)) /* if e2 is 0 */ + { + // Don't do it for ANSI floating point + if (tyfloating(e1->Ety) && !(config.flags4 & CFG4fastfloat)) + ; + // Don't do it if we're assembling a complex value + else if ((tytab[e->E1->Ety & 0xFF] ^ + tytab[e->E2->Ety & 0xFF]) == (TYFLreal | TYFLimaginary)) + ; + else + return optelem(el_selecte1(e),goal); + } + } + else if (OTeop00(op) && !boolres(e2) && !tyfloating(e->Ety)) + { if (OTassign(op)) + op = e->Eoper = OPeq; + else + op = e->Eoper = OPcomma; + } + if (OTeop1e(op)) /* if e1 op 1 => e1 */ + { + if (elemisone(e2) && !tyimaginary(e2->Ety)) + return optelem(el_selecte1(e),goal); + } + } + + if (OTpost(op) && !goal) + { + op = e->Eoper = (op == OPpostinc) ? OPaddass : OPminass; + } + } + else /* unary operator */ + { + assert(!e->E2 || op == OPinfo || op == OParraylength || op == OPddtor); + if (!goal && !OTsideff(op)) + { + tym_t tym = e->E1->Ety; + + e = el_selecte1(e); + e->Ety = tym; + return optelem(e,FALSE); + } + + e1 = e->E1 = optelem(e->E1,TRUE); + if (e1->Eoper == OPconst) + { +#if TARGET_SEGMENTED + if (!(op == OPnp_fp && el_tolong(e1) != 0)) +#endif + return evalu8(e); + } + e2 = NULL; + } + +L1: +#ifdef DEBUG +// if (debugb) +// { dbg_printf("optelem: %p ",e); WROP(op); dbg_printf("\n"); } +#endif + + expgoal = goal; +#if 0 + { dbg_printf("xoptelem: %p ",e); WROP(e->Eoper); dbg_printf("\n"); } + elem_print(e); + e = (*elxxx[op])(e); + printf("After:\n"); + elem_print(e); + return e; +#else + return (*elxxx[op])(e); +#endif +} + +/******************************** + * Optimize and canonicalize an expression tree. + * Fiddle with double operators so that the rvalue is a pointer + * (this is needed by the 8086 code generator). + * + * op op + * / \ / \ + * e1 e2 e1 , + * / \ + * = & + * / \ \ + * fr e2 fr + * + * e1 op (*p) e1 op p + * e1 op c e1 op &dc + * e1 op v e1 op &v + */ + +elem *doptelem(elem *e,HINT goal) +{ + //printf("doptelem(e = %p, goal = %d)\n", e, goal); + cgelem_goal = goal; + + assert(!PARSER); + do + { again = 0; + e = optelem(e,goal & (GOALflags | GOALvalue | GOALnone)); + } while (again && goal & GOALagain && e); + + /* If entire expression is a struct, and we can replace it with */ + /* something simpler, do so. */ + if (goal & GOALstruct && e && tybasic(e->Ety) == TYstruct) + e = elstruct(e); + + return e; +} + +/**************************************** + * Do optimizations after bltailrecursion() and before common subexpressions. + */ + +void postoptelem(elem *e) +{ + int linnum = 0; + const char *filename = NULL; + + elem_debug(e); + while (1) + { + if (OTunary(e->Eoper)) + { + /* This is necessary as the optimizer tends to lose this information + */ +#if MARS + if (e->Esrcpos.Slinnum > linnum) + { linnum = e->Esrcpos.Slinnum; + filename = e->Esrcpos.Sfilename; + } +#endif + if (e->Eoper == OPind) + { +#if MARS + if (e->E1->Eoper == OPconst && + el_tolong(e->E1) >= 0 && el_tolong(e->E1) < 4096) + { + error(filename, linnum, "null dereference in function %s", funcsym_p->Sident); + e->E1->EV.Vlong = 4096; // suppress redundant messages + } +#endif + } + e = e->E1; + } + else if (OTbinary(e->Eoper)) + { +#if MARS + /* This is necessary as the optimizer tends to lose this information + */ + if (e->Esrcpos.Slinnum > linnum) + { linnum = e->Esrcpos.Slinnum; + filename = e->Esrcpos.Sfilename; + } +#endif + if (e->Eoper == OPparam) + { + if (!I64) + elparamx(e); + } + postoptelem(e->E2); + e = e->E1; + } + else + break; + } +} + +#endif // !SPP diff --git a/backend/cgen.c b/backend/cgen.c new file mode 100644 index 00000000..ae0be342 --- /dev/null +++ b/backend/cgen.c @@ -0,0 +1,781 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "global.h" +#include "aa.h" +#include "dt.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/************************************* + * Handy function to answer the question: who the heck is generating this piece of code? + */ +inline void ccheck(code *cs) +{ +// if (cs->Iop == LEA && (cs->Irm & 0x3F) == 0x34 && cs->Isib == 7) *(char*)0=0; +// if (cs->Iop == 0x31) *(char*)0=0; +// if (cs->Irm == 0x3D) *(char*)0=0; +} + +/***************************** + * Find last code in list. + */ + +code *code_last(code *c) +{ + if (c) + { while (c->next) + c = c->next; + } + return c; +} + +/***************************** + * Set flag bits on last code in list. + */ + +void code_orflag(code *c,unsigned flag) +{ + if (flag && c) + { while (c->next) + c = c->next; + c->Iflags |= flag; + } +} + +/***************************** + * Set rex bits on last code in list. + */ + +void code_orrex(code *c,unsigned rex) +{ + if (rex && c) + { while (c->next) + c = c->next; + c->Irex |= rex; + } +} + +/************************************** + * Set the opcode fields in cs. + */ +code *setOpcode(code *c, code *cs, unsigned op) +{ + cs->Iop = op; + return c; +} + +/***************************** + * Concatenate two code lists together. Return pointer to result. + */ + +#if TX86 && __INTSIZE == 4 && __SC__ +__declspec(naked) code * __pascal cat(code *c1,code *c2) +{ + _asm + { + mov EAX,c1-4[ESP] + mov ECX,c2-4[ESP] + test EAX,EAX + jne L6D + mov EAX,ECX + ret 8 + +L6D: mov EDX,EAX + cmp dword ptr [EAX],0 + je L7B +L74: mov EDX,[EDX] + cmp dword ptr [EDX],0 + jne L74 +L7B: mov [EDX],ECX + ret 8 + } +} +#else +code * __pascal cat(code *c1,code *c2) +{ code **pc; + + if (!c1) + return c2; + for (pc = &code_next(c1); *pc; pc = &code_next(*pc)) + ; + *pc = c2; + return c1; +} +#endif + +code * cat3(code *c1,code *c2,code *c3) +{ code **pc; + + for (pc = &c1; *pc; pc = &code_next(*pc)) + ; + for (*pc = c2; *pc; pc = &code_next(*pc)) + ; + *pc = c3; + return c1; +} + +code * cat4(code *c1,code *c2,code *c3,code *c4) +{ code **pc; + + for (pc = &c1; *pc; pc = &code_next(*pc)) + ; + for (*pc = c2; *pc; pc = &code_next(*pc)) + ; + for (*pc = c3; *pc; pc = &code_next(*pc)) + ; + *pc = c4; + return c1; +} + +code * cat6(code *c1,code *c2,code *c3,code *c4,code *c5,code *c6) +{ return cat(cat4(c1,c2,c3,c4),cat(c5,c6)); } + +/***************************** + * Add code to end of linked list. + * Note that unused operands are garbage. + * gen1() and gen2() are shortcut routines. + * Input: + * c -> linked list that code is to be added to end of + * cs -> data for the code + * Returns: + * pointer to start of code list + */ + +code *gen(code *c,code *cs) +{ code *ce,*cstart; + unsigned reg; + +#ifdef DEBUG /* this is a high usage routine */ + assert(cs); +#endif + assert(I64 || cs->Irex == 0); + ce = code_calloc(); + *ce = *cs; + //printf("ce = %p %02x\n", ce, ce->Iop); + ccheck(ce); + if (config.flags4 & CFG4optimized && + (ce->Iop == 0x81 || ce->Iop == 0x80) && + ce->IFL2 == FLconst && + reghasvalue((ce->Iop == 0x80) ? BYTEREGS : ALLREGS,I64 ? ce->IEV2.Vsize_t : ce->IEV2.Vlong,®) && + !(ce->Iflags & CFopsize && I16) + ) + { // See if we can replace immediate instruction with register instruction + static unsigned char regop[8] = + { 0x00,0x08,0x10,0x18,0x20,0x28,0x30,0x38 }; + + //printf("replacing 0x%02x, val = x%lx\n",ce->Iop,ce->IEV2.Vlong); + ce->Iop = regop[(ce->Irm & modregrm(0,7,0)) >> 3] | (ce->Iop & 1); + code_newreg(ce, reg); + } + code_next(ce) = CNIL; + if (c) + { cstart = c; + while (code_next(c)) c = code_next(c); /* find end of list */ + code_next(c) = ce; /* link into list */ + return cstart; + } + return ce; +} + +code *gen1(code *c,unsigned op) +{ code *ce,*cstart; + + ce = code_calloc(); + ce->Iop = op; + ccheck(ce); + assert(op != LEA); + if (c) + { cstart = c; + while (code_next(c)) c = code_next(c); /* find end of list */ + code_next(c) = ce; /* link into list */ + return cstart; + } + return ce; +} + +code *gen2(code *c,unsigned op,unsigned rm) +{ code *ce,*cstart; + + cstart = ce = code_calloc(); + /*cxcalloc++;*/ + ce->Iop = op; + ce->Iea = rm; + ccheck(ce); + if (c) + { cstart = c; + while (code_next(c)) c = code_next(c); /* find end of list */ + code_next(c) = ce; /* link into list */ + } + return cstart; +} + +code *gen2sib(code *c,unsigned op,unsigned rm,unsigned sib) +{ code *ce,*cstart; + + cstart = ce = code_calloc(); + /*cxcalloc++;*/ + ce->Iop = op; + ce->Irm = rm; + ce->Isib = sib; + ce->Irex = (rm | (sib & (REX_B << 16))) >> 16; + if (sib & (REX_R << 16)) + ce->Irex |= REX_X; + ccheck(ce); + if (c) + { cstart = c; + while (code_next(c)) c = code_next(c); /* find end of list */ + code_next(c) = ce; /* link into list */ + } + return cstart; +} + +/******************************** + * Generate an ASM sequence. + */ + +code *genasm(code *c,char *s,unsigned slen) +{ code *ce; + + ce = code_calloc(); + ce->Iop = ASM; + ce->IFL1 = FLasm; + ce->IEV1.as.len = slen; + ce->IEV1.as.bytes = (char *) mem_malloc(slen); + memcpy(ce->IEV1.as.bytes,s,slen); + return cat(c,ce); +} + +code *gencs(code *c,unsigned op,unsigned ea,unsigned FL2,symbol *s) +{ code cs; + + cs.Iop = op; + cs.Iea = ea; + ccheck(&cs); + cs.Iflags = 0; + cs.IFL2 = FL2; + cs.IEVsym2 = s; + cs.IEVoffset2 = 0; + + return gen(c,&cs); +} + +code *genc2(code *c,unsigned op,unsigned ea,targ_size_t EV2) +{ code cs; + + cs.Iop = op; + cs.Iea = ea; + ccheck(&cs); + cs.Iflags = CFoff; + cs.IFL2 = FLconst; + cs.IEV2.Vsize_t = EV2; + return gen(c,&cs); +} + +/***************** + * Generate code. + */ + +code *genc1(code *c,unsigned op,unsigned ea,unsigned FL1,targ_size_t EV1) +{ code cs; + + assert(FL1 < FLMAX); + cs.Iop = op; + cs.Iflags = CFoff; + cs.Iea = ea; + ccheck(&cs); + cs.IFL1 = FL1; + cs.IEV1.Vsize_t = EV1; + return gen(c,&cs); +} + +/***************** + * Generate code. + */ + +code *genc(code *c,unsigned op,unsigned ea,unsigned FL1,targ_size_t EV1,unsigned FL2,targ_size_t EV2) +{ code cs; + + assert(FL1 < FLMAX); + cs.Iop = op; + cs.Iea = ea; + ccheck(&cs); + cs.Iflags = CFoff; + cs.IFL1 = FL1; + cs.IEV1.Vsize_t = EV1; + assert(FL2 < FLMAX); + cs.IFL2 = FL2; + cs.IEV2.Vsize_t = EV2; + return gen(c,&cs); +} + +/******************************** + * Generate 'instruction' which is actually a line number. + */ + +code *genlinnum(code *c,Srcpos srcpos) +{ code cs; + +#if 0 + srcpos.print("genlinnum"); +#endif + cs.Iop = ESCAPE | ESClinnum; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = 0; + cs.IFL2 = 0; + cs.IEV1.Vsrcpos = srcpos; + return gen(c,&cs); +} + +/****************************** + * Append line number to existing code. + */ + +void cgen_linnum(code **pc,Srcpos srcpos) +{ + *pc = genlinnum(*pc,srcpos); +} + +/***************************** + * Prepend line number to existing code. + */ + +void cgen_prelinnum(code **pc,Srcpos srcpos) +{ + *pc = cat(genlinnum(NULL,srcpos),*pc); +} + +/******************************** + * Generate 'instruction' which tells the address resolver that the stack has + * changed. + */ + +code *genadjesp(code *c, int offset) +{ code cs; + + if (!I16 && offset) + { + cs.Iop = ESCAPE | ESCadjesp; + cs.Iflags = 0; + cs.Irex = 0; + cs.IEV1.Vint = offset; + return gen(c,&cs); + } + else + return c; +} + +/******************************** + * Generate 'instruction' which tells the scheduler that the fpu stack has + * changed. + */ + +code *genadjfpu(code *c, int offset) +{ code cs; + + if (!I16 && offset) + { + cs.Iop = ESCAPE | ESCadjfpu; + cs.Iflags = 0; + cs.Irex = 0; + cs.IEV1.Vint = offset; + return gen(c,&cs); + } + else + return c; +} + +/******************************** + * Generate 'nop' + */ + +code *gennop(code *c) +{ + return gen1(c,NOP); +} + + +/**************************************** + * Clean stack after call to codelem(). + */ + +code *gencodelem(code *c,elem *e,regm_t *pretregs,bool constflag) +{ + if (e) + { + unsigned stackpushsave; + int stackcleansave; + + stackpushsave = stackpush; + stackcleansave = cgstate.stackclean; + cgstate.stackclean = 0; // defer cleaning of stack + c = cat(c,codelem(e,pretregs,constflag)); + assert(cgstate.stackclean == 0); + cgstate.stackclean = stackcleansave; + c = genstackclean(c,stackpush - stackpushsave,*pretregs); // do defered cleaning + } + return c; +} + +/********************************** + * Determine if one of the registers in regm has value in it. + * If so, return !=0 and set *preg to which register it is. + */ + +bool reghasvalue(regm_t regm,targ_size_t value,unsigned *preg) +{ + //printf("reghasvalue(%s, %llx)\n", regm_str(regm), (unsigned long long)value); + /* See if another register has the right value */ + unsigned r = 0; + for (regm_t mreg = regcon.immed.mval; mreg; mreg >>= 1) + { + if (mreg & regm & 1 && regcon.immed.value[r] == value) + { *preg = r; + return TRUE; + } + r++; + regm >>= 1; + } + return FALSE; +} + +/************************************** + * Load a register from the mask regm with value. + * Output: + * *preg the register selected + */ + +code *regwithvalue(code *c,regm_t regm,targ_size_t value,unsigned *preg,regm_t flags) +{ unsigned reg; + + if (!preg) + preg = ® + + /* If we don't already have a register with the right value in it */ + if (!reghasvalue(regm,value,preg)) + { regm_t save; + + save = regcon.immed.mval; + c = cat(c,allocreg(®m,preg,TYint)); // allocate register + regcon.immed.mval = save; + c = movregconst(c,*preg,value,flags); // store value into reg + } + return c; +} + +/************************ + * When we don't know whether a function symbol is defined or not + * within this module, we stuff it in this linked list of references + * to be fixed up later. + */ + +struct fixlist +{ //symbol *Lsymbol; // symbol we don't know about + int Lseg; // where the fixup is going (CODE or DATA, never UDATA) + int Lflags; // CFxxxx + targ_size_t Loffset; // addr of reference to symbol + targ_size_t Lval; // value to add into location +#if TARGET_OSX + symbol *Lfuncsym; // function the symbol goes in +#endif + fixlist *Lnext; // next in threaded list + + static AArray *start; + static int nodel; // don't delete from within searchfixlist +}; + +AArray *fixlist::start = NULL; +int fixlist::nodel = 0; + +/* The AArray, being hashed on the pointer value of the symbol s, is in a different + * order from run to run. This plays havoc with trying to compare the .obj file output. + * When needing to do that, set FLARRAY to 1. This will replace the AArray with a + * simple (and very slow) linear array. Handy for tracking down compiler issues, though. + */ +#define FLARRAY 0 +#if FLARRAY +struct Flarray +{ + symbol *s; + fixlist *fl; +}; + +Flarray *flarray; +size_t flarray_dim; +size_t flarray_max; +#endif + +/**************************** + * Add to the fix list. + */ + +void addtofixlist(symbol *s,targ_size_t soffset,int seg,targ_size_t val,int flags) +{ fixlist *ln; + static char zeros[8]; + int numbytes; + + //printf("addtofixlist(%p '%s')\n",s,s->Sident); + assert(flags); + ln = (fixlist *) mem_calloc(sizeof(fixlist)); + //ln->Lsymbol = s; + ln->Loffset = soffset; + ln->Lseg = seg; + ln->Lflags = flags; + ln->Lval = val; +#if TARGET_OSX + ln->Lfuncsym = funcsym_p; +#endif + +#if FLARRAY + fixlist **pv; + for (size_t i = 0; 1; i++) + { + if (i == flarray_dim) + { + if (flarray_dim == flarray_max) + { + flarray_max = flarray_max * 2 + 1000; + flarray = (Flarray *)mem_realloc(flarray, flarray_max * sizeof(flarray[0])); + } + flarray_dim += 1; + flarray[i].s = s; + flarray[i].fl = NULL; + pv = &flarray[i].fl; + break; + } + if (flarray[i].s == s) + { + pv = &flarray[i].fl; + break; + } + } +#else + if (!fixlist::start) + fixlist::start = new AArray(&ti_pvoid, sizeof(fixlist *)); + fixlist **pv = (fixlist **)fixlist::start->get(&s); +#endif + ln->Lnext = *pv; + *pv = ln; + +#if TARGET_SEGMENTED + switch (flags & (CFoff | CFseg)) + { + case CFoff: numbytes = tysize[TYnptr]; break; + case CFseg: numbytes = 2; break; + case CFoff | CFseg: numbytes = tysize[TYfptr]; break; + default: assert(0); + } +#else + numbytes = tysize[TYnptr]; + if (I64 && !(flags & CFoffset64)) + numbytes = 4; + assert(!(flags & CFseg)); +#endif +#ifdef DEBUG + assert(numbytes <= sizeof(zeros)); +#endif + obj_bytes(seg,soffset,numbytes,zeros); +} + +/**************************** + * Given a function symbol we've just defined the offset for, + * search for it in the fixlist, and resolve any matches we find. + * Input: + * s function symbol just defined + */ + +void searchfixlist(symbol *s) +{ + //printf("searchfixlist(%s)\n",s->Sident); + if (fixlist::start) + { +#if FLARRAY + fixlist **lp = NULL; + size_t i; + for (i = 0; i < flarray_dim; i++) + { + if (flarray[i].s == s) + { lp = &flarray[i].fl; + break; + } + } +#else + fixlist **lp = (fixlist **)fixlist::start->in(&s); +#endif + if (lp) + { fixlist *p; + while ((p = *lp) != NULL) + { + //dbg_printf("Found reference at x%lx\n",p->Loffset); + + // Determine if it is a self-relative fixup we can + // resolve directly. + if (s->Sseg == p->Lseg && + (s->Sclass == SCstatic || +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + (!(config.flags3 & CFG3pic) && s->Sclass == SCglobal)) && +#else + s->Sclass == SCglobal) && +#endif + s->Sxtrnnum == 0 && p->Lflags & CFselfrel) + { targ_size_t ad; + + //printf("Soffset = x%lx, Loffset = x%lx, Lval = x%lx\n",s->Soffset,p->Loffset,p->Lval); + ad = s->Soffset - p->Loffset - REGSIZE + p->Lval; + obj_bytes(p->Lseg,p->Loffset,REGSIZE,&ad); + } + else + { +#if TARGET_OSX + symbol *funcsymsave = funcsym_p; + funcsym_p = p->Lfuncsym; + reftoident(p->Lseg,p->Loffset,s,p->Lval,p->Lflags); + funcsym_p = funcsymsave; +#else + reftoident(p->Lseg,p->Loffset,s,p->Lval,p->Lflags); +#endif + } + *lp = p->Lnext; + mem_free(p); /* remove from list */ + } + if (!fixlist::nodel) + { +#if FLARRAY + flarray[i].s = NULL; + if (i + 1 == flarray_dim) + flarray_dim -= 1; +#else + fixlist::start->del(&s); +#endif + } + } + } +} + +/**************************** + * End of module. Output remaining fixlist elements as references + * to external symbols. + */ + +STATIC int outfixlist_dg(void *parameter, void *pkey, void *pvalue) +{ + //printf("outfixlist_dg(pkey = %p, pvalue = %p)\n", pkey, pvalue); + symbol *s = *(symbol **)pkey; + + fixlist **plnext = (fixlist **)pvalue; + + while (*plnext) + { + fixlist *ln = *plnext; + + symbol_debug(s); + //printf("outfixlist '%s' offset %04x\n",s->Sident,ln->Loffset); + +#if TARGET_SEGMENTED + if (tybasic(s->ty()) == TYf16func) + { + obj_far16thunk(s); /* make it into a thunk */ + searchfixlist(s); + } + else +#endif + { + if (s->Sxtrnnum == 0) + { if (s->Sclass == SCstatic) + { +#if SCPP + if (s->Sdt) + { + outdata(s); + searchfixlist(s); + continue; + } + + synerr(EM_no_static_def,prettyident(s)); // no definition found for static +#else // MARS + printf("Error: no definition for static %s\n",prettyident(s)); // no definition found for static + err_exit(); // BUG: do better +#endif + } + if (s->Sflags & SFLwasstatic) + { + // Put it in BSS + s->Sclass = SCstatic; + s->Sfl = FLunde; + dtnzeros(&s->Sdt,type_size(s->Stype)); + outdata(s); + searchfixlist(s); + continue; + } + s->Sclass = SCextern; /* make it external */ + objextern(s); + if (s->Sflags & SFLweak) + { + obj_wkext(s, NULL); + } + } +#if TARGET_OSX + symbol *funcsymsave = funcsym_p; + funcsym_p = ln->Lfuncsym; + reftoident(ln->Lseg,ln->Loffset,s,ln->Lval,ln->Lflags); + funcsym_p = funcsymsave; +#else + reftoident(ln->Lseg,ln->Loffset,s,ln->Lval,ln->Lflags); +#endif + *plnext = ln->Lnext; +#if TERMCODE + mem_free(ln); +#endif + } + } + s->Sxtrnnum = 0; + return 0; +} + +void outfixlist() +{ + //printf("outfixlist()\n"); +#if FLARRAY + for (size_t i = 0; i < flarray_dim; i++) + { + fixlist::nodel++; + outfixlist_dg(NULL, &flarray[i].s, &flarray[i].fl); + fixlist::nodel--; + } +#else + if (fixlist::start) + { + fixlist::nodel++; + fixlist::start->apply(NULL, &outfixlist_dg); + fixlist::nodel--; +#if TERMCODE + delete fixlist::start; +#endif + fixlist::start = NULL; + } +#endif +} + +#endif // !SPP diff --git a/backend/cgobj.c b/backend/cgobj.c new file mode 100644 index 00000000..60d253b9 --- /dev/null +++ b/backend/cgobj.c @@ -0,0 +1,3680 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !HTOD && (SCPP || MARS) + +#include +#include +#include +#include +#include +#include + +#include "filespec.h" + +#include "cc.h" +#include "global.h" +#include "cgcv.h" +#include "code.h" +#include "type.h" +#include "outbuf.h" + +#include "md5.h" + +#if MARS +struct Loc +{ + char *filename; + unsigned linnum; + + Loc(int x) + { + linnum = x; + filename = NULL; + } +}; + +void error(Loc loc, const char *format, ...); +#endif + +#if OMFOBJ + +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" + +#define MULTISCOPE 1 /* account for bug in MultiScope debugger + where it cannot handle a line number + with multiple offsets. We use a bit vector + to filter out the extra offsets. + */ + +#define TOOFFSET(a,b) (I32 ? TOLONG(a,b) : TOWORD(a,b)) + +/************************** + * Record types: + */ + +#define RHEADR 0x6E +#define REGINT 0x70 +#define REDATA 0x72 +#define RIDATA 0x74 +#define OVLDEF 0x76 +#define ENDREC 0x78 +#define BLKDEF 0x7A +#define BLKEND 0x7C +//#define DEBSYM 0x7E +#define THEADR 0x80 +#define LHEADR 0x82 +#define PEDATA 0x84 +#define PIDATA 0x86 +#define COMENT 0x88 +#define MODEND 0x8A +#define EXTDEF 0x8C +#define TYPDEF 0x8E +#define PUBDEF 0x90 +#define PUB386 0x91 +#define LOCSYM 0x92 +#define LINNUM 0x94 +#define LNAMES 0x96 +#define SEGDEF 0x98 +#define SEG386 0x99 +#define GRPDEF 0x9A +#define FIXUPP 0x9C +#define FIX386 0x9D +#define LEDATA 0xA0 +#define LED386 0xA1 +#define LIDATA 0xA2 +#define LID386 0xA3 +#define LIBHED 0xA4 +#define LIBNAM 0xA6 +#define LIBLOC 0xA8 +#define LIBDIC 0xAA +#define COMDEF 0xB0 +#define LEXTDEF 0xB4 +#define LPUBDEF 0xB6 +#define LCOMDEF 0xB8 +#define CEXTDEF 0xBC +#define COMDAT 0xC2 +#define LINSYM 0xC4 +#define ALIAS 0xC6 +#define LLNAMES 0xCA + +// Some definitions for .OBJ files. Trial and error to determine which +// one to use when. Page #s refer to Intel spec on .OBJ files. + +// Values for LOCAT byte: (pg. 71) +#define LOCATselfrel 0x8000 +#define LOCATsegrel 0xC000 +// OR'd with one of the following: +#define LOClobyte 0x0000 +#define LOCbase 0x0800 +#define LOChibyte 0x1000 +#define LOCloader_resolved 0x1400 + +// Unfortunately, the fixup stuff is different for EASY OMF and Microsoft +#define EASY_LOCoffset 0x1400 // 32 bit offset +#define EASY_LOCpointer 0x1800 // 48 bit seg/offset + +#define LOC32offset 0x2400 +#define LOC32tlsoffset 0x2800 +#define LOC32pointer 0x2C00 + +#define LOC16offset 0x0400 +#define LOC16pointer 0x0C00 + +#define LOCxx 0x3C00 + +// FDxxxx are constants for the FIXDAT byte in fixup records (pg. 72) + +#define FD_F0 0x00 // segment index +#define FD_F1 0x10 // group index +#define FD_F2 0x20 // external index +#define FD_F4 0x40 // canonic frame of LSEG that contains Location +#define FD_F5 0x50 // Target determines the frame + +#define FD_T0 0 // segment index +#define FD_T1 1 // group index +#define FD_T2 2 // external index +#define FD_T4 4 // segment index, 0 displacement +#define FD_T5 5 // group index, 0 displacement +#define FD_T6 6 // external index, 0 displacement + +/*************** + * Fixup list. + */ + +struct FIXUP +{ + struct FIXUP *FUnext; + targ_size_t FUoffset; // offset from start of ledata + unsigned short FUlcfd; // LCxxxx | FDxxxx + unsigned short FUframedatum; + unsigned short FUtargetdatum; +}; + +#define list_fixup(fl) ((struct FIXUP *)list_ptr(fl)) + +#define seg_is_comdat(seg) ((seg) < 0) + +/***************************** + * Ledata records + */ + +#define LEDATAMAX (1024-14) + +struct Ledatarec +{ + char header[14]; // big enough to handle COMDAT header + char data[LEDATAMAX]; + int lseg; // segment value + unsigned i; // number of bytes in data + targ_size_t offset; // segment offset of start of data + struct FIXUP *fixuplist; // fixups for this ledata + + // For COMDATs + unsigned char flags; // flags byte of COMDAT + unsigned char alloctyp; // allocation type of COMDAT + unsigned char align; // align type + int typidx; + int pubbase; + int pubnamidx; +}; + +/***************************** + * For defining segments. + */ + +#define SEG_ATTR(A,C,B,P) (((A) << 5) | ((C) << 2) | ((B) << 1) | (P)) + +// Segment alignment A +#define SEG_ALIGN0 0 // absolute segment +#define SEG_ALIGN1 1 // byte align +#define SEG_ALIGN2 2 // word align +#define SEG_ALIGN16 3 // paragraph align +#define SEG_ALIGN4K 4 // 4Kb page align +#define SEG_ALIGN4 5 // dword align + +// Segment combine types C +#define SEG_C_ABS 0 +#define SEG_C_PUBLIC 2 +#define SEG_C_STACK 5 +#define SEG_C_COMMON 6 + +// Segment type P +#define USE16 0 +#define USE32 1 + +#define USE32_CODE (4+2) // use32 + execute/read +#define USE32_DATA (4+3) // use32 + read/write + +/***************************** + * Line number support. + */ + +#define LINNUMMAX 512 + +struct Linnum +{ +#if MARS + const char *filename; // source file name +#else + Sfile *filptr; // file pointer +#endif + int cseg; // our internal segment number + int seg; // segment/public index + int i; // used in data[] + char data[LINNUMMAX]; // linnum/offset data +}; + +#define LINRECMAX (2 + 255 * 2) // room for 255 line numbers + +/************************************ + * State of object file. + */ + +struct Objstate +{ + const char *modname; + char *csegname; + Outbuffer *buf; // output buffer + + int fdsegattr; // far data segment attribute + int csegattr; // code segment attribute + + int lastfardatasegi; // SegData[] index of last far data seg + + int LOCoffset; + int LOCpointer; + + int mlidata; + int mpubdef; + int mfixupp; + int mmodend; + + int lnameidx; // index of next LNAMES record + int segidx; // index of next SEGDEF record + int extidx; // index of next EXTDEF record + int pubnamidx; // index of COMDAT public name index + + Symbol *startaddress; // if !NULL, then Symbol is start address + +#ifdef DEBUG + int fixup_count; +#endif + + size_t ledatai; // max index used in ledatas[] + + // Line numbers + list_t linnum_list; + char *linrec; // line number record + unsigned linreci; // index of next avail in linrec[] + unsigned linrecheader; // size of line record header + unsigned linrecnum; // number of line record entries + list_t linreclist; // list of line records + int mlinnum; + int recseg; + int term; +#if MULTISCOPE + vec_t linvec; // bit vector of line numbers used + vec_t offvec; // and offsets used +#endif + + int fisegi; // SegData[] index of FI segment + +#if MARS + int fmsegi; // SegData[] of FM segment +#endif + + int tlssegi; // SegData[] of tls segment + int fardataidx; + + char pubdata[1024]; + int pubdatai; + + char extdata[1024]; + int extdatai; + + // For obj_far16thunk + int code16segi; // SegData[] index + targ_size_t CODE16offset; + + int fltused; + int nullext; +}; + +Ledatarec **ledatas; +size_t ledatamax; + +seg_data **SegData; +static int seg_count; +static int seg_max; + +static Objstate obj; + +STATIC void obj_defaultlib(); +STATIC void objheader (char *csegname); +STATIC char * objmodtoseg (const char *modname); +STATIC void obj_browse_flush(); +STATIC int obj_newfarseg (targ_size_t size,int); +STATIC void linnum_flush(void); +STATIC void linnum_term(void); +STATIC void objsegdef (int attr,targ_size_t size,int segnamidx,int classnamidx); +STATIC void obj_modend(); +STATIC void objfixupp (struct FIXUP *); +STATIC void outextdata(); +STATIC void outpubdata(); +STATIC Ledatarec *ledata_new(int seg,targ_size_t offset); + +char *id_compress(char *id, int idlen); + +/******************************* + * Output an object file data record. + * Input: + * rectyp = record type + * record -> the data + * reclen = # of bytes in record + */ + +void objrecord(unsigned rectyp,const char *record,unsigned reclen) +{ Outbuffer *o = obj.buf; + + //printf("rectyp = x%x, record[0] = x%x, reclen = x%x\n",rectyp,record[0],reclen); + o->reserve(reclen + 4); + o->writeByten(rectyp); + o->writeWordn(reclen + 1); // record length includes checksum + o->writen(record,reclen); + o->writeByten(0); // use 0 for checksum +} + + +/************************** + * Insert an index number. + * Input: + * p -> where to put the 1 or 2 byte index + * index = the 15 bit index + * Returns: + * # of bytes stored + */ + +extern void error(const char *filename, unsigned linnum, const char *format, ...); +extern void fatal(); + +void too_many_symbols() +{ +#if SCPP + err_fatal(EM_too_many_symbols, 0x7FFF); +#else // MARS + error(NULL, 0, "more than %d symbols in object file", 0x7FFF); + fatal(); +#endif +} + +#if !DEBUG && TX86 && __INTSIZE == 4 && !defined(_MSC_VER) +__declspec(naked) int __pascal insidx(char *p,unsigned index) +{ +#undef AL +#undef AH +#undef DL +#undef DH + _asm + { + mov EAX,index - 4[ESP] + mov ECX,p - 4[ESP] + cmp EAX,0x7F + jae L1 + mov [ECX],AL + mov EAX,1 + ret 8 + + + L1: + cmp EAX,0x7FFF + ja L2 + + mov 1[ECX],AL + or EAX,0x8000 + mov [ECX],AH + mov EAX,2 + ret 8 + } + L2: + too_many_symbols(); +} +#else +__inline int insidx(char *p,unsigned index) +{ + //if (index > 0x7FFF) printf("index = x%x\n",index); + /* OFM spec says it could be <=0x7F, but that seems to cause + * "library is corrupted" messages. Unverified. See Bugzilla 3601 + */ + if (index < 0x7F) + { *p = index; + return 1; + } + else if (index <= 0x7FFF) + { + *(p + 1) = index; + *p = (index >> 8) | 0x80; + return 2; + } + else + { too_many_symbols(); + return 0; + } +} +#endif + +/************************** + * Insert a type index number. + * Input: + * p -> where to put the 1 or 2 byte index + * index = the 15 bit index + * Returns: + * # of bytes stored + */ + +__inline int instypidx(char *p,unsigned index) +{ + if (index <= 127) + { *p = index; + return 1; + } + else if (index <= 0x7FFF) + { *(p + 1) = index; + *p = (index >> 8) | 0x80; + return 2; + } + else // overflow + { *p = 0; // the linker ignores this field anyway + return 1; + } +} + +/**************************** + * Read index. + */ + +#define getindex(p) ((*(p) & 0x80) \ + ? ((*(unsigned char *)(p) & 0x7F) << 8) | *((unsigned char *)(p) + 1) \ + : *(unsigned char *)(p)) + +/***************************** + * Returns: + * # of bytes stored + */ + +#define ONS_OHD 4 // max # of extra bytes added by obj_namestring() + +STATIC int obj_namestring(char *p,const char *name) +{ unsigned len; + + len = strlen(name); + if (len > 255) + { p[0] = 0xFF; + p[1] = 0; +#ifdef DEBUG + assert(len <= 0xFFFF); +#endif + TOWORD(p + 2,len); + memcpy(p + 4,name,len); + len += ONS_OHD; + } + else + { p[0] = len; + memcpy(p + 1,name,len); + len++; + } + return len; +} + +/****************************** + * Allocate a new segment. + * Return index for the new segment. + */ + +seg_data *getsegment() +{ + int seg = ++seg_count; + if (seg_count == seg_max) + { + seg_max += 10; + SegData = (seg_data **)mem_realloc(SegData, seg_max * sizeof(seg_data *)); + memset(&SegData[seg_count], 0, 10 * sizeof(seg_data *)); + } + assert(seg_count < seg_max); + if (SegData[seg]) + memset(SegData[seg], 0, sizeof(seg_data)); + else + SegData[seg] = (seg_data *)mem_calloc(sizeof(seg_data)); + + seg_data *pseg = SegData[seg]; + pseg->SDseg = seg; + pseg->segidx = 0; + return pseg; +} + + +/****************************** + * Perform initialization that applies to all .obj output files. + * Input: + * filename source file name + * csegname code segment name (can be NULL) + */ + +void obj_init(Outbuffer *objbuf, const char *filename, const char *csegname) +{ + memset(&obj,0,sizeof(obj)); + + obj.buf = objbuf; + obj.buf->reserve(40000); + + obj.lastfardatasegi = -1; + + obj.mlidata = LIDATA; + obj.mpubdef = PUBDEF; + obj.mfixupp = FIXUPP; + obj.mmodend = MODEND; + obj.mlinnum = LINNUM; + + + // Reset for different OBJ file formats + if (I32) + { if (config.flags & CFGeasyomf) + { obj.LOCoffset = EASY_LOCoffset; + obj.LOCpointer = EASY_LOCpointer; + } + else + { + obj.mlidata = LID386; + obj.mpubdef = PUB386; + obj.mfixupp = FIX386; + obj.mmodend = MODEND + 1; + obj.LOCoffset = LOC32offset; + obj.LOCpointer = LOC32pointer; + } + obj.fdsegattr = SEG_ATTR(SEG_ALIGN16,SEG_C_PUBLIC,0,USE32); + obj.csegattr = SEG_ATTR(SEG_ALIGN4, SEG_C_PUBLIC,0,USE32); + } + else + { + obj.LOCoffset = LOC16offset; + obj.LOCpointer = LOC16pointer; + obj.fdsegattr = SEG_ATTR(SEG_ALIGN16,SEG_C_PUBLIC,0,USE16); + obj.csegattr = SEG_ATTR(SEG_ALIGN2, SEG_C_PUBLIC,0,USE16); + } + + if (config.flags4 & CFG4speed && // if optimized for speed + config.target_cpu == TARGET_80486) + // 486 is only CPU that really benefits from alignment + obj.csegattr = I32 ? SEG_ATTR(SEG_ALIGN16, SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN16, SEG_C_PUBLIC,0,USE16); + + if (!SegData) + { seg_max = UDATA + 10; + SegData = (seg_data **)mem_calloc(seg_max * sizeof(seg_data *)); + } + + for (int i = 0; i < seg_max; i++) + { + if (SegData[i]) + memset(SegData[i], 0, sizeof(seg_data)); + else + SegData[i] = (seg_data *)mem_calloc(sizeof(seg_data)); + } + + SegData[CODE]->SDseg = CODE; + SegData[DATA]->SDseg = DATA; + SegData[CDATA]->SDseg = CDATA; + SegData[UDATA]->SDseg = UDATA; + + SegData[CODE]->segidx = CODE; + SegData[DATA]->segidx = DATA; + SegData[CDATA]->segidx = CDATA; + SegData[UDATA]->segidx = UDATA; + + seg_count = UDATA; + + if (config.fulltypes) + { + SegData[DEBSYM]->SDseg = DEBSYM; + SegData[DEBTYP]->SDseg = DEBTYP; + + SegData[DEBSYM]->segidx = DEBSYM; + SegData[DEBTYP]->segidx = DEBTYP; + + seg_count = DEBTYP; + } + + obj_theadr(filename); + obj.modname = filename; + if (!csegname || !*csegname) // if no code seg name supplied + obj.csegname = objmodtoseg(obj.modname); // generate one + else + obj.csegname = mem_strdup(csegname); // our own copy + objheader(obj.csegname); + objseggrp(0,0,0,0); // obj seg and grp info + ledata_new(cseg,0); // so ledata is never NULL + if (config.fulltypes) // if full typing information + cv_init(); // initialize debug output code +} + +/************************** + * Initialize the start of object output for this particular .obj file. + */ + +void obj_initfile(const char *filename,const char *csegname, const char *modname) +{ +} + +/*************************** + * Fixup and terminate object file. + */ + +void obj_termfile() +{ +} + +/********************************* + * Terminate package. + */ + +void obj_term() +{ + //printf("obj_term()\n"); + list_t dl; + unsigned long size; + +#if SCPP + if (!errcnt) +#endif + { obj_defaultlib(); + outfixlist(); // backpatches + } + + if (config.fulltypes) + cv_term(); // write out final debug info + outextdata(); // finish writing EXTDEFs + outpubdata(); // finish writing PUBDEFs + + // Put out LEDATA records and associated fixups + for (size_t i = 0; i < obj.ledatai; i++) + { Ledatarec *d = ledatas[i]; + + if (d->i) // if any data in this record + { // Fill in header + int headersize; + int rectyp; + assert(d->lseg > 0 && d->lseg <= seg_count); + int lseg = SegData[d->lseg]->segidx; + char header[sizeof(d->header)]; + + if (seg_is_comdat(lseg)) // if COMDAT + { + header[0] = d->flags | (d->offset ? 1 : 0); // continuation flag + header[1] = d->alloctyp; + header[2] = d->align; + TOOFFSET(header + 3,d->offset); + headersize = 3 + intsize; + headersize += instypidx(header + headersize,d->typidx); + if ((header[1] & 0x0F) == 0) + { // Group index + header[headersize] = (d->pubbase == DATA) ? 1 : 0; + headersize++; + + // Segment index + headersize += insidx(header + headersize,d->pubbase); + } + headersize += insidx(header + headersize,d->pubnamidx); + + rectyp = I32 ? COMDAT + 1 : COMDAT; + } + else + { + rectyp = LEDATA; + headersize = insidx(header,lseg); + if (intsize == LONGSIZE || d->offset & ~0xFFFFL) + { if (!(config.flags & CFGeasyomf)) + rectyp++; + TOLONG(header + headersize,d->offset); + headersize += 4; + } + else + { + TOWORD(header + headersize,d->offset); + headersize += 2; + } + } + assert(headersize <= sizeof(d->header)); + + // Right-justify data in d->header[] + memcpy(d->header + sizeof(d->header) - headersize,header,headersize); + //printf("objrecord(rectyp=x%02x, d=%p, p=%p, size = %d)\n", + //rectyp,d,d->header + (sizeof(d->header) - headersize),d->i + headersize); + + objrecord(rectyp,d->header + (sizeof(d->header) - headersize), + d->i + headersize); + objfixupp(d->fixuplist); + } + } +#if TERMCODE + //list_free(&obj.ledata_list,mem_freefp); +#endif + + linnum_term(); + obj_modend(); + + size = obj.buf->size(); + obj.buf->setsize(0); // rewind file + obj_theadr(obj.modname); + objheader(obj.csegname); + mem_free(obj.csegname); + objseggrp(SegData[CODE]->SDoffset,Doffset,0,SegData[UDATA]->SDoffset); // do real sizes + + // Update any out-of-date far segment sizes + for (size_t i = 0; i <= seg_count; i++) + { seg_data *f = SegData[i]; + if (f->isfarseg && f->origsize != f->SDoffset) + { obj.buf->setsize(f->seek); + objsegdef(f->attr,f->SDoffset,f->lnameidx,f->classidx); + } + } + //mem_free(obj.farseg); + + //printf("Ledata max = %d\n", obj.ledatai); +#if 0 + printf("Max # of fixups = %d\n",obj.fixup_count); +#endif + + obj.buf->setsize(size); +} + +/***************************** + * Line number support. + */ + +/*************************** + * Record line number linnum at offset. + * Input: + * cseg current code segment (negative for COMDAT segments) + * pubnamidx + * obj.mlinnum LINNUM or LINSYM + */ + +void objlinnum(Srcpos srcpos,targ_size_t offset) +{ + unsigned linnum = srcpos.Slinnum; + +#if 0 +#if MARS || SCPP + printf("objlinnum(cseg=%d, offset=0x%lx) ", cseg, offset); +#endif + srcpos.print(""); +#endif + + char linos2 = config.exe == EX_OS2 && !seg_is_comdat(SegData[cseg]->segidx); + +#if MARS + if (!obj.term && + (seg_is_comdat(SegData[cseg]->segidx) || (srcpos.Sfilename && srcpos.Sfilename != obj.modname))) +#else + if (!srcpos.Sfilptr) + return; + sfile_debug(&srcpos_sfile(srcpos)); + if (!obj.term && (!(srcpos_sfile(srcpos).SFflags & SFtop) || (seg_is_comdat(SegData[cseg]->segidx) && !obj.term))) +#endif + { // Not original source file, or a COMDAT. + // Save data away and deal with it at close of compile. + // It is done this way because presumably 99% of the lines + // will be in the original source file, so we wish to minimize + // memory consumption and maximize speed. + list_t ll; + struct Linnum *ln; + + if (linos2) + return; // BUG: not supported under OS/2 + for (ll = obj.linnum_list; 1; ll = list_next(ll)) + { + if (!ll) + { + ln = (struct Linnum *) mem_calloc(sizeof(struct Linnum)); +#if MARS + ln->filename = srcpos.Sfilename; +#else + ln->filptr = *srcpos.Sfilptr; +#endif + ln->cseg = cseg; + ln->seg = obj.pubnamidx; + list_prepend(&obj.linnum_list,ln); + break; + } + ln = (Linnum *)list_ptr(ll); + if ( +#if MARS + (ln->filename == srcpos.Sfilename) && +#endif +#if SCPP + (ln->filptr == *srcpos.Sfilptr) && +#endif + ln->cseg == cseg && + ln->i < LINNUMMAX - 6) + break; + } + TOWORD(&ln->data[ln->i],linnum); + TOOFFSET(&ln->data[ln->i + 2],offset); + ln->i += 2 + intsize; + } + else + { + if (linos2 && obj.linreci > LINRECMAX - 8) + obj.linrec = NULL; // allocate a new one + else if (cseg != obj.recseg) + linnum_flush(); + + if (!obj.linrec) // if not allocated + { obj.linrec = (char *) mem_calloc(LINRECMAX); + obj.linrec[0] = 0; // base group / flags + obj.linrecheader = 1 + insidx(obj.linrec + 1,seg_is_comdat(SegData[cseg]->segidx) ? obj.pubnamidx : SegData[cseg]->segidx); + obj.linreci = obj.linrecheader; + obj.recseg = cseg; +#if MULTISCOPE + if (!obj.linvec) + { obj.linvec = vec_calloc(1000); + obj.offvec = vec_calloc(1000); + } +#endif + if (linos2) + { + if (!obj.linreclist) // if first line number record + obj.linreci += 8; // leave room for header + list_append(&obj.linreclist,obj.linrec); + } + + // Select record type to use + obj.mlinnum = seg_is_comdat(SegData[cseg]->segidx) ? LINSYM : LINNUM; + if (I32 && !(config.flags & CFGeasyomf)) + obj.mlinnum++; + } + else if (obj.linreci > LINRECMAX - (2 + intsize)) + { objrecord(obj.mlinnum,obj.linrec,obj.linreci); // output data + obj.linreci = obj.linrecheader; + if (seg_is_comdat(SegData[cseg]->segidx)) // if LINSYM record + obj.linrec[0] |= 1; // continuation bit + } +#if MULTISCOPE + if (linnum >= vec_numbits(obj.linvec)) + obj.linvec = vec_realloc(obj.linvec,linnum + 1000); + if (offset >= vec_numbits(obj.offvec)) + { +#if __INTSIZE == 2 + unsigned newsize = (unsigned)offset * 2; + + if (offset >= 0x8000) + { newsize = 0xFF00; + assert(offset < newsize); + } + if (newsize != vec_numbits(obj.offvec)) + obj.offvec = vec_realloc(obj.offvec,newsize); +#else + if (offset < 0xFF00) // otherwise we overflow ph_malloc() + obj.offvec = vec_realloc(obj.offvec,offset * 2); +#endif + } + if ( +#if 1 // disallow multiple offsets per line + !vec_testbit(linnum,obj.linvec) && // if linnum not already used +#endif + // disallow multiple lines per offset + (offset >= 0xFF00 || !vec_testbit(offset,obj.offvec))) // and offset not already used +#endif + { +#if MULTISCOPE + vec_setbit(linnum,obj.linvec); // mark linnum as used + if (offset < 0xFF00) + vec_setbit(offset,obj.offvec); // mark offset as used +#endif + TOWORD(obj.linrec + obj.linreci,linnum); + if (linos2) + { obj.linrec[obj.linreci + 2] = 1; // source file index + TOLONG(obj.linrec + obj.linreci + 4,offset); + obj.linrecnum++; + obj.linreci += 8; + } + else + { + TOOFFSET(obj.linrec + obj.linreci + 2,offset); + obj.linreci += 2 + intsize; + } + } + } +} + +/*************************** + * Flush any pending line number records. + */ + +STATIC void linnum_flush() +{ + if (obj.linreclist) + { list_t list; + size_t len; + + obj.linrec = (char *) list_ptr(obj.linreclist); + TOWORD(obj.linrec + 6,obj.linrecnum); + list = obj.linreclist; + while (1) + { obj.linrec = (char *) list_ptr(list); + + list = list_next(list); + if (list) + { objrecord(obj.mlinnum,obj.linrec,LINRECMAX); + mem_free(obj.linrec); + } + else + { objrecord(obj.mlinnum,obj.linrec,obj.linreci); + break; + } + } + list_free(&obj.linreclist,FPNULL); + + // Put out File Names Table + TOLONG(obj.linrec + 2,0); // record no. of start of source (???) + TOLONG(obj.linrec + 6,obj.linrecnum); // number of primary source records + TOLONG(obj.linrec + 10,1); // number of source and listing files + len = obj_namestring(obj.linrec + 14,obj.modname); + assert(14 + len <= LINRECMAX); + objrecord(obj.mlinnum,obj.linrec,14 + len); + + mem_free(obj.linrec); + obj.linrec = NULL; + } + else if (obj.linrec) // if some line numbers to send + { objrecord(obj.mlinnum,obj.linrec,obj.linreci); + mem_free(obj.linrec); + obj.linrec = NULL; + } +#if MULTISCOPE + vec_clear(obj.linvec); + vec_clear(obj.offvec); +#endif +} + +/************************************* + * Terminate line numbers. + */ + +STATIC void linnum_term() +{ list_t ll; +#if SCPP + Sfile *lastfilptr = NULL; +#endif +#if MARS + const char *lastfilename = NULL; +#endif + int csegsave = cseg; + + linnum_flush(); + obj.term = 1; + while (obj.linnum_list) + { struct Linnum *ln; + unsigned u; + Srcpos srcpos; + targ_size_t offset; + + ll = obj.linnum_list; + ln = (struct Linnum *) list_ptr(ll); +#if SCPP + Sfile *filptr = ln->filptr; + if (filptr != lastfilptr) + { obj_theadr(filptr->SFname); + lastfilptr = filptr; + } +#endif +#if MARS + const char *filename = ln->filename; + if (filename != lastfilename) + { + if (filename) + obj_theadr(filename); + lastfilename = filename; + } +#endif + while (1) + { + cseg = ln->cseg; + assert(cseg > 0); + obj.pubnamidx = ln->seg; +#if MARS + srcpos.Sfilename = ln->filename; +#else + srcpos.Sfilptr = &ln->filptr; +#endif + for (u = 0; u < ln->i; ) + { + srcpos.Slinnum = *(unsigned short *)&ln->data[u]; + u += 2; + if (I32) + offset = *(unsigned long *)&ln->data[u]; + else + offset = *(unsigned short *)&ln->data[u]; + objlinnum(srcpos,offset); + u += intsize; + } + linnum_flush(); + ll = list_next(ll); + list_subtract(&obj.linnum_list,ln); + mem_free(ln); + L1: + if (!ll) + break; + ln = (struct Linnum *) list_ptr(ll); +#if SCPP + if (filptr != ln->filptr) +#else + if (filename != ln->filename) +#endif + { ll = list_next(ll); + goto L1; + } + } + } + cseg = csegsave; + assert(cseg > 0); +#if MULTISCOPE + vec_free(obj.linvec); + vec_free(obj.offvec); +#endif +} + +/******************************* + * Set start address + */ + +void obj_startaddress(Symbol *s) +{ + obj.startaddress = s; +} + +/******************************* + * Output DOSSEG coment record. + */ + +void obj_dosseg() +{ static const char dosseg[] = { 0x80,0x9E }; + + objrecord(COMENT,dosseg,sizeof(dosseg)); +} + +/******************************* + * Embed comment record. + */ + +STATIC void obj_comment(unsigned char x, const char *string, size_t len) +{ + char __ss *library; + + library = (char __ss *) alloca(2 + len); + library[0] = 0; + library[1] = x; + memcpy(library + 2,string,len); + objrecord(COMENT,library,len + 2); +} + +/******************************* + * Output library name. + * Output: + * name is modified + */ + +void obj_includelib(const char *name) +{ const char *p; + size_t len = strlen(name); + + p = filespecdotext(name); + if (!filespeccmp(p,".lib")) + len -= strlen(p); // lop off .LIB extension + obj_comment(0x9F, name, len); +} + +/************************** + * Embed string in executable. + */ + +void obj_exestr(const char *p) +{ + obj_comment(0xA4,p, strlen(p)); +} + +/************************** + * Embed string in obj. + */ + +void obj_user(const char *p) +{ + obj_comment(0xDF,p, strlen(p)); +} + +/********************************* + * Put out default library name. + */ + +STATIC void obj_defaultlib() +{ + char library[4]; // default library + static const char model[MEMMODELS] = "SMCLV"; + +#if MARS + memcpy(library,"SM?",4); +#else + memcpy(library,"SD?",4); +#endif + switch (config.exe) + { + case EX_OS2: + library[2] = 'F'; + case EX_OS1: + library[1] = 'O'; + break; + case EX_NT: +#if MARS + library[1] = 'M'; +#else + library[1] = 'N'; +#endif + library[2] = (config.flags4 & CFG4dllrtl) ? 'D' : 'N'; + break; + case EX_DOSX: + case EX_PHARLAP: + library[2] = 'X'; + break; + default: + library[2] = model[config.memmodel]; + if (config.wflags & WFwindows) + library[1] = 'W'; + break; + } + + if (!(config.flags2 & CFG2nodeflib)) + { + obj_includelib(configv.deflibname ? configv.deflibname : library); + } +} + +/******************************* + * Output a weak extern record. + * s1 is the weak extern, s2 is its default resolution. + */ + +void obj_wkext(Symbol *s1,Symbol *s2) +{ char buffer[2+2+2]; + int i; + int x2; + + printf("obj_wkext(%s)\n", s1->Sident); + if (s2) + x2 = s2->Sxtrnnum; + else + { + if (!obj.nullext) + { + obj.nullext = objextdef("__nullext"); + } + x2 = obj.nullext; + } + outextdata(); + buffer[0] = 0x80; + buffer[1] = 0xA8; + i = 2; + i += insidx(&buffer[2],s1->Sxtrnnum); + i += insidx(&buffer[i],x2); + objrecord(COMENT,buffer,i); +} + +/******************************* + * Output a lazy extern record. + * s1 is the lazy extern, s2 is its default resolution. + */ + +void obj_lzext(Symbol *s1,Symbol *s2) +{ char buffer[2+2+2]; + int i; + + outextdata(); + buffer[0] = 0x80; + buffer[1] = 0xA9; + i = 2; + i += insidx(&buffer[2],s1->Sxtrnnum); + i += insidx(&buffer[i],s2->Sxtrnnum); + objrecord(COMENT,buffer,i); +} + +/******************************* + * Output an alias definition record. + */ + +void obj_alias(const char *n1,const char *n2) +{ unsigned len; + char *buffer; + + buffer = (char *) alloca(strlen(n1) + strlen(n2) + 2 * ONS_OHD); + len = obj_namestring(buffer,n1); + len += obj_namestring(buffer + len,n2); + objrecord(ALIAS,buffer,len); +} + +/******************************* + * Output module name record. + */ + +void obj_theadr(const char *modname) +{ + //printf("obj_theadr(%s)\n", modname); + + // Convert to absolute file name, so debugger can find it anywhere + char absname[260]; + if (config.fulltypes && + modname[0] != '\\' && modname[0] != '/' && !(modname[0] && modname[1] == ':')) + { + if (getcwd(absname, sizeof(absname))) + { + int len = strlen(absname); + if(absname[len - 1] != '\\' && absname[len - 1] != '/') + absname[len++] = '\\'; + strcpy(absname + len, modname); + modname = absname; + } + } + + char *theadr = (char *)alloca(ONS_OHD + strlen(modname)); + int i = obj_namestring(theadr,modname); + objrecord(THEADR,theadr,i); // module name record +} + +/******************************* + * Embed compiler version in .obj file. + */ + +void obj_compiler() +{ + static const char compiler[] = "\0\xDBDigital Mars C/C++" + VERSION + ; // compiled by ... + + objrecord(COMENT,compiler,sizeof(compiler) - 1); +} + +/******************************* + * Output header stuff for object files. + * Input: + * csegname Name to use for code segment (NULL if use default) + */ + +STATIC void objheader(char *csegname) +{ + char *nam; + static char lnames[] = + "\0\06DGROUP\05_TEXT\04CODE\05_DATA\04DATA\05CONST\04_BSS\03BSS\ +\07$$TYPES\06DEBTYP\011$$SYMBOLS\06DEBSYM"; + +#define DATACLASS 6 // data class lname index +#define BSSCLASS 9 // BSS class lname index + + // Include debug segment names if inserting type information + int lnamesize = config.fulltypes ? sizeof(lnames) - 1 : sizeof(lnames) - 1 - 32; + int texti = 8; // index of _TEXT + + static char comment[] = {0,0x9D,'0','?','O'}; // memory model + static char model[MEMMODELS] = "smclv"; + static char exten[] = {0,0xA1,1,'C','V'}; // extended format + static char pmdeb[] = {0x80,0xA1,1,'H','L','L',0}; // IBM PM debug format + + if (I32) + { if (config.flags & CFGeasyomf) + { + // Indicate we're in EASY OMF (hah!) format + static const char easy_omf[] = { 0x80,0xAA,'8','0','3','8','6' }; + objrecord(COMENT,easy_omf,sizeof(easy_omf)); + } + } + + // Send out a comment record showing what memory model was used + comment[2] = config.target_cpu + '0'; + comment[3] = model[config.memmodel]; + if (I32) + { if (config.exe == EX_NT) + comment[3] = 'n'; + else if (config.exe == EX_OS2) + comment[3] = 'f'; + else + comment[3] = 'x'; + } + objrecord(COMENT,comment,sizeof(comment)); + + // Send out comment indicating we're using extensions to .OBJ format + if (config.exe == EX_OS2) + objrecord(COMENT,pmdeb,sizeof(pmdeb)); + else + objrecord(COMENT,exten,sizeof(exten)); + + // Change DGROUP to FLAT if we are doing flat memory model + // (Watch out, objheader() is called twice!) + if (config.exe & EX_flat) + { + if (lnames[2] != 'F') // do not do this twice + { memcpy(lnames + 1,"\04FLAT",5); + memmove(lnames + 6,lnames + 8,sizeof(lnames) - 8); + } + lnamesize -= 2; + texti -= 2; + } + + // Put out segment and group names + if (csegname) + { char *p; + size_t i; + + // Replace the module name _TEXT with the new code segment name + i = strlen(csegname); + p = (char *)alloca(lnamesize + i - 5); + memcpy(p,lnames,8); + p[texti] = i; + texti++; + memcpy(p + texti,csegname,i); + memcpy(p + texti + i,lnames + texti + 5,lnamesize - (texti + 5)); + objrecord(LNAMES,p,lnamesize + i - 5); + } + else + objrecord(LNAMES,lnames,lnamesize); +} + +/******************************** + * Convert module name to code segment name. + * Output: + * mem_malloc'd code seg name + */ + +STATIC char * objmodtoseg(const char *modname) +{ char *csegname = NULL; + + if (LARGECODE) // if need to add in module name + { int i; + char *m; + static const char suffix[] = "_TEXT"; + + // Prepend the module name to the beginning of the _TEXT + m = filespecgetroot(filespecname(modname)); + strupr(m); + i = strlen(m); + csegname = (char *)mem_malloc(i + sizeof(suffix)); + strcpy(csegname,m); + strcat(csegname,suffix); + mem_free(m); + } + return csegname; +} + +/********************************* + * Put out a segment definition. + */ + +STATIC void objsegdef(int attr,targ_size_t size,int segnamidx,int classnamidx) +{ + unsigned reclen; + char sd[1+4+2+2+2+1]; + + //printf("objsegdef(attr=x%x, size=x%x, segnamidx=x%x, classnamidx=x%x)\n", + //attr,size,segnamidx,classnamidx); + sd[0] = attr; + if (attr & 1 || config.flags & CFGeasyomf) + { TOLONG(sd + 1,size); // store segment size + reclen = 5; + } + else + { +#ifdef DEBUG + assert(size <= 0xFFFF); +#endif + TOWORD(sd + 1,size); + reclen = 3; + } + reclen += insidx(sd + reclen,segnamidx); // segment name index + reclen += insidx(sd + reclen,classnamidx); // class name index + sd[reclen] = 1; // overlay name index + reclen++; + if (attr & 1) // if USE32 + { + if (config.flags & CFGeasyomf) + { // Translate to Pharlap format + sd[0] &= ~1; // turn off P bit + + // Translate A: 4->6 + attr &= SEG_ATTR(7,0,0,0); + if (attr == SEG_ATTR(4,0,0,0)) + sd[0] ^= SEG_ATTR(4 ^ 6,0,0,0); + + // 2 is execute/read + // 3 is read/write + // 4 is use32 + sd[reclen] = (classnamidx == 4) ? (4+2) : (4+3); + reclen++; + } + } + else // 16 bit segment + { +#if MARS + assert(0); +#else + if (size & ~0xFFFFL) + { if (size == 0x10000) // if exactly 64Kb + sd[0] |= 2; // set "B" bit + else + synerr(EM_seg_gt_64k,size); // segment exceeds 64Kb + } +//printf("attr = %x\n", attr); +#endif + } +#ifdef DEBUG + assert(reclen <= sizeof(sd)); +#endif + objrecord(SEGDEF + (sd[0] & 1),sd,reclen); +} + +/********************************* + * Output segment and group definitions. + * Input: + * codesize size of code segment + * datasize size of initialized data segment + * cdatasize size of initialized const data segment + * udatasize size of uninitialized data segment + */ + +void objseggrp(targ_size_t codesize,targ_size_t datasize, + targ_size_t cdatasize,targ_size_t udatasize) +{ + int dsegattr; + int dsymattr; + + // Group into DGROUP the segments CONST, _BSS and _DATA + // For FLAT model, it's just GROUP FLAT + static const char grpdef[] = {2,0xFF,2,0xFF,3,0xFF,4}; + + objsegdef(obj.csegattr,codesize,3,4); // seg _TEXT, class CODE + +#if MARS + dsegattr = SEG_ATTR(SEG_ALIGN16,SEG_C_PUBLIC,0,USE32); +#else + dsegattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); +#endif + + objsegdef(dsegattr,datasize,5,DATACLASS); // seg _DATA, class DATA + objsegdef(dsegattr,cdatasize,7,7); // seg CONST, class CONST + objsegdef(dsegattr,udatasize,8,9); // seg _BSS, class BSS + + obj.lnameidx = 10; // next lname index + obj.segidx = 5; // next segment index + + if (config.fulltypes) + { + dsymattr = I32 + ? SEG_ATTR(SEG_ALIGN1,SEG_C_ABS,0,USE32) + : SEG_ATTR(SEG_ALIGN1,SEG_C_ABS,0,USE16); + + if (config.exe & EX_flat) + { // IBM's version of CV uses dword aligned segments + dsymattr = SEG_ATTR(SEG_ALIGN4,SEG_C_ABS,0,USE32); + } + else if (config.fulltypes == CV4) + { // Always use 32 bit segments + dsymattr |= USE32; + assert(!(config.flags & CFGeasyomf)); + } + objsegdef(dsymattr,SegData[DEBSYM]->SDoffset,0x0C,0x0D); + objsegdef(dsymattr,SegData[DEBTYP]->SDoffset,0x0A,0x0B); + obj.lnameidx += 4; // next lname index + obj.segidx += 2; // next segment index + } + + objrecord(GRPDEF,grpdef,(config.exe & EX_flat) ? 1 : sizeof(grpdef)); +#if 0 + // Define fixup threads, we don't use them + { static const char thread[] = { 0,3,1,2,2,1,3,4,0x40,1,0x45,1 }; + objrecord(obj.mfixupp,thread,sizeof(thread)); + } + // This comment appears to indicate that no more PUBDEFs, EXTDEFs, + // or COMDEFs are coming. + { static const char cv[] = {0,0xA2,1}; + objrecord(COMENT,cv,sizeof(cv)); + } +#endif +} + +//#if NEWSTATICDTOR + +/************************************** + * Symbol is the function that calls the static constructors. + * Put a pointer to it into a special segment that the startup code + * looks at. + * Input: + * s static constructor function + * dtor number of static destructors + * seg 1: user + * 2: lib + * 3: compiler + */ + +void obj_staticctor(Symbol *s,int dtor,int seg) +{ + // We need to always put out the segments in triples, so that the + // linker will put them in the correct order. + static char lnamector[] = "\05XIFCB\04XIFU\04XIFL\04XIFM\05XIFCE"; + static char lnamedtor[] = "\04XOFB\03XOF\04XOFE"; + static char lnamedtorf[] = "\03XOB\02XO\03XOE"; + + symbol_debug(s); + + // Determine if near or far function + assert(I32 || tyfarfunc(s->ty())); + + // Put out LNAMES record + objrecord(LNAMES,lnamector,sizeof(lnamector) - 1); + + int dsegattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); + + for (int i = 0; i < 5; i++) + { int sz; + + sz = (i == seg) ? 4 : 0; + + // Put out segment definition record + objsegdef(dsegattr,sz,obj.lnameidx,DATACLASS); + + if (i == seg) + { + seg_data *pseg = getsegment(); + pseg->segidx = obj.segidx; + reftoident(pseg->SDseg,0,s,0,0); // put out function pointer + } + + obj.segidx++; + obj.lnameidx++; + } + + if (dtor) + { // Leave space in XOF segment so that __fatexit() can insert a + // pointer to the static destructor in XOF. + + // Put out LNAMES record + if (LARGEDATA) + objrecord(LNAMES,lnamedtorf,sizeof(lnamedtorf) - 1); + else + objrecord(LNAMES,lnamedtor,sizeof(lnamedtor) - 1); + + // Put out beginning segment + objsegdef(dsegattr,0,obj.lnameidx,BSSCLASS); + + // Put out segment definition record + objsegdef(dsegattr,4 * dtor,obj.lnameidx + 1,BSSCLASS); + + // Put out ending segment + objsegdef(dsegattr,0,obj.lnameidx + 2,BSSCLASS); + + obj.lnameidx += 3; // for next time + obj.segidx += 3; + } +} + +//#else + +/*************************************** + * Stuff pointer to function in its own segment. + * Used for static ctor and dtor lists. + */ + +void obj_funcptr(Symbol *s) +{ + // We need to always put out the segments in triples, so that the + // linker will put them in the correct order. + static char lnames[4][5+4+5] = + { "\03XIB\02XI\03XIE", // near constructor + "\03XCB\02XC\03XCE", // near destructor + "\04XIFB\03XIF\04XIFE", // far constructor + "\04XCFB\03XCF\04XCFE", // far destructor + }; + // Size of each of the above strings + static int lnamesize[4] = { 4+3+4,4+3+4,5+4+5,5+4+5 }; + + int dsegattr; + int i; + + symbol_debug(s); +#ifdef DEBUG + assert(memcmp(s->Sident,"_ST",3) == 0); +#endif + + // Determine if constructor or destructor + // _STI... is a constructor, _STD... is a destructor + i = s->Sident[3] == 'D'; + // Determine if near or far function + if (tyfarfunc(s->Stype->Tty)) + i += 2; + + // Put out LNAMES record + objrecord(LNAMES,lnames[i],lnamesize[i]); + + dsegattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); + + // Put out beginning segment + objsegdef(dsegattr,0,obj.lnameidx,DATACLASS); + obj.segidx++; + + // Put out segment definition record + // size is NPTRSIZE or FPTRSIZE + objsegdef(dsegattr,(i & 2) + tysize[TYnptr],obj.lnameidx + 1,DATACLASS); + seg_data *pseg = getsegment(); + pseg->segidx = obj.segidx; + reftoident(pseg->SDseg,0,s,0,0); // put out function pointer + obj.segidx++; + + // Put out ending segment + objsegdef(dsegattr,0,obj.lnameidx + 2,DATACLASS); + obj.segidx++; + + obj.lnameidx += 3; // for next time +} + +//#endif + +/*************************************** + * Stuff pointer to function in its own segment. + * Used for static ctor and dtor lists. + */ + +void obj_ehtables(Symbol *sfunc,targ_size_t size,Symbol *ehsym) +{ + // We need to always put out the segments in triples, so that the + // linker will put them in the correct order. + static char lnames[] = + { "\03FIB\02FI\03FIE" // near constructor + }; + int i; + int dsegattr; + targ_size_t offset; + + symbol_debug(sfunc); + + if (obj.fisegi == 0) + { + // Put out LNAMES record + objrecord(LNAMES,lnames,sizeof(lnames) - 1); + + dsegattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); + + // Put out beginning segment + objsegdef(dsegattr,0,obj.lnameidx,DATACLASS); + obj.lnameidx++; + obj.segidx++; + + // Put out segment definition record + obj.fisegi = obj_newfarseg(0,DATACLASS); + objsegdef(dsegattr,0,obj.lnameidx,DATACLASS); + SegData[obj.fisegi]->attr = dsegattr; + assert(SegData[obj.fisegi]->segidx == obj.segidx); + + // Put out ending segment + objsegdef(dsegattr,0,obj.lnameidx + 1,DATACLASS); + + obj.lnameidx += 2; // for next time + obj.segidx += 2; + } + offset = SegData[obj.fisegi]->SDoffset; + offset += reftoident(obj.fisegi,offset,sfunc,0,LARGECODE ? CFoff | CFseg : CFoff); // put out function pointer + offset += reftoident(obj.fisegi,offset,ehsym,0,0); // pointer to data + obj_bytes(obj.fisegi,offset,intsize,&size); // size of function + SegData[obj.fisegi]->SDoffset = offset + intsize; +} + +/*************************************** + * Append pointer to ModuleInfo to "FM" segment. + * The FM segment is bracketed by the empty FMB and FME segments. + */ + +#if MARS + +void obj_moduleinfo(Symbol *scc) +{ + // We need to always put out the segments in triples, so that the + // linker will put them in the correct order. + static char lnames[] = + { "\03FMB\02FM\03FME" + }; + + symbol_debug(scc); + + if (obj.fmsegi == 0) + { + // Put out LNAMES record + objrecord(LNAMES,lnames,sizeof(lnames) - 1); + + int dsegattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); + + // Put out beginning segment + objsegdef(dsegattr,0,obj.lnameidx,DATACLASS); + obj.lnameidx++; + obj.segidx++; + + // Put out segment definition record + obj.fmsegi = obj_newfarseg(0,DATACLASS); + objsegdef(dsegattr,0,obj.lnameidx,DATACLASS); + SegData[obj.fmsegi]->attr = dsegattr; + assert(SegData[obj.fmsegi]->segidx == obj.segidx); + + // Put out ending segment + objsegdef(dsegattr,0,obj.lnameidx + 1,DATACLASS); + + obj.lnameidx += 2; // for next time + obj.segidx += 2; + } + + targ_size_t offset = SegData[obj.fmsegi]->SDoffset; + offset += reftoident(obj.fmsegi,offset,scc,0,LARGECODE ? CFoff | CFseg : CFoff); // put out function pointer + SegData[obj.fmsegi]->SDoffset = offset; +} + +#endif + + +/********************************* + * Setup for Symbol s to go into a COMDAT segment. + * Output (if s is a function): + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * "segment index" of COMDAT (which will be a negative value to + * distinguish it from regular segments). + */ + +int obj_comdat(Symbol *s) +{ char lnames[IDMAX+IDOHD+1]; // +1 to allow room for strcpy() terminating 0 + char cextdef[2+2]; + char __ss *p; + size_t lnamesize; + unsigned ti; + int isfunc; + tym_t ty; + + symbol_debug(s); + ty = s->ty(); + isfunc = tyfunc(ty) != 0; + + // Put out LNAME for name of Symbol + lnamesize = obj_mangle(s,lnames); + objrecord((s->Sclass == SCstatic ? LLNAMES : LNAMES),lnames,lnamesize); + + // Put out CEXTDEF for name of Symbol + outextdata(); + p = cextdef; + p += insidx(p,obj.lnameidx++); + ti = (config.fulltypes == CVOLD) ? cv_typidx(s->Stype) : 0; + p += instypidx(p,ti); + objrecord(CEXTDEF,cextdef,p - cextdef); + s->Sxtrnnum = ++obj.extidx; + + seg_data *pseg = getsegment(); + pseg->segidx = -obj.extidx; + assert(pseg->SDseg > 0); + + // Start new LEDATA record for this COMDAT + Ledatarec *lr = ledata_new(pseg->SDseg,0); + lr->typidx = ti; + lr->pubnamidx = obj.lnameidx - 1; + if (isfunc) + { lr->pubbase = SegData[cseg]->segidx; + if (s->Sclass == SCcomdat || s->Sclass == SCinline) + lr->alloctyp = 0x10 | 0x00; // pick any instance | explicit allocation + cseg = lr->lseg; + assert(cseg > 0 && cseg <= seg_count); + obj.pubnamidx = obj.lnameidx - 1; + Coffset = 0; + if (tyfarfunc(ty) && strcmp(s->Sident,"main") == 0) + lr->alloctyp |= 1; // because MS does for unknown reasons + } + else + { unsigned char atyp; + + switch (ty & mTYLINK) + { case 0: + case mTYnear: lr->pubbase = DATA; +#if 0 + atyp = 0; // only one instance is allowed +#else + atyp = 0x10; // pick any (also means it is + // not searched for in a library) +#endif + break; + +#if TARGET_SEGMENTED + case mTYcs: lr->flags |= 0x08; // data in code seg + atyp = 0x11; break; + + case mTYfar: atyp = 0x12; break; +#endif + case mTYthread: lr->pubbase = obj_tlsseg()->segidx; + atyp = 0x10; // pick any (also means it is + // not searched for in a library) + break; + + default: assert(0); + } + lr->alloctyp = atyp; + } + if (s->Sclass == SCstatic) + lr->flags |= 0x04; // local bit (make it an "LCOMDAT") + return pseg->SDseg; +} + +/********************************** + * Reset code seg to existing seg. + * Used after a COMDAT for a function is done. + */ + +void obj_setcodeseg(int seg,targ_size_t offset) +{ + assert(0 < seg && seg <= seg_count); + cseg = seg; + Coffset = offset; +} + +/******************************** + * Define a new code segment. + * Input: + * name name of segment, if NULL then revert to default + * suffix 0 use name as is + * 1 append "_TEXT" to name + * Output: + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * segment index of newly created code segment + */ + +int obj_codeseg(char *name,int suffix) +{ + if (!name) + { + if (cseg != CODE) + { + cseg = CODE; + } + return cseg; + } + + // Put out LNAMES record + size_t lnamesize = strlen(name) + suffix * 5; + char *lnames = (char *) alloca(1 + lnamesize + 1); + lnames[0] = lnamesize; + assert(lnamesize <= (255 - 2 - sizeof(int)*3)); + strcpy(lnames + 1,name); + if (suffix) + strcat(lnames + 1,"_TEXT"); + objrecord(LNAMES,lnames,lnamesize + 1); + + cseg = obj_newfarseg(0,4); + SegData[cseg]->attr = obj.csegattr; + SegData[cseg]->segidx = obj.segidx; + assert(cseg > 0); + obj.segidx++; + Coffset = 0; + + objsegdef(obj.csegattr,0,obj.lnameidx++,4); + + return cseg; +} + +/********************************* + * Define segment for Thread Local Storage. + * Output: + * tlsseg set to segment number for TLS segment. + * Returns: + * segment for TLS segment + */ + +seg_data *obj_tlsseg_bss() { return obj_tlsseg(); } + +seg_data *obj_tlsseg() +{ //static char tlssegname[] = "\04$TLS\04$TLS"; + //static char tlssegname[] = "\05.tls$\03tls"; + static const char tlssegname[] = "\05.tls$\03tls\04.tls\010.tls$ZZZ"; + + if (obj.tlssegi == 0) + { int segattr; + + objrecord(LNAMES,tlssegname,sizeof(tlssegname) - 1); + +#if MARS + segattr = SEG_ATTR(SEG_ALIGN16,SEG_C_PUBLIC,0,USE32); +#else + segattr = I32 + ? SEG_ATTR(SEG_ALIGN4,SEG_C_PUBLIC,0,USE32) + : SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); +#endif + + // Put out beginning segment (.tls) + objsegdef(segattr,0,obj.lnameidx + 2,obj.lnameidx + 1); + obj.segidx++; + + // Put out .tls$ segment definition record + obj.tlssegi = obj_newfarseg(0,obj.lnameidx + 1); + objsegdef(segattr,0,obj.lnameidx,obj.lnameidx + 1); + SegData[obj.tlssegi]->attr = segattr; + SegData[obj.tlssegi]->segidx = obj.segidx; + + // Put out ending segment (.tls$ZZZ) + objsegdef(segattr,0,obj.lnameidx + 3,obj.lnameidx + 1); + + obj.lnameidx += 4; + obj.segidx += 2; + } + return SegData[obj.tlssegi]; +} + + +/******************************** + * Define a far data segment. + * Input: + * name Name of module + * size Size of the segment to be created + * Returns: + * segment index of far data segment created + * *poffset start of the data for the far data segment + */ + +int obj_fardata(char *name,targ_size_t size,targ_size_t *poffset) +{ + static char fardataclass[] = "\010FAR_DATA"; + int len; + int i; + char *buffer; + + // See if we can use existing far segment, and just bump its size + i = obj.lastfardatasegi; + if (i != -1 + && (intsize != 2 || (unsigned long) SegData[i]->SDoffset + size < 0x8000) + ) + { *poffset = SegData[i]->SDoffset; // BUG: should align this + SegData[i]->SDoffset += size; + return i; + } + + // No. We need to build a new far segment + + if (obj.fardataidx == 0) // if haven't put out far data lname + { // Put out class lname + objrecord(LNAMES,fardataclass,sizeof(fardataclass) - 1); + obj.fardataidx = obj.lnameidx++; + } + + // Generate name based on module name + name = strupr(filespecgetroot(filespecname(obj.modname))); + + // Generate name for this far segment + len = 1 + strlen(name) + 3 + 5 + 1; + buffer = (char *)alloca(len); + sprintf(buffer + 1,"%s%d_DATA",name,obj.segidx); + len = strlen(buffer + 1); + buffer[0] = len; + assert(len <= 255); + objrecord(LNAMES,buffer,len + 1); + + mem_free(name); + + // Construct a new SegData[] entry + obj.lastfardatasegi = obj_newfarseg(size,obj.fardataidx); + + // Generate segment definition + objsegdef(obj.fdsegattr,size,obj.lnameidx++,obj.fardataidx); + obj.segidx++; + + *poffset = 0; + return SegData[obj.lastfardatasegi]->SDseg; +} + +/************************************ + * Remember where we put a far segment so we can adjust + * its size later. + * Input: + * obj.segidx + * lnameidx + * Returns: + * index of SegData[] + */ + +STATIC int obj_newfarseg(targ_size_t size,int classidx) +{ + seg_data *f = getsegment(); + f->isfarseg = true; + f->seek = obj.buf->size(); + f->attr = obj.fdsegattr; + f->origsize = size; + f->SDoffset = size; + f->segidx = obj.segidx; + f->lnameidx = obj.lnameidx; + f->classidx = classidx; + return f->SDseg; +} + +/****************************** + * Convert reference to imported name. + */ + +void obj_import(elem *e) +{ +#if MARS + assert(0); +#else + Symbol *s; + Symbol *simp; + + elem_debug(e); + if ((e->Eoper == OPvar || e->Eoper == OPrelconst) && + (s = e->EV.sp.Vsym)->ty() & mTYimport && + (s->Sclass == SCextern || s->Sclass == SCinline) + ) + { char *name; + char *p; + size_t len; + char buffer[IDMAX + IDOHD + 1]; + + // Create import name + len = obj_mangle(s,buffer); + if (buffer[0] == (char)0xFF && buffer[1] == 0) + { name = buffer + 4; + len -= 4; + } + else + { name = buffer + 1; + len -= 1; + } + if (config.flags4 & CFG4underscore) + { p = (char *) alloca(5 + len + 1); + memcpy(p,"_imp_",5); + memcpy(p + 5,name,len); + p[5 + len] = 0; + } + else + { p = (char *) alloca(6 + len + 1); + memcpy(p,"__imp_",6); + memcpy(p + 6,name,len); + p[6 + len] = 0; + } + simp = scope_search(p,SCTglobal); + if (!simp) + { type *t; + + simp = scope_define(p,SCTglobal,SCextern); + simp->Ssequence = 0; + simp->Sfl = FLextern; + simp->Simport = s; + t = newpointer(s->Stype); + t->Tmangle = mTYman_c; + t->Tcount++; + simp->Stype = t; + } + assert(!e->EV.sp.Voffset); + if (e->Eoper == OPrelconst) + { + e->Eoper = OPvar; + e->EV.sp.Vsym = simp; + } + else // OPvar + { + e->Eoper = OPind; + e->E1 = el_var(simp); + e->E2 = NULL; + } + } +#endif +} + +/******************************* + * Mangle a name. + * Returns: + * length of mangled name + */ + +size_t obj_mangle(Symbol *s,char *dest) +{ size_t len; + size_t ilen; + char *name; + char *name2 = NULL; + + //printf("obj_mangle('%s'), mangle = x%x\n",s->Sident,type_mangle(s->Stype)); +#if SCPP + name = CPP ? cpp_mangle(s) : s->Sident; +#elif MARS + name = cpp_mangle(s); +#else + name = s->Sident; +#endif + len = strlen(name); // # of bytes in name + + // Use as max length the max length lib.exe can handle + // Use 5 as length of _ + @nnn + #define LIBIDMAX ((512 - 0x25 - 3 - 4) - 5) +#define LIBIDMAX 128 + if (len > LIBIDMAX) + //if (len > IDMAX) + { + size_t len2; + + // Attempt to compress the name + name2 = id_compress(name, len); + len2 = strlen(name2); +#if MARS + if (len2 > LIBIDMAX) // still too long + { + /* Form md5 digest of the name and store it in the + * last 32 bytes of the name. + */ + MD5_CTX mdContext; + MD5Init(&mdContext); + MD5Update(&mdContext, (unsigned char *)name, len); + MD5Final(&mdContext); + memcpy(name2, name, LIBIDMAX - 32); + for (int i = 0; i < 16; i++) + { unsigned char c = mdContext.digest[i]; + unsigned char c1 = (c >> 4) & 0x0F; + unsigned char c2 = c & 0x0F; + c1 += (c1 < 10) ? '0' : 'A' - 10; + name2[LIBIDMAX - 32 + i * 2] = c1; + c2 += (c2 < 10) ? '0' : 'A' - 10; + name2[LIBIDMAX - 32 + i * 2 + 1] = c2; + } + name = name2; + len = LIBIDMAX; + name[len] = 0; + //printf("name = '%s', len = %d, strlen = %d\n", name, len, strlen(name)); + } +#else + if (len2 > IDMAX) // still too long + { +#if SCPP + synerr(EM_identifier_too_long, name, len - IDMAX, IDMAX); +#elif MARS +// error(0, "identifier %s is too long by %d characters", name, len - IDMAX); +#else + assert(0); +#endif + len = IDMAX; + } +#endif + else + { + name = name2; + len = len2; + } + } + ilen = len; + if (ilen > (255-2-sizeof(int)*3)) + dest += 3; + switch (type_mangle(s->Stype)) + { case mTYman_pas: // if upper case + case mTYman_for: + memcpy(dest + 1,name,len); // copy in name + dest[1 + len] = 0; + strupr(dest + 1); // to upper case + break; +#if SCPP || MARS + case mTYman_cpp: +#if NEWMANGLE + memcpy(dest + 1,name,len); + break; +#endif +#endif + case mTYman_std: + if (!(config.flags4 & CFG4oldstdmangle) && + config.exe == EX_NT && tyfunc(s->ty()) && + !variadic(s->Stype)) + { + dest[1] = '_'; + memcpy(dest + 2,name,len); + dest[1 + 1 + len] = '@'; + itoa(type_paramsize(s->Stype),dest + 3 + len,10); + len = strlen(dest + 1); + assert(isdigit(dest[len])); + break; + } + case mTYman_c: + if (config.flags4 & CFG4underscore) + { + dest[1] = '_'; // leading _ in name + memcpy(&dest[2],name,len); // copy in name + len++; + break; + } + case mTYman_d: + case mTYman_sys: + memcpy(dest + 1, name, len); // no mangling + dest[1 + len] = 0; + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + if (ilen > (255-2-sizeof(int)*3)) + { dest -= 3; + dest[0] = 0xFF; + dest[1] = 0; +#ifdef DEBUG + assert(len <= 0xFFFF); +#endif + TOWORD(dest + 2,len); + len += 4; + } + else + { *dest = len; + len++; + } + if (name2) + free(name2); + assert(len <= IDMAX + IDOHD); + return len; +} + +/******************************* + * Export a function name. + */ + +void obj_export(Symbol *s,unsigned argsize) +{ char *coment; + size_t len; + + coment = (char *) alloca(4 + 1 + (IDMAX + IDOHD) + 1); // allow extra byte for mangling + len = obj_mangle(s,&coment[4]); + assert(len <= IDMAX + IDOHD); + coment[1] = 0xA0; // comment class + coment[2] = 2; // why??? who knows + if (argsize >= 64) // we only have a 5 bit field + argsize = 0; // hope we don't need callgate + coment[3] = (argsize + 1) >> 1; // # words on stack + coment[4 + len] = 0; // no internal name + objrecord(COMENT,coment,4 + len + 1); // module name record +} + +/******************************* + * Update data information about symbol + * align for output and assign segment + * if not already specified. + * + * Input: + * sdata data symbol + * datasize output size + * seg default seg if not known + * Returns: + * actual seg + */ + +int elf_data_start(Symbol *sdata, targ_size_t datasize, int seg) +{ + targ_size_t alignbytes; + //printf("elf_data_start(%s,size %llx,seg %d)\n",sdata->Sident,datasize,seg); + //symbol_print(sdata); + + if (sdata->Sseg == UNKNOWN) // if we don't know then there + sdata->Sseg = seg; // wasn't any segment override + else + seg = sdata->Sseg; + targ_size_t offset = SegData[seg]->SDoffset; + alignbytes = align(datasize, offset) - offset; + if (alignbytes) + obj_lidata(seg, offset, alignbytes); + sdata->Soffset = offset + alignbytes; + return seg; +} + +/******************************** + * Output a public definition. + * Input: + * seg = segment index that symbol is defined in + * s -> symbol + * offset = offset of name + */ + +STATIC void outpubdata() +{ + if (obj.pubdatai) + { objrecord(obj.mpubdef,obj.pubdata,obj.pubdatai); + obj.pubdatai = 0; + } +} + +void objpubdef(int seg,Symbol *s,targ_size_t offset) +{ unsigned reclen,len; + char *p; + unsigned ti; + + int idx = SegData[seg]->segidx; + if (obj.pubdatai + 1 + (IDMAX + IDOHD) + 4 + 2 > sizeof(obj.pubdata) || + idx != getindex(obj.pubdata + 1)) + outpubdata(); + if (obj.pubdatai == 0) + { + obj.pubdata[0] = (seg == DATA || seg == UDATA) ? 1 : 0; // group index + obj.pubdatai += 1 + insidx(obj.pubdata + 1,idx); // segment index + } + p = &obj.pubdata[obj.pubdatai]; + len = obj_mangle(s,p); // mangle in name + reclen = len + intsize; + p += len; + TOOFFSET(p,offset); + p += intsize; + ti = (config.fulltypes == CVOLD) ? cv_typidx(s->Stype) : 0; + reclen += instypidx(p,ti); + obj.pubdatai += reclen; +} + +/******************************* + * Output an external definition. + * Input: + * name -> external identifier + * Returns: + * External index of the definition (1,2,...) + */ + +STATIC void outextdata() +{ + if (obj.extdatai) + { objrecord(EXTDEF,obj.extdata,obj.extdatai); + obj.extdatai = 0; + } +} + +int objextdef(const char *name) +{ unsigned len; + char *e; + + //dbg_printf("objextdef('%s')\n",name); + assert(name); + len = strlen(name); // length of identifier + if (obj.extdatai + len + ONS_OHD + 1 > sizeof(obj.extdata)) + outextdata(); + + e = &obj.extdata[obj.extdatai]; + len = obj_namestring(e,name); + e[len] = 0; // typidx = 0 + obj.extdatai += len + 1; + assert(obj.extdatai <= sizeof(obj.extdata)); + return ++obj.extidx; +} + +/******************************* + * Output an external definition. + * Input: + * s Symbol to do EXTDEF on + * Returns: + * External index of the definition (1,2,...) + */ + +int objextern(Symbol *s) +{ + //dbg_printf("objextern('%s')\n",s->Sident); + symbol_debug(s); + if (obj.extdatai + (IDMAX + IDOHD) + 3 > sizeof(obj.extdata)) + outextdata(); + + char *e = &obj.extdata[obj.extdatai]; + unsigned len = obj_mangle(s,e); + e[len] = 0; // typidx = 0 + obj.extdatai += len + 1; + s->Sxtrnnum = ++obj.extidx; + return obj.extidx; +} + +/******************************* + * Output a common block definition. + * Input: + * p -> external identifier + * flag TRUE: in default data segment + * FALSE: not in default data segment + * size size in bytes of each elem + * count number of elems + * Returns: + * External index of the definition (1,2,...) + */ + +// Helper for obj_comdef() + +static unsigned storelength(unsigned long length,unsigned i) +{ + obj.extdata[i] = length; + if (length >= 128) // Microsoft docs say 129, but their linker + // won't take >=128, so accommodate it + { obj.extdata[i] = 129; +#ifdef DEBUG + assert(length <= 0xFFFF); +#endif + TOWORD(obj.extdata + i + 1,length); + if (length >= 0x10000) + { obj.extdata[i] = 132; + obj.extdata[i + 3] = length >> 16; + + // Only 386 can generate lengths this big + if (I32 && length >= 0x1000000) + { obj.extdata[i] = 136; + obj.extdata[i + 4] = length >> 24; + i += 4; + } + else + i += 3; + } + else + i += 2; + } + return i + 1; // index past where we stuffed length +} + +int obj_comdef(Symbol *s,int flag,targ_size_t size,targ_size_t count) +{ register unsigned i; + unsigned long length; + unsigned ti; + + //dbg_printf("obj_comdef('%s',%d,%d,%d)\n",s->Sident,flag,size,count); + outextdata(); // borrow the extdata[] storage + i = obj_mangle(s,obj.extdata); + + ti = (config.fulltypes == CVOLD) ? cv_typidx(s->Stype) : 0; + i += instypidx(obj.extdata + i,ti); + + if (flag) // if in default data segment + { + //printf("NEAR comdef\n"); + obj.extdata[i] = 0x62; + length = (unsigned long) size * count; + assert(I32 || length <= 0x10000); + i = storelength(length,i + 1); + } + else + { + //printf("FAR comdef\n"); + obj.extdata[i] = 0x61; + i = storelength((unsigned long) size,i + 1); + i = storelength((unsigned long) count,i); + } + assert(i <= arraysize(obj.extdata)); + objrecord(COMDEF,obj.extdata,i); + return ++obj.extidx; +} + +/*************************************** + * Append an iterated data block of 0s. + * (uninitialized data only) + */ + +void obj_write_zeros(seg_data *pseg, targ_size_t count) +{ + obj_lidata(pseg->SDseg, pseg->SDoffset, count); + //pseg->SDoffset += count; +} + +/*************************************** + * Output an iterated data block of 0s. + * (uninitialized data only) + */ + +void obj_lidata(int seg,targ_size_t offset,targ_size_t count) +{ int i; + unsigned reclen; + static char zero[20]; + char data[20]; + char __ss *di; + + //printf("obj_lidata(seg = %d, offset = x%x, count = %d)\n", seg, offset, count); + + SegData[seg]->SDoffset += count; + + if (seg == UDATA) + return; + int idx = SegData[seg]->segidx; + +Lagain: + if (count <= sizeof(zero)) // if shorter to use ledata + { + obj_bytes(seg,offset,count,zero); + return; + } + + if (seg_is_comdat(idx)) + { + while (count > sizeof(zero)) + { + obj_bytes(seg,offset,sizeof(zero),zero); + offset += sizeof(zero); + count -= sizeof(zero); + } + obj_bytes(seg,offset,count,zero); + return; + } + + i = insidx(data,idx); + di = data + i; + TOOFFSET(di,offset); + + if (config.flags & CFGeasyomf) + { + if (count >= 0x8000) // repeat count can only go to 32k + { + TOWORD(di + 4,(unsigned short)(count / 0x8000)); + TOWORD(di + 4 + 2,1); // 1 data block follows + TOWORD(di + 4 + 2 + 2,0x8000); // repeat count + TOWORD(di + 4 + 2 + 2 + 2,0); // block count + TOWORD(di + 4 + 2 + 2 + 2 + 2,1); // 1 byte of 0 + reclen = i + 4 + 5 * 2; + objrecord(obj.mlidata,data,reclen); + + offset += (count & ~0x7FFFL); + count &= 0x7FFF; + goto Lagain; + } + else + { + TOWORD(di + 4,(unsigned short)count); // repeat count + TOWORD(di + 4 + 2,0); // block count + TOWORD(di + 4 + 2 + 2,1); // 1 byte of 0 + reclen = i + 4 + 2 + 2 + 2; + objrecord(obj.mlidata,data,reclen); + } + } + else + { + TOOFFSET(di + intsize,count); + TOWORD(di + intsize * 2,0); // block count + TOWORD(di + intsize * 2 + 2,1); // repeat 1 byte of 0s + reclen = i + (I32 ? 12 : 8); + objrecord(obj.mlidata,data,reclen); + } + assert(reclen <= sizeof(data)); +} + +/**************************** + * Output a MODEND record. + */ + +STATIC void obj_modend() +{ + if (obj.startaddress) + { char mdata[10]; + int i; + unsigned framedatum,targetdatum; + unsigned char fd; + targ_size_t offset; + int external; // !=0 if identifier is defined externally + tym_t ty; + Symbol *s = obj.startaddress; + + // Turn startaddress into a fixup. + // Borrow heavilly from reftoident() + + symbol_debug(s); + offset = 0; + ty = s->ty(); + + switch (s->Sclass) + { + case SCcomdat: + case_SCcomdat: + case SCextern: + case SCcomdef: + if (s->Sxtrnnum) // identifier is defined somewhere else + external = s->Sxtrnnum; + else + { + Ladd: + s->Sclass = SCextern; + external = objextern(s); + outextdata(); + } + break; + case SCinline: + if (config.flags2 & CFG2comdat) + goto case_SCcomdat; // treat as initialized common block + case SCsinline: + case SCstatic: + case SCglobal: + if (s->Sseg == UNKNOWN) + goto Ladd; + if (seg_is_comdat(SegData[s->Sseg]->segidx)) // if in comdat + goto case_SCcomdat; + case SClocstat: + external = 0; // identifier is static or global + // and we know its offset + offset += s->Soffset; + break; + default: + #ifdef DEBUG + //symbol_print(s); + #endif + assert(0); + } + + if (external) + { fd = FD_T2; + targetdatum = external; + switch (s->Sfl) + { + case FLextern: + if (!(ty & ( +#if TARGET_SEGMENTED + mTYcs | +#endif + mTYthread))) + goto L1; + case FLfunc: +#if TARGET_SEGMENTED + case FLfardata: + case FLcsdata: +#endif + case FLtlsdata: + if (config.exe & EX_flat) + { fd |= FD_F1; + framedatum = 1; + } + else + { + //case FLtlsdata: + fd |= FD_F2; + framedatum = targetdatum; + } + break; + default: + goto L1; + } + } + else + { + fd = FD_T0; // target is always a segment + targetdatum = SegData[s->Sseg]->segidx; + assert(targetdatum != -1); + switch (s->Sfl) + { + case FLextern: + if (!(ty & ( +#if TARGET_SEGMENTED + mTYcs | +#endif + mTYthread))) + goto L1; + case FLfunc: +#if TARGET_SEGMENTED + case FLfardata: + case FLcsdata: +#endif + case FLtlsdata: + if (config.exe & EX_flat) + { fd |= FD_F1; + framedatum = 1; + } + else + { + //case FLtlsdata: + fd |= FD_F0; + framedatum = targetdatum; + } + break; + default: + L1: + fd |= FD_F1; + framedatum = DGROUPIDX; + //if (flags == CFseg) + { fd = FD_F1 | FD_T1; // target is DGROUP + targetdatum = DGROUPIDX; + } + break; + } + } + + // Write the fixup into mdata[] + mdata[0] = 0xC1; + mdata[1] = fd; + i = 2 + insidx(&mdata[2],framedatum); + i += insidx(&mdata[i],targetdatum); + TOOFFSET(mdata + i,offset); + + objrecord(obj.mmodend,mdata,i + intsize); // write mdata[] to .OBJ file + } + else + { static const char modend[] = {0}; + + objrecord(MODEND,modend,sizeof(modend)); + } +} + +/**************************** + * Output the fixups in list fl. + */ + +STATIC void objfixupp(struct FIXUP *f) +{ + unsigned i,j,k; + targ_size_t locat; + struct FIXUP *fn; + +#if 1 // store in one record + char data[1024]; + + i = 0; + for (; f; f = fn) + { unsigned char fd; + + if (i >= sizeof(data) - (3 + 2 + 2)) // if not enough room + { objrecord(obj.mfixupp,data,i); + i = 0; + } + + //printf("f = %p, offset = x%x\n",f,f->FUoffset); + assert(f->FUoffset < 1024); + locat = (f->FUlcfd & 0xFF00) | f->FUoffset; + data[i+0] = locat >> 8; + data[i+1] = locat; + data[i+2] = fd = f->FUlcfd; + k = i; + i += 3 + insidx(&data[i+3],f->FUframedatum); + //printf("FUframedatum = x%x\n", f->FUframedatum); + if ((fd >> 4) == (fd & 3) && f->FUframedatum == f->FUtargetdatum) + { + data[k + 2] = (fd & 15) | FD_F5; + } + else + { i += insidx(&data[i],f->FUtargetdatum); + //printf("FUtargetdatum = x%x\n", f->FUtargetdatum); + } + //printf("[%d]: %02x %02x %02x\n", k, data[k + 0] & 0xFF, data[k + 1] & 0xFF, data[k + 2] & 0xFF); + fn = f->FUnext; + mem_ffree(f); + } + assert(i <= sizeof(data)); + if (i) + objrecord(obj.mfixupp,data,i); +#else // store in multiple records + for (; fl; fl = list_next(fl)) + { + char data[7]; + + assert(f->FUoffset < 1024); + locat = (f->FUlcfd & 0xFF00) | f->FUoffset; + data[0] = locat >> 8; + data[1] = locat; + data[2] = f->FUlcfd; + i = 3 + insidx(&data[3],f->FUframedatum); + i += insidx(&data[i],f->FUtargetdatum); + objrecord(obj.mfixupp,data,i); + } +#endif +} + + +/*************************** + * Add a new fixup to the fixup list. + * Write things out if we overflow the list. + */ + +STATIC void addfixup(Ledatarec *lr, targ_size_t offset,unsigned lcfd, + unsigned framedatum,unsigned targetdatum) +{ struct FIXUP *f; + + assert(offset < 0x1024); +#ifdef DEBUG + assert(targetdatum <= 0x7FFF); + assert(framedatum <= 0x7FFF); +#endif + f = (struct FIXUP *) mem_fmalloc(sizeof(struct FIXUP)); + //printf("f = %p, offset = x%x\n",f,offset); + f->FUoffset = offset; + f->FUlcfd = lcfd; + f->FUframedatum = framedatum; + f->FUtargetdatum = targetdatum; + f->FUnext = lr->fixuplist; // link f into list + lr->fixuplist = f; +#ifdef DEBUG + obj.fixup_count++; // gather statistics +#endif +} + + +/********************************* + * Open up a new ledata record. + * Input: + * seg segment number data is in + * offset starting offset of start of data for this record + */ + +STATIC Ledatarec *ledata_new(int seg,targ_size_t offset) +{ + + //printf("ledata_new(seg = %d, offset = x%lx)\n",seg,offset); + assert(seg > 0 && seg <= seg_count); + + if (obj.ledatai == ledatamax) + { + size_t o = ledatamax; + ledatamax = o * 2 + 100; + ledatas = (Ledatarec **)mem_realloc(ledatas, ledatamax * sizeof(Ledatarec *)); + memset(ledatas + o, 0, (ledatamax - o) * sizeof(Ledatarec *)); + } + Ledatarec *lr = ledatas[obj.ledatai]; + if (!lr) + { lr = (Ledatarec *) mem_malloc(sizeof(Ledatarec)); + ledatas[obj.ledatai] = lr; + } + memset(lr, 0, sizeof(Ledatarec)); + ledatas[obj.ledatai] = lr; + obj.ledatai++; + + lr->lseg = seg; + lr->offset = offset; + + if (seg_is_comdat(SegData[seg]->segidx) && offset) // if continuation of an existing COMDAT + { + Ledatarec *d = SegData[seg]->ledata; + if (d) + { + if (d->lseg == seg) // found existing COMDAT + { lr->flags = d->flags; + lr->alloctyp = d->alloctyp; + lr->align = d->align; + lr->typidx = d->typidx; + lr->pubbase = d->pubbase; + lr->pubnamidx = d->pubnamidx; + } + } + } + SegData[seg]->ledata = lr; + return lr; +} + +/*********************************** + * Append byte to segment. + */ + +void obj_write_byte(seg_data *pseg, unsigned byte) +{ + obj_byte(pseg->SDseg, pseg->SDoffset, byte); + pseg->SDoffset++; +} + +/************************************ + * Output byte to object file. + */ + +void obj_byte(int seg,targ_size_t offset,unsigned byte) +{ unsigned i; + + Ledatarec *lr = SegData[seg]->ledata; + if (!lr) + goto L2; + + if ( + lr->i > LEDATAMAX - 1 || // if it'll overflow + offset < lr->offset || // underflow + offset > lr->offset + lr->i + ) + { + // Try to find an existing ledata + for (size_t i = obj.ledatai; i; ) + { Ledatarec *d = ledatas[--i]; + if (seg == d->lseg && // segments match + offset >= d->offset && + offset + 1 <= d->offset + LEDATAMAX && + offset <= d->offset + d->i + ) + { + lr = SegData[seg]->ledata = d; + goto L1; + } + } +L2: + lr = ledata_new(seg,offset); +L1: ; + } + + i = offset - lr->offset; + if (lr->i <= i) + lr->i = i + 1; + lr->data[i] = byte; // 1st byte of data +} + +/*********************************** + * Append bytes to segment. + */ + +void obj_write_bytes(seg_data *pseg, unsigned nbytes, void *p) +{ + obj_bytes(pseg->SDseg, pseg->SDoffset, nbytes, p); + pseg->SDoffset += nbytes; +} + +/************************************ + * Output bytes to object file. + * Returns: + * nbytes + */ + +unsigned obj_bytes(int seg,targ_size_t offset,unsigned nbytes, void *p) +{ unsigned n = nbytes; + + //dbg_printf("obj_bytes(seg=%d, offset=x%lx, nbytes=x%x, p=%p)\n",seg,offset,nbytes,p); + Ledatarec *lr = SegData[seg]->ledata; + if (!lr) + lr = ledata_new(seg, offset); + L1: + if ( + lr->i + nbytes > LEDATAMAX || // or it'll overflow + offset < lr->offset || // underflow + offset > lr->offset + lr->i + ) + { + while (nbytes) + { obj_byte(seg,offset,*(char *)p); + offset++; + ((char *)p)++; + nbytes--; + lr = SegData[seg]->ledata; + if (lr->i + nbytes <= LEDATAMAX) + goto L1; + } + } + else + { + unsigned i = offset - lr->offset; + if (lr->i < i + nbytes) + lr->i = i + nbytes; + memcpy(lr->data + i,p,nbytes); + } + return n; +} + +/************************************ + * Output word of data. (Two words if segment:offset pair.) + * Input: + * seg CODE, DATA, CDATA, UDATA + * offset offset of start of data + * data word of data + * lcfd LCxxxx | FDxxxx + * if (FD_F2 | FD_T6) + * idx1 = external Symbol # + * else + * idx1 = frame datum + * idx2 = target datum + */ + +void objledata(int seg,targ_size_t offset,targ_size_t data, + unsigned lcfd,unsigned idx1,unsigned idx2) +{ unsigned i; + unsigned size; // number of bytes to output + +#if TARGET_SEGMENTED + unsigned ptrsize = tysize[TYfptr]; +#else + unsigned ptrsize = I64 ? 10 : 6; +#endif + + if ((lcfd & LOCxx) == obj.LOCpointer) + size = ptrsize; + else if ((lcfd & LOCxx) == LOCbase) + size = 2; + else + size = tysize[TYnptr]; + + Ledatarec *lr = SegData[seg]->ledata; + if (!lr) + lr = ledata_new(seg, offset); + assert(seg == lr->lseg); + if ( + lr->i + size > LEDATAMAX || // if it'll overflow + offset < lr->offset || // underflow + offset > lr->offset + lr->i + ) + { + // Try to find an existing ledata +//dbg_printf("seg = %d, offset = x%lx, size = %d\n",seg,offset,size); + for (size_t i = obj.ledatai; i; ) + { Ledatarec *d = ledatas[--i]; + +//dbg_printf("d: seg = %d, offset = x%lx, i = x%x\n",d->lseg,d->offset,d->i); + if (seg == d->lseg && // segments match + offset >= d->offset && + offset + size <= d->offset + LEDATAMAX && + offset <= d->offset + d->i + ) + { +//dbg_printf("match\n"); + lr = SegData[seg]->ledata = d; + goto L1; + } + } + lr = ledata_new(seg,offset); +L1: ; + } + + i = offset - lr->offset; + if (lr->i < i + size) + lr->i = i + size; + if (size == 2 || !I32) + TOWORD(lr->data + i,data); + else + TOLONG(lr->data + i,data); + if (size == ptrsize) // if doing a seg:offset pair + TOWORD(lr->data + i + tysize[TYnptr],0); // segment portion + addfixup(lr, offset - lr->offset,lcfd,idx1,idx2); +} + +/************************************ + * Output long word of data. + * Input: + * seg CODE, DATA, CDATA, UDATA + * offset offset of start of data + * data long word of data + * Present only if size == 2: + * lcfd LCxxxx | FDxxxx + * if (FD_F2 | FD_T6) + * idx1 = external Symbol # + * else + * idx1 = frame datum + * idx2 = target datum + */ + +void obj_long(int seg,targ_size_t offset,unsigned long data, + unsigned lcfd,unsigned idx1,unsigned idx2) +{ +#if TARGET_SEGMENTED + unsigned sz = tysize[TYfptr]; +#else + unsigned sz = I64 ? 10 : 6; +#endif + Ledatarec *lr = SegData[seg]->ledata; + if (!lr) + lr = ledata_new(seg, offset); + if ( + lr->i + sz > LEDATAMAX || // if it'll overflow + offset < lr->offset || // underflow + offset > lr->offset + lr->i + ) + lr = ledata_new(seg,offset); + unsigned i = offset - lr->offset; + if (lr->i < i + sz) + lr->i = i + sz; + TOLONG(lr->data + i,data); + if (I32) // if 6 byte far pointers + TOWORD(lr->data + i + LONGSIZE,0); // fill out seg + addfixup(lr, offset - lr->offset,lcfd,idx1,idx2); +} + +/******************************* + * Refer to address that is in the data segment. + * Input: + * seg = where the address is going + * offset = offset within seg + * val = displacement from address + * targetdatum = DATA, CDATA or UDATA, depending where the address is + * flags = CFoff, CFseg + * Example: + * int *abc = &def[3]; + * to allocate storage: + * reftodatseg(DATA,offset,3 * sizeof(int *),UDATA); + */ + +void reftodatseg(int seg,targ_size_t offset,targ_size_t val, + unsigned targetdatum,int flags) +{ + assert(flags); + + if (flags == 0 || flags & CFoff) + { + // The frame datum is always 1, which is DGROUP + objledata(seg,offset,val, + LOCATsegrel | obj.LOCoffset | FD_F1 | FD_T4,DGROUPIDX,SegData[targetdatum]->segidx); + offset += intsize; + } + + if (flags & CFseg) + { +#if 0 + if (config.wflags & WFdsnedgroup) + warerr(WM_ds_ne_dgroup); +#endif + objledata(seg,offset,0, + LOCATsegrel | LOCbase | FD_F1 | FD_T5,DGROUPIDX,DGROUPIDX); + } +} + +/******************************* + * Refer to address that is in a far segment. + * Input: + * seg = where the address is going + * offset = offset within seg + * val = displacement from address + * farseg = far segment index + * flags = CFoff, CFseg + */ + +void reftofarseg(int seg,targ_size_t offset,targ_size_t val, + int farseg,int flags) +{ + assert(flags); + + int idx = SegData[farseg]->segidx; + if (flags == 0 || flags & CFoff) + { + objledata(seg,offset,val, + LOCATsegrel | obj.LOCoffset | FD_F0 | FD_T4,idx,idx); + offset += intsize; + } + + if (flags & CFseg) + { + objledata(seg,offset,0, + LOCATsegrel | LOCbase | FD_F0 | FD_T4,idx,idx); + } +} + +/******************************* + * Refer to address that is in the code segment. + * Only offsets are output, regardless of the memory model. + * Used to put values in switch address tables. + * Input: + * seg = where the address is going (CODE or DATA) + * offset = offset within seg + * val = displacement from start of this module + */ + +void reftocodseg(int seg,targ_size_t offset,targ_size_t val) +{ unsigned framedatum; + unsigned lcfd; + + int idx = SegData[cseg]->segidx; + if (seg_is_comdat(idx)) // if comdat + { idx = -idx; + framedatum = idx; + lcfd = (LOCATsegrel | obj.LOCoffset) | (FD_F2 | FD_T6); + } + else if (config.exe & EX_flat) + { framedatum = 1; + lcfd = (LOCATsegrel | obj.LOCoffset) | (FD_F1 | FD_T4); + } + else + { framedatum = idx; + lcfd = (LOCATsegrel | obj.LOCoffset) | (FD_F0 | FD_T4); + } + + objledata(seg,offset,val,lcfd,framedatum,idx); +} + +/******************************* + * Refer to an identifier. + * Input: + * seg = where the address is going (CODE or DATA) + * offset = offset within seg + * s -> Symbol table entry for identifier + * val = displacement from identifier + * flags = CFselfrel: self-relative + * CFseg: get segment + * CFoff: get offset + * Returns: + * number of bytes in reference (2 or 4) + * Example: + * extern int def[]; + * int *abc = &def[3]; + * to allocate storage: + * reftodatseg(DATA,offset,3 * sizeof(int *),UDATA); + */ + +int reftoident(int seg,targ_size_t offset,Symbol *s,targ_size_t val, + int flags) +{ + unsigned targetdatum; // which datum the symbol is in + unsigned framedatum; + int lc; + int external; // !=0 if identifier is defined externally + int numbytes; + tym_t ty; + +#if 0 + printf("reftoident('%s' seg %d, offset x%lx, val x%lx, flags x%x)\n", + s->Sident,seg,offset,val,flags); + printf("Sseg = %d, Sxtrnnum = %d\n",s->Sseg,s->Sxtrnnum); + symbol_print(s); +#endif + assert(seg > 0); + + ty = s->ty(); + while (1) + { + switch (flags & (CFseg | CFoff)) + { case 0: + // Select default + flags |= CFoff; + if (tyfunc(ty)) + { + if (tyfarfunc(ty)) + flags |= CFseg; + } + else // DATA + { + if (LARGEDATA) + flags |= CFseg; + } + continue; + case CFoff: + if (I32) + { +#if 1 + if (ty & mTYthread) + { lc = LOC32tlsoffset; + } + else +#endif + lc = obj.LOCoffset; + } + else + { + // The 'loader_resolved' offset is required for VCM + // and Windows support. A fixup of this type is + // relocated by the linker to point to a 'thunk'. + lc = (tyfarfunc(ty) + && !(flags & CFselfrel)) + ? LOCloader_resolved : obj.LOCoffset; + } + numbytes = tysize[TYnptr]; + break; + case CFseg: + lc = LOCbase; + numbytes = 2; + break; + case CFoff | CFseg: + lc = obj.LOCpointer; +#if TARGET_SEGMENTED + numbytes = tysize[TYfptr]; +#else + numbytes = I64 ? 10 : 6; +#endif + break; + } + break; + } + + switch (s->Sclass) + { + case SCcomdat: + case_SCcomdat: + case SCextern: + case SCcomdef: + if (s->Sxtrnnum) // identifier is defined somewhere else + { external = s->Sxtrnnum; +#ifdef DEBUG + if (external > obj.extidx) + symbol_print(s); +#endif + assert(external <= obj.extidx); + } + else + { // Don't know yet, worry about it later + Ladd: + addtofixlist(s,offset,seg,val,flags); + return numbytes; + } + break; + case SCinline: + if (config.flags2 & CFG2comdat) + goto case_SCcomdat; // treat as initialized common block + case SCsinline: + case SCstatic: + case SCglobal: + if (s->Sseg == UNKNOWN) + goto Ladd; + if (seg_is_comdat(SegData[s->Sseg]->segidx)) + goto case_SCcomdat; + case SClocstat: + external = 0; // identifier is static or global + // and we know its offset + if (flags & CFoff) + val += s->Soffset; + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + + lc |= (flags & CFselfrel) ? LOCATselfrel : LOCATsegrel; + if (external) + { lc |= FD_T6; + targetdatum = external; + switch (s->Sfl) + { + case FLextern: + if (!(ty & ( +#if TARGET_SEGMENTED + mTYcs | +#endif + mTYthread))) + goto L1; + case FLfunc: +#if TARGET_SEGMENTED + case FLfardata: + case FLcsdata: +#endif + case FLtlsdata: + if (config.exe & EX_flat) + { lc |= FD_F1; + framedatum = 1; + } + else + { + //case FLtlsdata: + lc |= FD_F2; + framedatum = targetdatum; + } + break; + default: + goto L1; + } + } + else + { + lc |= FD_T4; // target is always a segment + targetdatum = SegData[s->Sseg]->segidx; + assert(s->Sseg != UNKNOWN); + switch (s->Sfl) + { + case FLextern: + if (!(ty & ( +#if TARGET_SEGMENTED + mTYcs | +#endif + mTYthread))) + goto L1; + case FLfunc: +#if TARGET_SEGMENTED + case FLfardata: + case FLcsdata: +#endif + case FLtlsdata: + if (config.exe & EX_flat) + { lc |= FD_F1; + framedatum = 1; + } + else + { + //case FLtlsdata: + lc |= FD_F0; + framedatum = targetdatum; + } + break; + default: + L1: + lc |= FD_F1; + framedatum = DGROUPIDX; + if (flags == CFseg) + { lc = LOCATsegrel | LOCbase | FD_F1 | FD_T5; + targetdatum = DGROUPIDX; + } +#if 0 + if (flags & CFseg && config.wflags & WFdsnedgroup) + warerr(WM_ds_ne_dgroup); +#endif + break; + } + } + + objledata(seg,offset,val,lc,framedatum,targetdatum); + return numbytes; +} + +/***************************************** + * Generate far16 thunk. + * Input: + * s Symbol to generate a thunk for + */ + +void obj_far16thunk(Symbol *s) +{ + static unsigned char cod32_1[] = + { + 0x55, // PUSH EBP + 0x8B,0xEC, // MOV EBP,ESP + 0x83,0xEC,0x04, // SUB ESP,4 + 0x53, // PUSH EBX + 0x57, // PUSH EDI + 0x56, // PUSH ESI + 0x06, // PUSH ES + 0x8C,0xD2, // MOV DX,SS + 0x80,0xE2,0x03, // AND DL,3 + 0x80,0xCA,0x07, // OR DL,7 + 0x89,0x65,0xFC, // MOV -4[EBP],ESP + 0x8C,0xD0, // MOV AX,SS + 0x66,0x3D, // 0x00,0x00 */ /* CMP AX,seg FLAT:_DATA + }; + static unsigned char cod32_2[] = + { 0x0F,0x85,0x10,0x00,0x00,0x00, // JNE L1 + 0x8B,0xC4, // MOV EAX,ESP + 0x66,0x3D,0x00,0x08, // CMP AX,2048 + 0x0F,0x83,0x04,0x00,0x00,0x00, // JAE L1 + 0x66,0x33,0xC0, // XOR AX,AX + 0x94, // XCHG ESP,EAX + // L1: + 0x55, // PUSH EBP + 0x8B,0xC4, // MOV EAX,ESP + 0x16, // PUSH SS + 0x50, // PUSH EAX + 0x8D,0x75,0x08, // LEA ESI,8[EBP] + 0x81,0xEC,0x00,0x00,0x00,0x00, // SUB ESP,numparam + 0x8B,0xFC, // MOV EDI,ESP + 0xB9,0x00,0x00,0x00,0x00, // MOV ECX,numparam + 0x66,0xF3,0xA4, // REP MOVSB + 0x8B,0xC4, // MOV EAX,ESP + 0xC1,0xC8,0x10, // ROR EAX,16 + 0x66,0xC1,0xE0,0x03, // SHL AX,3 + 0x0A,0xC2, // OR AL,DL + 0xC1,0xC0,0x10, // ROL EAX,16 + 0x50, // PUSH EAX + 0x66,0x0F,0xB2,0x24,0x24, // LSS SP,[ESP] + 0x66,0xEA, // 0,0,0,0, */ /* JMPF L3 + }; + static unsigned char cod32_3[] = + { // L2: + 0xC1,0xE0,0x10, // SHL EAX,16 + 0x0F,0xAC,0xD0,0x10, // SHRD EAX,EDX,16 + 0x0F,0xB7,0xE4, // MOVZX ESP,SP + 0x0F,0xB2,0x24,0x24, // LSS ESP,[ESP] + 0x5D, // POP EBP + 0x8B,0x65,0xFC, // MOV ESP,-4[EBP] + 0x07, // POP ES + 0x5E, // POP ESI + 0x5F, // POP EDI + 0x5B, // POP EBX + 0xC9, // LEAVE + 0xC2,0x00,0x00 // RET numparam + }; + + unsigned numparam = 24; + targ_size_t L2offset; + int idx; + + s->Sclass = SCstatic; + s->Sseg = cseg; // identifier is defined in code segment + s->Soffset = Coffset; + + // Store numparam into right places + assert((numparam & 0xFFFF) == numparam); // 2 byte value + TOWORD(&cod32_2[32],numparam); + TOWORD(&cod32_2[32 + 7],numparam); + TOWORD(&cod32_3[sizeof(cod32_3) - 2],numparam); + + //------------------------------------------ + // Generate CODE16 segment if it isn't there already + if (obj.code16segi == 0) + { + // Define CODE16 segment for far16 thunks + + static char lname[] = { "\06CODE16" }; + + // Put out LNAMES record + objrecord(LNAMES,lname,sizeof(lname) - 1); + + obj.code16segi = obj_newfarseg(0,4); + obj.CODE16offset = 0; + + // class CODE + unsigned attr = SEG_ATTR(SEG_ALIGN2,SEG_C_PUBLIC,0,USE16); + SegData[obj.code16segi]->attr = attr; + objsegdef(attr,0,obj.lnameidx++,4); + obj.segidx++; + } + + //------------------------------------------ + // Output the 32 bit thunk + + obj_bytes(cseg,Coffset,sizeof(cod32_1),cod32_1); + Coffset += sizeof(cod32_1); + + // Put out fixup for SEG FLAT:_DATA + objledata(cseg,Coffset,0,LOCATsegrel|LOCbase|FD_F1|FD_T4, + DGROUPIDX,DATA); + Coffset += 2; + + obj_bytes(cseg,Coffset,sizeof(cod32_2),cod32_2); + Coffset += sizeof(cod32_2); + + // Put out fixup to CODE16 part of thunk + objledata(cseg,Coffset,obj.CODE16offset,LOCATsegrel|LOC16pointer|FD_F0|FD_T4, + SegData[obj.code16segi]->segidx, + SegData[obj.code16segi]->segidx); + Coffset += 4; + + L2offset = Coffset; + obj_bytes(cseg,Coffset,sizeof(cod32_3),cod32_3); + Coffset += sizeof(cod32_3); + + s->Ssize = Coffset - s->Soffset; // size of thunk + + //------------------------------------------ + // Output the 16 bit thunk + + obj_byte(obj.code16segi,obj.CODE16offset++,0x9A); // CALLF function + + // Make function external + idx = objextern(s); // use Pascal name mangling + + // Output fixup for function + objledata(obj.code16segi,obj.CODE16offset,0,LOCATsegrel|LOC16pointer|FD_F2|FD_T6, + idx,idx); + obj.CODE16offset += 4; + + obj_bytes(obj.code16segi,obj.CODE16offset,3,"\x66\x67\xEA"); // JMPF L2 + obj.CODE16offset += 3; + + objledata(obj.code16segi,obj.CODE16offset,L2offset, + LOCATsegrel | LOC32pointer | FD_F1 | FD_T4, + DGROUPIDX, + SegData[cseg]->segidx); + obj.CODE16offset += 6; + + SegData[obj.code16segi]->SDoffset = obj.CODE16offset; +} + +/************************************** + * Mark object file as using floating point. + */ + +void obj_fltused() +{ + if (!obj.fltused) + { + obj.fltused = 1; + if (!(config.flags3 & CFG3wkfloat)) + objextdef("__fltused"); + } +} + + +/**************************************** + * Find longest match of pattern[] in dict[]. + */ + +static int longest_match(char *dict, int dlen, char *pattern, int plen, + int *pmatchoff, int *pmatchlen) +{ + int matchlen = 0; + int matchoff; + + int i; + int j; + + for (i = 0; i < dlen; i++) + { + if (dict[i] == pattern[0]) + { + for (j = 1; 1; j++) + { + if (i + j == dlen || j == plen) + break; + if (dict[i + j] != pattern[j]) + break; + } + if (j >= matchlen) + { + matchlen = j; + matchoff = i; + } + } + } + + if (matchlen > 1) + { + *pmatchlen = matchlen; + *pmatchoff = matchoff; + return 1; // found a match + } + return 0; // no match +} + +/****************************************** + * Compress an identifier. + * Format: if ASCII, then it's just the char + * if high bit set, then it's a length/offset pair + * Returns: + * malloc'd compressed identifier + */ + +char *id_compress(char *id, int idlen) +{ + int i; + int count = 0; + char *p; + + p = (char *)malloc(idlen + 1); + for (i = 0; i < idlen; i++) + { + int matchoff; + int matchlen; + + int j = 0; + if (i > 1023) + j = i - 1023; + + if (longest_match(id + j, i - j, id + i, idlen - i, &matchoff, &matchlen)) + { int off; + + matchoff += j; + off = i - matchoff; + //printf("matchoff = %3d, matchlen = %2d, off = %d\n", matchoff, matchlen, off); + assert(off >= matchlen); + + if (off <= 8 && matchlen <= 8) + { + p[count] = 0xC0 | ((off - 1) << 3) | (matchlen - 1); + count++; + i += matchlen - 1; + continue; + } + else if (matchlen > 2 && off < 1024) + { + if (matchlen >= 1024) + matchlen = 1023; // longest representable match + p[count + 0] = 0x80 | ((matchlen >> 4) & 0x38) | ((off >> 7) & 7); + p[count + 1] = 0x80 | matchlen; + p[count + 2] = 0x80 | off; + count += 3; + i += matchlen - 1; + continue; + } + } + p[count] = id[i]; + count++; + } + p[count] = 0; + //printf("old size = %d, new size = %d\n", idlen, count); + return p; +} + +#endif +#endif diff --git a/backend/cgreg.c b/backend/cgreg.c new file mode 100644 index 00000000..084a6a7c --- /dev/null +++ b/backend/cgreg.c @@ -0,0 +1,1013 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2012 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if !SPP + +#include +#include +#include +#include +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "global.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +STATIC void el_weights(int bi,elem *e,unsigned weight); + +#ifndef __DMC__ +#undef __cdecl +#define __cdecl +#endif + +static int __cdecl weight_compare(const void *e1,const void *e2); + +static int nretblocks; + +static vec_t regrange[REGMAX]; + +static int *weights; +#define WEIGHTS(bi,si) weights[bi * globsym.top + si] + +/****************************************** + */ + +void cgreg_init() +{ + if (!(config.flags4 & CFG4optimized)) + return; + + // Use calloc() instead because sometimes the alloc is too large + //printf("1weights: dfotop = %d, globsym.top = %d\n", dfotop, globsym.top); + weights = (int *) calloc(1,dfotop * globsym.top * sizeof(weights[0])); + assert(weights); + + nretblocks = 0; + for (int bi = 0; bi < dfotop; bi++) + { block *b = dfo[bi]; + if (b->BC == BCret || b->BC == BCretexp) + nretblocks++; + if (b->Belem) + { + //printf("b->Bweight = x%x\n",b->Bweight); + el_weights(bi,b->Belem,b->Bweight); + } + } + memset(regrange,0,sizeof(regrange)); + + // Make adjustments to symbols we might stick in registers + for (size_t i = 0; i < globsym.top; i++) + { unsigned sz; + symbol *s = globsym.tab[i]; + + //printf("candidate '%s' for register\n",s->Sident); + + if (s->Srange) + s->Srange = vec_realloc(s->Srange,dfotop); + + // Determine symbols that are not candidates + if (!(s->Sflags & GTregcand) || + !s->Srange || + (sz = type_size(s->Stype)) == 0 || + (tysize(s->ty()) == -1) || + (I16 && sz > REGSIZE) || + (tyfloating(s->ty()) && !(config.fpxmmregs && tyxmmreg(s->ty()))) + ) + { + #ifdef DEBUG + if (debugr) + printf("not considering variable '%s' for register\n",s->Sident); + #endif + s->Sflags &= ~GTregcand; + continue; + } + + switch (s->Sclass) + { case SCparameter: + case SCfastpar: + // Do not put parameters in registers if they are not used + // more than twice (otherwise we have a net loss). + if (s->Sweight <= 2 && !tyxmmreg(s->ty())) + { + #ifdef DEBUG + if (debugr) + printf("parameter '%s' weight %d is not enough\n",s->Sident,s->Sweight); + #endif + s->Sflags &= ~GTregcand; + continue; + } + break; + } + + if (sz == 1) + s->Sflags |= GTbyte; + + if (!s->Slvreg) + s->Slvreg = vec_calloc(dfotop); + + //printf("dfotop = %d, numbits = %d\n",dfotop,vec_numbits(s->Srange)); + assert(vec_numbits(s->Srange) == dfotop); + } +} + +/****************************************** + */ + +void cgreg_term() +{ + if (config.flags4 & CFG4optimized) + { + for (size_t i = 0; i < globsym.top; i++) + { + Symbol *s = globsym.tab[i]; + vec_free(s->Srange); + vec_free(s->Slvreg); + s->Srange = NULL; + s->Slvreg = NULL; + } + + for (size_t i = 0; i < arraysize(regrange); i++) + { + if (regrange[i]) + { vec_free(regrange[i]); + regrange[i] = NULL; + } + } + + free(weights); + weights = NULL; + } +} + +/********************************* + */ + +void cgreg_reset() +{ + for (size_t j = 0; j < arraysize(regrange); j++) + if (!regrange[j]) + regrange[j] = vec_calloc(dfotop); + else + vec_clear(regrange[j]); +} + +/******************************* + * Registers used in block bi. + */ + +void cgreg_used(unsigned bi,regm_t used) +{ + for (size_t j = 0; used; j++) + { if (used & 1) // if register j is used + vec_setbit(bi,regrange[j]); + used >>= 1; + } +} + +/************************* + * Run through a tree calculating symbol weights. + */ + +STATIC void el_weights(int bi,elem *e,unsigned weight) +{ + while (1) + { elem_debug(e); + + int op = e->Eoper; + if (!OTleaf(op)) + { + // This prevents variable references within common subexpressions + // from adding to the variable's usage count. + if (e->Ecount) + { + if (e->Ecomsub) + weight = 0; + else + e->Ecomsub = 1; + } + + if (OTbinary(op)) + { el_weights(bi,e->E2,weight); + if ((OTopeq(op) || OTpost(op)) && e->E1->Eoper == OPvar) + { + if (weight >= 10) + weight += 10; + else + weight++; + } + } + e = e->E1; + } + else + { + switch (op) + { + case OPvar: + Symbol *s = e->EV.sp.Vsym; + if (s->Ssymnum != -1 && s->Sflags & GTregcand) + { + s->Sweight += weight; + //printf("adding %d weight to '%s' (block %d, Ssymnum %d), giving Sweight %d\n",weight,s->Sident,bi,s->Ssymnum,s->Sweight); + if (weights) + WEIGHTS(bi,s->Ssymnum) += weight; + } + break; + } + return; + } + } +} + +/***************************************** + * Determine 'benefit' of assigning symbol s to register reg. + * Benefit is roughly the number of clocks saved. + * A negative value means that s cannot or should not be assigned to reg. + */ + +int cgreg_benefit(Symbol *s,int reg, Symbol *retsym) +{ + int benefit; + int benefit2; + block *b; + int bi; + int gotoepilog; + int retsym_cnt; + + //printf("cgreg_benefit(s = '%s', reg = %d)\n", s->Sident, reg); + + vec_sub(s->Slvreg,s->Srange,regrange[reg]); + int si = s->Ssymnum; + +Lagain: + //printf("again\n"); + benefit = 0; + retsym_cnt = 0; + + // Make sure we have enough uses to justify + // using a register we must save + if (fregsaved & mask[reg] & mfuncreg) + benefit -= 1 + nretblocks; + + foreach (bi,dfotop,s->Srange) + { int inoutp; + int inout; + + b = dfo[bi]; + switch (b->BC) + { + case BCjcatch: + case BCcatch: + case BC_except: + case BC_finally: + case BC_ret: + s->Sflags &= ~GTregcand; + goto Lcant; // can't assign to register + } + if (vec_testbit(bi,s->Slvreg)) + { benefit += WEIGHTS(bi,si); + //printf("WEIGHTS(%d,%d) = %d, benefit = %d\n",bi,si,WEIGHTS(bi,si),benefit); + inout = 1; + + if (s == retsym && (reg == AX || reg == XMM0) && b->BC == BCretexp) + { benefit += 1; + retsym_cnt++; + //printf("retsym, benefit = %d\n",benefit); + if (s->Sfl == FLreg && !vec_disjoint(s->Srange,regrange[reg])) + goto Lcant; // don't spill if already in register + } + } + else + inout = -1; + + // Look at predecessors to see if we need to load in/out of register + gotoepilog = 0; + L2: + inoutp = 0; + benefit2 = 0; + for (list_t bl = b->Bpred; bl; bl = list_next(bl)) + { + block *bp = list_block(bl); + int bpi = bp->Bdfoidx; + if (!vec_testbit(bpi,s->Srange)) + continue; + if (gotoepilog && bp->BC == BCgoto) + { + if (vec_testbit(bpi,s->Slvreg)) + { + if (inout == -1) + benefit2 -= bp->Bweight; // need to mov into mem + } + else + { + if (inout == 1) + benefit2 -= bp->Bweight; // need to mov into reg + } + } + else if (vec_testbit(bpi,s->Slvreg)) + { + switch (inoutp) + { + case 0: + inoutp = 1; + if (inout != 1) + { if (gotoepilog) + { vec_clearbit(bpi,s->Slvreg); + goto Lagain; + } + benefit2 -= b->Bweight; // need to mov into mem + } + break; + case 1: + break; + case -1: + if (gotoepilog == 0) + { gotoepilog = 1; + goto L2; + } + vec_clearbit(bpi,s->Slvreg); + goto Lagain; + } + } + else + { + switch (inoutp) + { + case 0: + inoutp = -1; + if (inout != -1) + { if (gotoepilog) + { vec_clearbit(bi,s->Slvreg); + goto Lagain; + } + benefit2 -= b->Bweight; // need to mov into reg + } + break; + case 1: + if (gotoepilog == 0) + { gotoepilog = 1; + goto L2; + } + if (inout == 1) + { vec_clearbit(bi,s->Slvreg); + goto Lagain; + } + goto Lcant; + case -1: + break; + } + } + } + //printf("benefit2 = %d\n", benefit2); + benefit += benefit2; + } + +#ifdef DEBUG + //printf("2weights: dfotop = %d, globsym.top = %d\n", dfotop, globsym.top); + if (benefit > s->Sweight + retsym_cnt) + printf("s = '%s', benefit = %d, Sweight = %d, retsym_cnt = x%x\n",s->Sident,benefit,s->Sweight, retsym_cnt); +#endif + assert(benefit <= s->Sweight + retsym_cnt); + return benefit; + +Lcant: + return -1; // can't assign to reg +} + +/********************************************* + * Determine if block gets symbol loaded by predecessor epilog (1), + * or by prolog (0). + */ + +int cgreg_gotoepilog(block *b,Symbol *s) +{ + int bi = b->Bdfoidx; + + int inout; + if (vec_testbit(bi,s->Slvreg)) + inout = 1; + else + inout = -1; + + // Look at predecessors to see if we need to load in/out of register + int gotoepilog = 0; + int inoutp = 0; + for (list_t bl = b->Bpred; bl; bl = list_next(bl)) + { + block *bp = list_block(bl); + int bpi = bp->Bdfoidx; + if (!vec_testbit(bpi,s->Srange)) + continue; + if (vec_testbit(bpi,s->Slvreg)) + { + switch (inoutp) + { + case 0: + inoutp = 1; + if (inout != 1) + { if (gotoepilog) + goto Lcant; + } + break; + case 1: + break; + case -1: + if (gotoepilog == 0) + { gotoepilog = 1; + goto Lret; + } + goto Lcant; + } + } + else + { + switch (inoutp) + { + case 0: + inoutp = -1; + if (inout != -1) + { if (gotoepilog) + goto Lcant; + } + break; + case 1: + if (gotoepilog == 0) + { gotoepilog = 1; + goto Lret; + } + goto Lcant; + case -1: + break; + } + } + } +Lret: + return gotoepilog; + +Lcant: + assert(0); + return -1; // can't assign to reg +} + +/********************************** + * Determine block prolog code - it's either + * assignments to register, or storing register back in memory. + */ + +void cgreg_spillreg_prolog(block *b,Symbol *s,code **pcstore,code **pcload) +{ + list_t bl; + code *cstore = *pcstore; + code *cload = *pcload; + int bi = b->Bdfoidx; + + //printf("cgreg_spillreg_prolog(block %d, s = '%s')\n",bi,s->Sident); + + int inoutp; + if (vec_testbit(bi,s->Slvreg)) + { inoutp = 1; + // If it's startblock, and it's a spilled parameter, we + // need to load it + if (s->Sflags & SFLspill && bi == 0 && + (s->Sclass == SCparameter || s->Sclass == SCfastpar)) + { + goto Lload; + } + } + else + inoutp = -1; + + if (cgreg_gotoepilog(b,s)) + return; + + // Look at predecessors to see if we need to load in/out of register + for (bl = b->Bpred; bl; bl = list_next(bl)) + { + { + block *bp = list_block(bl); + int bpi = bp->Bdfoidx; + + if (!vec_testbit(bpi,s->Srange)) + continue; + if (vec_testbit(bpi,s->Slvreg)) + { + if (inoutp != -1) + continue; + } + else + { + if (inoutp != 1) + continue; + } + } + +Lload: +#ifdef DEBUG + if (debugr) + { + int sz = type_size(s->Stype); + if (inoutp == -1) + printf("B%d: prolog moving %s into '%s'\n",bi,regstring[s->Sreglsw],s->Sident); + else + printf("B%d: prolog moving '%s' into %s:%s\n", + bi, s->Sident, regstring[s->Sregmsw], sz > REGSIZE ? regstring[s->Sreglsw] : ""); + } +#endif + + code* c = gen_spill_reg(s, inoutp == 1); + + if (inoutp == -1) + cstore = cat(cstore,c); + else + cload = cat(cload,c); + break; + } + + // Store old register values before loading in new ones + *pcstore = cstore; + *pcload = cload; +} + +/********************************** + * Determine block epilog code - it's either + * assignments to register, or storing register back in memory. + */ + +void cgreg_spillreg_epilog(block *b,Symbol *s,code **pcstore,code **pcload) +{ + code *cstore = *pcstore; + code *cload = *pcload; + int bi = b->Bdfoidx; + + //printf("cgreg_spillreg_epilog(block %d, s = '%s')\n",bi,s->Sident); + //assert(b->BC == BCgoto); + if (!cgreg_gotoepilog(list_block(b->Bsucc),s)) + return; + + int inoutp; + if (vec_testbit(bi,s->Slvreg)) + inoutp = 1; + else + inoutp = -1; + + // Look at successors to see if we need to load in/out of register + for (list_t bl = b->Bsucc; bl; bl = list_next(bl)) + { + block *bp = list_block(bl); + int bpi = bp->Bdfoidx; + if (!vec_testbit(bpi,s->Srange)) + continue; + if (vec_testbit(bpi,s->Slvreg)) + { + if (inoutp != -1) + continue; + } + else + { + if (inoutp != 1) + continue; + } + +#ifdef DEBUG + if (debugr) + { + if (inoutp == 1) + printf("B%d: epilog moving %s into '%s'\n",bi,regstring[s->Sreglsw],s->Sident); + else + printf("B%d: epilog moving '%s' into %s\n",bi,s->Sident,regstring[s->Sreglsw]); + } +#endif + + code* c = gen_spill_reg(s, inoutp == -1); + + if (inoutp == 1) + cstore = cat(cstore,c); + else + cload = cat(cload,c); + break; + } + + // Store old register values before loading in new ones + *pcstore = cstore; + *pcload = cload; +} + +/*************************** + * Map symbol s into registers [NOREG,reglsw] or [regmsw, reglsw]. + */ + +void cgreg_map(Symbol *s, unsigned regmsw, unsigned reglsw) +{ + //assert(I64 || reglsw < 8); + + if (vec_disjoint(s->Srange,regrange[reglsw]) && + (regmsw == NOREG || vec_disjoint(s->Srange,regrange[regmsw])) + ) + { + s->Sfl = FLreg; + vec_copy(s->Slvreg,s->Srange); + } + else + { + s->Sflags |= SFLspill; + + // Already computed by cgreg_benefit() + //vec_sub(s->Slvreg,s->Srange,regrange[reglsw]); + + if (s->Sfl == FLreg) // if reassigned + { + switch (s->Sclass) + { + case SCauto: + case SCregister: + case SCtmp: + case SCfastpar: + s->Sfl = FLauto; + break; + case SCbprel: + s->Sfl = FLbprel; + break; + case SCparameter: + s->Sfl = FLpara; + break; +#if PSEUDO_REGS + case SCpseudo: + s->Sfl = FLpseudo; + break; +#endif + case SCstack: + s->Sfl = FLstack; + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + } + } + s->Sreglsw = reglsw; + s->Sregm = mask[reglsw]; + mfuncreg &= ~mask[reglsw]; + if (regmsw != NOREG) + vec_subass(s->Slvreg,regrange[regmsw]); + vec_orass(regrange[reglsw],s->Slvreg); + + if (regmsw == NOREG) + { + #if DEBUG + if (debugr) + { + printf("symbol '%s' %s in register %s\n ", + s->Sident, + (s->Sflags & SFLspill) ? "spilled" : "put", + regstring[reglsw]); + vec_println(s->Slvreg); + } + #endif + } + else + { + assert(regmsw < 8); + s->Sregmsw = regmsw; + s->Sregm |= mask[regmsw]; + mfuncreg &= ~mask[regmsw]; + vec_orass(regrange[regmsw],s->Slvreg); + + #if DEBUG + if (debugr) + printf("symbol '%s' %s in register pair %s\n", + s->Sident, + (s->Sflags & SFLspill) ? "spilled" : "put", + regm_str(s->Sregm)); + #endif + } +} + +/******************************************** + * The register variables in this mask can not be in registers. + * "Unregister" them. + */ + +void cgreg_unregister(regm_t conflict) +{ + if (pass == PASSfinal) + pass = PASSreg; // have to codegen at least one more time + for (int i = 0; i < globsym.top; i++) + { symbol *s = globsym.tab[i]; + if (s->Sfl == FLreg && s->Sregm & conflict) + { + s->Sflags |= GTunregister; + } + } +} + +/****************************************** + * Do register assignments. + * Returns: + * !=0 redo code generation + * 0 no more register assignments + */ + +struct Reg // data for trial register assignment +{ + Symbol *sym; + int reglsw; + int regmsw; + int benefit; +}; + +int cgreg_assign(Symbol *retsym) +{ + int flag = FALSE; // assume no changes + + /* First do any 'unregistering' which might have happened in the last + * code gen pass. + */ + for (size_t si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + + if (s->Sflags & GTunregister) + { + #if DEBUG + if (debugr) + { + printf("symbol '%s' %s register %s\n ", + s->Sident, + (s->Sflags & SFLspill) ? "unspilled" : "unregistered", + regstring[s->Sreglsw]); + vec_println(s->Slvreg); + } + #endif + flag = TRUE; + s->Sflags &= ~(GTregcand | GTunregister | SFLspill); + if (s->Sfl == FLreg) + { + switch (s->Sclass) + { + case SCauto: + case SCregister: + case SCtmp: + case SCfastpar: + s->Sfl = FLauto; + break; + case SCbprel: + s->Sfl = FLbprel; + break; + case SCparameter: + s->Sfl = FLpara; + break; +#if PSEUDO_REGS + case SCpseudo: + s->Sfl = FLpseudo; + break; +#endif + case SCstack: + s->Sfl = FLstack; + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + } + } + } + + vec_t v = vec_calloc(dfotop); + + // Find symbol t, which is the most 'deserving' symbol that should be + // placed into a register. + Reg t; + t.sym = NULL; + t.benefit = 0; + for (size_t si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + + Reg u; + u.sym = s; + if (!(s->Sflags & GTregcand) || + s->Sflags & SFLspill || + // Keep trying to reassign retsym into AX + (s->Sfl == FLreg && !(s == retsym && s->Sregm != mAX && s->Sregm != mXMM0)) + ) + { + #ifdef DEBUG + if (debugr) + if (s->Sfl == FLreg) + printf("symbol '%s' is in reg %s\n",s->Sident,regm_str(s->Sregm)); + else if (s->Sflags & SFLspill) + printf("symbol '%s' spilled in reg %s\n",s->Sident,regm_str(s->Sregm)); + else if (!(s->Sflags & GTregcand)) + printf("symbol '%s' is not a reg candidate\n",s->Sident); + else + printf("symbol '%s' is not a candidate\n",s->Sident); + #endif + continue; + } + + tym_t ty = s->ty(); + unsigned sz = tysize(ty); + + #ifdef DEBUG + if (debugr) + { printf("symbol '%3s', ty x%x weight x%x sz %d\n ", + s->Sident,ty,s->Sweight,(int)sz); + vec_println(s->Srange); + } + #endif + + // Select sequence of registers to try to map s onto + char *pseq; // sequence to try for LSW + char *pseqmsw = NULL; // sequence to try for MSW, NULL if none + if (tyxmmreg(ty)) + { + static char sequence[] = {XMM0,XMM1,XMM2,XMM3,XMM4,XMM5,XMM6,XMM7,NOREG}; + pseq = sequence; + } + else if (I64) + { + if (sz == REGSIZE * 2) + { + static char seqmsw[] = {CX,DX,NOREG}; + static char seqlsw[] = {AX,BX,SI,DI,NOREG}; + pseq = seqlsw; + pseqmsw = seqmsw; + } + else + { // R10 is reserved for the static link + static char sequence[] = {AX,CX,DX,SI,DI,R8,R9,R11,BX,R12,R13,R14,R15,BP,NOREG}; + pseq = sequence; + } + } + else if (I32) + { + if (sz == REGSIZE * 2) + { + static char seqlsw[] = {AX,BX,SI,DI,NOREG}; + static char seqmsw[] = {CX,DX,NOREG}; + pseq = seqlsw; + pseqmsw = seqmsw; + } + else + { + static char sequence[] = {AX,CX,DX,BX,SI,DI,BP,NOREG}; + pseq = sequence; + } + } + else + { assert(I16); + if (typtr(ty)) + { + // For pointer types, try to pick index register first + static char seqidx[] = {BX,SI,DI,AX,CX,DX,BP,NOREG}; + pseq = seqidx; + } + else + { + // Otherwise, try to pick index registers last + static char sequence[] = {AX,CX,DX,BX,SI,DI,BP,NOREG}; + pseq = sequence; + } + } + + u.benefit = 0; + for (int i = 0; pseq[i] != NOREG; i++) + { + unsigned reg = pseq[i]; + + // Symbols used as return values should only be mapped into return value registers + if (s == retsym && !(mask[reg] & (mAX | mXMM0))) + continue; + + // If BP isn't available, can't assign to it + if (reg == BP && !(allregs & mBP)) + continue; + +#if 0 && TARGET_LINUX + // Need EBX for static pointer + if (reg == BX && !(allregs & mBX)) + continue; +#endif + + if (s->Sflags & GTbyte && + !(mask[reg] & BYTEREGS)) + continue; + + int benefit = cgreg_benefit(s,reg,retsym); + + #ifdef DEBUG + if (debugr) + { printf(" %s",regstring[reg]); + vec_print(regrange[reg]); + printf(" %d\n",benefit); + } + #endif + + if (benefit > u.benefit) + { // successful assigning of lsw + unsigned regmsw = NOREG; + + // Now assign MSW + if (pseqmsw) + { + for (unsigned regj = 0; 1; regj++) + { + regmsw = pseqmsw[regj]; + if (regmsw == NOREG) + goto Ltried; // tried and failed to assign MSW + if (regmsw == reg) // can't assign msw and lsw to same reg + continue; + #ifdef DEBUG + if (debugr) + { printf(".%s",regstring[regmsw]); + vec_println(regrange[regmsw]); + } + #endif + if (vec_disjoint(s->Slvreg,regrange[regmsw])) + break; + } + } + vec_copy(v,s->Slvreg); + u.benefit = benefit; + u.reglsw = reg; + u.regmsw = regmsw; + } +Ltried: ; + } + + if (u.benefit > t.benefit) + { t = u; + vec_copy(t.sym->Slvreg,v); + } + } + + if (t.sym && t.benefit > 0) + { + cgreg_map(t.sym,t.regmsw,t.reglsw); + flag = TRUE; + } + + /* See if any scratch registers have become available that we can use. + * Scratch registers are cheaper, as they don't need save/restore. + * All floating point registers are scratch registers, so no need + * to do this for them. + */ + if ((I32 || I64) && // not worth the bother for 16 bit code + !flag && // if haven't already assigned registers in this pass + (mfuncreg & ~fregsaved) & ALLREGS && // if unused non-floating scratch registers + !(funcsym_p->Sflags & SFLexit)) // don't need save/restore if function never returns + { + for (size_t si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + + if (s->Sfl == FLreg && // if assigned to register + mask[s->Sreglsw] & fregsaved && // and that register is not scratch + type_size(s->Stype) <= REGSIZE && // don't bother with register pairs + !tyfloating(s->ty())) // don't assign floating regs to non-floating regs + { + s->Sreglsw = findreg((mfuncreg & ~fregsaved) & ALLREGS); + s->Sregm = mask[s->Sreglsw]; + flag = TRUE; +#ifdef DEBUG + if (debugr) + printf("re-assigned '%s' to %s\n",s->Sident,regstring[s->Sreglsw]); +#endif + break; + } + } + } + vec_free(v); + + return flag; +} + +////////////////////////////////////// +// Qsort() comparison routine for array of pointers to Symbol's. + +static int __cdecl weight_compare(const void *e1,const void *e2) +{ Symbol **psp1; + Symbol **psp2; + + psp1 = (Symbol **)e1; + psp2 = (Symbol **)e2; + + return (*psp2)->Sweight - (*psp1)->Sweight; +} + + +#endif diff --git a/backend/cgsched.c b/backend/cgsched.c new file mode 100644 index 00000000..e3edf170 --- /dev/null +++ b/backend/cgsched.c @@ -0,0 +1,3206 @@ +// Copyright (C) 1995-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include + +#include "cc.h" +#include "el.h" +#include "code.h" +#include "oper.h" +#include "global.h" +#include "type.h" +#include "exh.h" +#include "list.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +// If we use Pentium Pro scheduler +#if 0 +#define PRO (config.target_scheduler >= TARGET_PentiumPro) +#else +#define PRO (config.target_cpu >= TARGET_PentiumPro) +#endif + +// Struct where we gather information about an instruction +struct Cinfo +{ + code *c; // the instruction + unsigned char pair; // pairing information + unsigned char sz; // operand size + unsigned char isz; // instruction size + + // For floating point scheduling + unsigned char fxch_pre; + unsigned char fxch_post; + unsigned char fp_op; + #define FPfstp 1 // FSTP mem + #define FPfld 2 // FLD mem + #define FPfop 3 // Fop ST0,mem or Fop ST0 + + unsigned char flags; +#define CIFLarraybounds 1 // this instruction is a jmp to array bounds +#define CIFLea 2 // this instruction has a memory-referencing + // modregrm EA byte +#define CIFLnostage 4 // don't stage these instructions +#define CIFLpush 8 // it's a push we can swap around + + unsigned r; // read mask + unsigned w; // write mask + unsigned a; // registers used in addressing mode + unsigned char reg; // reg field of modregrm byte + unsigned char uops; // Pentium Pro micro-ops + unsigned sibmodrm; // (sib << 8) + mod__rm byte + unsigned spadjust; // if !=0, then amount ESP changes as a result of this + // instruction being executed + int fpuadjust; // if !=0, then amount FPU stack changes as a result + // of this instruction being executed +#if DEBUG + void print(); // pretty-printer +#endif +}; + +code *simpleops(code *c,regm_t scratch); +code *schedule(code *c,regm_t scratch); +code *peephole(code *c,regm_t scratch); + +/***************************************** + * Do Pentium optimizations. + * Input: + * scratch scratch registers we can use + */ + +void cgsched_pentium(code **pc,regm_t scratch) +{ + //printf("scratch = x%02x\n",scratch); + if (config.target_scheduler >= TARGET_80486) + { + if (!I64) + *pc = peephole(*pc,0); + if (I32) // forget about 16 bit code + { + if (config.target_cpu == TARGET_Pentium || + config.target_cpu == TARGET_PentiumMMX) + *pc = simpleops(*pc,scratch); + *pc = schedule(*pc,0); + } + } +} + +void cgsched_block(block* b) +{ + if (config.flags4 & CFG4speed && + config.target_cpu >= TARGET_Pentium && + b->BC != BCasm) + { + regm_t scratch = allregs; + + scratch &= ~(b->Bregcon.used | b->Bregcon.params | mfuncreg); + scratch &= ~(b->Bregcon.immed.mval | b->Bregcon.cse.mval); + cgsched_pentium(&b->Bcode,scratch); + //printf("after schedule:\n"); WRcodlst(b->Bcode); + } +} + +#define NP 0 // not pairable +#define PU 1 // pairable in U only, never executed in V +#define PV 2 // pairable in V only +#define UV (PU|PV) // pairable in both U and V +#define PE 4 // register contention exception +#define PF 8 // flags contention exception +#define FX 0x10 // pairable with FXCH instruction + +static unsigned char pentcycl[256] = +{ + UV,UV,UV,UV, UV,UV,NP,NP, // 0 + UV,UV,UV,UV, UV,UV,NP,NP, // 8 + PU,PU,PU,PU, PU,PU,NP,NP, // 10 + PU,PU,PU,PU, PU,PU,NP,NP, // 18 + UV,UV,UV,UV, UV,UV,NP,NP, // 20 + UV,UV,UV,UV, UV,UV,NP,NP, // 28 + UV,UV,UV,UV, UV,UV,NP,NP, // 30 + UV,UV,UV,UV, UV,UV,NP,NP, // 38 + + UV,UV,UV,UV, UV,UV,UV,UV, // 40 + UV,UV,UV,UV, UV,UV,UV,UV, // 48 + PE|UV,PE|UV,PE|UV,PE|UV, PE|UV,PE|UV,PE|UV,PE|UV, // 50 PUSH reg + PE|UV,PE|UV,PE|UV,PE|UV, PE|UV,PE|UV,PE|UV,PE|UV, // 58 POP reg + NP,NP,NP,NP, NP,NP,NP,NP, // 60 + PE|UV,NP,PE|UV,NP, NP,NP,NP,NP, // 68 + PV|PF,PV|PF,PV|PF,PV|PF, PV|PF,PV|PF,PV|PF,PV|PF, // 70 Jcc rel8 + PV|PF,PV|PF,PV|PF,PV|PF, PV|PF,PV|PF,PV|PF,PV|PF, // 78 Jcc rel8 + + NP,NP,NP,NP, NP,NP,NP,NP, // 80 + UV,UV,UV,UV, NP,UV,NP,NP, // 88 + NP,NP,NP,NP, NP,NP,NP,NP, // 90 + NP,NP,NP,NP, NP,NP,NP,NP, // 98 + UV,UV,UV,UV, NP,NP,NP,NP, // A0 + UV,UV,NP,NP, NP,NP,NP,NP, // A8 + UV,UV,UV,UV, UV,UV,UV,UV, // B0 + UV,UV,UV,UV, UV,UV,UV,UV, // B8 + + NP,NP,NP,NP, NP,NP,NP,NP, // C0 + NP,NP,NP,NP, NP,NP,NP,NP, // C8 + PU,PU,NP,NP, NP,NP,NP,NP, // D0 + FX,NP,FX,FX, NP,NP,FX,NP, // D8 all floating point + NP,NP,NP,NP, NP,NP,NP,NP, // E0 + PE|PV,PV,NP,PV, NP,NP,NP,NP, // E8 + NP,NP,NP,NP, NP,NP,NP,NP, // F0 + NP,NP,NP,NP, NP,NP,NP,NP, // F8 +}; + +/******************************************** + * For each opcode, determine read [0] and written [1] masks. + */ + +#define EA 0x100000 +#define R 0x200000 // register (reg of modregrm field) +#define N 0x400000 // other things modified, not swappable +#define B 0x800000 // it's a byte operation +#define C 0x1000000 // floating point flags +#define mMEM 0x2000000 // memory +#define S 0x4000000 // floating point stack +#define F 0x8000000 // flags + +static unsigned oprw[256][2] = +{ + // 00 + EA|R|B, F|EA|B, // ADD + EA|R, F|EA, + EA|R|B, F|R|B, + EA|R, F|R, + mAX, F|mAX, + mAX, F|mAX, + N, N, // PUSH ES + N, N, // POP ES + + // 08 + EA|R|B, F|EA|B, // OR + EA|R, F|EA, + EA|R|B, F|R|B, + EA|R, F|R, + mAX, F|mAX, + mAX, F|mAX, + N, N, // PUSH CS + N, N, // 2 byte escape + + // 10 + F|EA|R|B,F|EA|B, // ADC + F|EA|R, F|EA, + F|EA|R|B,F|R|B, + F|EA|R, F|R, + F|mAX, F|mAX, + F|mAX, F|mAX, + N, N, // PUSH SS + N, N, // POP SS + + // 18 + F|EA|R|B,F|EA|B, // SBB + F|EA|R, F|EA, + F|EA|R|B,F|R|B, + F|EA|R, F|R, + F|mAX, F|mAX, + F|mAX, F|mAX, + N, N, // PUSH DS + N, N, // POP DS + + // 20 + EA|R|B, F|EA|B, // AND + EA|R, F|EA, + EA|R|B, F|R|B, + EA|R, F|R, + mAX, F|mAX, + mAX, F|mAX, + N, N, // SEG ES + F|mAX, F|mAX, // DAA + + // 28 + EA|R|B, F|EA|B, // SUB + EA|R, F|EA, + EA|R|B, F|R|B, + EA|R, F|R, + mAX, F|mAX, + mAX, F|mAX, + N, N, // SEG CS + F|mAX, F|mAX, // DAS + + // 30 + EA|R|B, F|EA|B, // XOR + EA|R, F|EA, + EA|R|B, F|R|B, + EA|R, F|R, + mAX, F|mAX, + mAX, F|mAX, + N, N, // SEG SS + F|mAX, F|mAX, // AAA + + // 38 + EA|R|B, F, // CMP + EA|R, F, + EA|R|B, F, + EA|R, F, + mAX, F, // CMP AL,imm8 + mAX, F, // CMP EAX,imm16/32 + N, N, // SEG DS + N, N, // AAS + + // 40 + mAX, F|mAX, // INC EAX + mCX, F|mCX, + mDX, F|mDX, + mBX, F|mBX, + mSP, F|mSP, + mBP, F|mBP, + mSI, F|mSI, + mDI, F|mDI, + + // 48 + mAX, F|mAX, // DEC EAX + mCX, F|mCX, + mDX, F|mDX, + mBX, F|mBX, + mSP, F|mSP, + mBP, F|mBP, + mSI, F|mSI, + mDI, F|mDI, + + // 50 + mAX|mSP, mSP|mMEM, // PUSH EAX + mCX|mSP, mSP|mMEM, + mDX|mSP, mSP|mMEM, + mBX|mSP, mSP|mMEM, + mSP|mSP, mSP|mMEM, + mBP|mSP, mSP|mMEM, + mSI|mSP, mSP|mMEM, + mDI|mSP, mSP|mMEM, + + // 58 + mSP|mMEM, mAX|mSP, // POP EAX + mSP|mMEM, mCX|mSP, + mSP|mMEM, mDX|mSP, + mSP|mMEM, mBX|mSP, + mSP|mMEM, mSP|mSP, + mSP|mMEM, mBP|mSP, + mSP|mMEM, mSI|mSP, + mSP|mMEM, mDI|mSP, + + // 60 + N, N, // PUSHA + N, N, // POPA + N, N, // BOUND Gv,Ma + N, N, // ARPL Ew,Rw + N, N, // SEG FS + N, N, // SEG GS + N, N, // operand size prefix + N, N, // address size prefix + + // 68 + mSP, mSP|mMEM, // PUSH immed16/32 + EA, F|R, // IMUL Gv,Ev,lv + mSP, mSP|mMEM, // PUSH immed8 + EA, F|R, // IMUL Gv,Ev,lb + N, N, // INSB Yb,DX + N, N, // INSW/D Yv,DX + N, N, // OUTSB DX,Xb + N, N, // OUTSW/D DX,Xv + + // 70 + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + + // 78 + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + F|N, N, + + // 80 + N, N, + N, N, + N, N, + N, N, + EA|R, F, // TEST EA,r8 + EA|R, F, // TEST EA,r16/32 + EA|R, EA|R, // XCHG EA,r8 + EA|R, EA|R, // XCHG EA,r16/32 + + // 88 + R|B, EA|B, // MOV EA8,r8 + R, EA, // MOV EA,r16/32 + EA|B, R|B, // MOV r8,EA8 + EA, R, // MOV r16/32,EA + N, N, // MOV EA,segreg + EA, R, // LEA r16/32,EA + N, N, // MOV segreg,EA + mSP|mMEM, EA|mSP, // POP mem16/32 + + // 90 + 0, 0, // NOP + mAX|mCX, mAX|mCX, + mAX|mDX, mAX|mDX, + mAX|mBX, mAX|mBX, + mAX|mSP, mAX|mSP, + mAX|mBP, mAX|mBP, + mAX|mSI, mAX|mSI, + mAX|mDI, mAX|mDI, + + // 98 + mAX, mAX, // CBW + mAX, mDX, // CWD + N, N|F, // CALL far ptr + N, N, // WAIT + F|mSP, mSP|mMEM, // PUSHF + mSP|mMEM, F|mSP, // POPF + mAX, F, // SAHF + F, mAX, // LAHF + + // A0 + mMEM, mAX, // MOV AL,moffs8 + mMEM, mAX, // MOV EAX,moffs32 + mAX, mMEM, // MOV moffs8,AL + mAX, mMEM, // MOV moffs32,EAX + N, N, // MOVSB + N, N, // MOVSW/D + N, N, // CMPSB + N, N, // CMPSW/D + + // A8 + mAX, F, // TEST AL,imm8 + mAX, F, // TEST AX,imm16 + N, N, // STOSB + N, N, // STOSW/D + N, N, // LODSB + N, N, // LODSW/D + N, N, // SCASB + N, N, // SCASW/D + + // B0 + 0, mAX, // MOV AL,imm8 + 0, mCX, + 0, mDX, + 0, mBX, + 0, mAX, + 0, mCX, + 0, mDX, + 0, mBX, + + // B8 + 0, mAX, // MOV AX,imm16 + 0, mCX, + 0, mDX, + 0, mBX, + 0, mSP, + 0, mBP, + 0, mSI, + 0, mDI, + + // C0 + EA, F|EA, // Shift Eb,Ib + EA, F|EA, + N, N, + N, N, + N, N, + N, N, + 0, EA|B, // MOV EA8,imm8 + 0, EA, // MOV EA,imm16 + + // C8 + N, N, // ENTER + N, N, // LEAVE + N, N, // RETF lw + N, N, // RETF + N, N, // INT 3 + N, N, // INT lb + N, N, // INTO + N, N, // IRET + + // D0 + EA, F|EA, // Shift EA,1 + EA, F|EA, + EA|mCX, F|EA, // Shift EA,CL + EA|mCX, F|EA, + mAX, F|mAX, // AAM + mAX, F|mAX, // AAD + N, N, // reserved + mAX|mBX|mMEM, mAX, // XLAT + + // D8 + N, N, + N, N, + N, N, + N, N, + N, N, + N, N, + N, N, + N, N, + + // E0 + F|mCX|N,mCX|N, // LOOPNE jb + F|mCX|N,mCX|N, // LOOPE jb + mCX|N, mCX|N, // LOOP jb + mCX|N, N, // JCXZ jb + N, N, // IN AL,lb + N, N, // IN EAX,lb + N, N, // OUT lb,AL + N, N, // OUT lb,EAX + + // E8 + N, N|F, // CALL jv + N, N, // JMP Jv + N, N, // JMP Ab + N, N, // JMP jb + N|mDX, N|mAX, // IN AL,DX + N|mDX, N|mAX, // IN AX,DX + N|mAX|mDX,N, // OUT DX,AL + N|mAX|mDX,N, // OUT DX,AX + + // F0 + N, N, // LOCK + N, N, // reserved + N, N, // REPNE + N, N, // REP,REPE + N, N, // HLT + F, F, // CMC + N, N, + N, N, + + // F8 + 0, F, // CLC + 0, F, // STC + N, N, // CLI + N, N, // STI + N, N, // CLD + N, N, // STD + EA, F|EA, // INC/DEC + N, N, +}; + +/**************************************** + * Same thing, but for groups. + */ + +static unsigned grprw[8][8][2] = +{ + // Grp 1 + EA, F|EA, // ADD + EA, F|EA, // OR + F|EA, F|EA, // ADC + F|EA, F|EA, // SBB + EA, F|EA, // AND + EA, F|EA, // SUB + EA, F|EA, // XOR + EA, F, // CMP + + // Grp 3 + EA, F, // TEST EA,imm + N, N, // reserved + EA, EA, // NOT + EA, F|EA, // NEG + mAX|EA, F|mAX|mDX, // MUL + mAX|EA, F|mAX|mDX, // IMUL + mAX|mDX|EA, F|mAX|mDX, // DIV +#if 0 + // Could generate an exception we want to catch + mAX|mDX|EA|N, F|mAX|mDX|N, // IDIV +#else + mAX|mDX|EA, F|mAX|mDX, // IDIV +#endif + + // Grp 5 + EA, F|EA, // INC Ev + EA, F|EA, // DEC Ev + N|EA, N, // CALL Ev + N|EA, N, // CALL eP + N|EA, N, // JMP Ev + N|EA, N, // JMP Ep + mSP|EA, mSP|mMEM, // PUSH Ev + N, N, // reserved + + // Grp 3, byte version + EA|B, F, // TEST EA,imm + N, N, // reserved + EA|B, EA|B, // NOT + EA|B, F|EA|B, // NEG + mAX|EA, F|mAX, // MUL + mAX|EA, F|mAX, // IMUL + mAX|EA, F|mAX, // DIV +#if 0 + // Could generate an exception we want to catch + mAX|EA|N, F|mAX|N, // IDIV +#else + mAX|EA, F|mAX, // IDIV +#endif + +}; + +/******************************************** + * For floating point opcodes 0xD8..0xDF, with Irm < 0xC0. + * [][][0] = read + * [1] = write + */ + +static unsigned grpf1[8][8][2] = +{ + // 0xD8 + EA|S, S|C, // FADD float + EA|S, S|C, // FMUL float + EA|S, C, // FCOM float + EA|S, S|C, // FCOMP float + EA|S, S|C, // FSUB float + EA|S, S|C, // FSUBR float + EA|S, S|C, // FDIV float + EA|S, S|C, // FDIVR float + + // 0xD9 + EA, S|C, // FLD float + N, N, // + S, EA|C, // FST float + S, EA|S|C, // FSTP float + N, N, // FLDENV + N, N, // FLDCW + N, N, // FSTENV + N, N, // FSTCW + + // 0xDA + EA|S, S|C, // FIADD long + EA|S, S|C, // FIMUL long + EA|S, C, // FICOM long + EA|S, S|C, // FICOMP long + EA|S, S|C, // FISUB long + EA|S, S|C, // FISUBR long + EA|S, S|C, // FIDIV long + EA|S, S|C, // FIDIVR long + + // 0xDB + EA, S|C, // FILD long + S, EA|S|C, // FISTTP int + S, EA|C, // FIST long + S, EA|S|C, // FISTP long + N, N, // + EA, S|C, // FLD real80 + N, N, // + S, EA|S|C, // FSTP real80 + + // 0xDC + EA|S, S|C, // FADD double + EA|S, S|C, // FMUL double + EA|S, C, // FCOM double + EA|S, S|C, // FCOMP double + EA|S, S|C, // FSUB double + EA|S, S|C, // FSUBR double + EA|S, S|C, // FDIV double + EA|S, S|C, // FDIVR double + + // 0xDD + EA, S|C, // FLD double + S, EA|S|C, // FISTTP long + S, EA|C, // FST double + S, EA|S|C, // FSTP double + N, N, // FRSTOR + N, N, // + N, N, // FSAVE + C, EA, // FSTSW + + // 0xDE + EA|S, S|C, // FIADD short + EA|S, S|C, // FIMUL short + EA|S, C, // FICOM short + EA|S, S|C, // FICOMP short + EA|S, S|C, // FISUB short + EA|S, S|C, // FISUBR short + EA|S, S|C, // FIDIV short + EA|S, S|C, // FIDIVR short + + // 0xDF + EA, S|C, // FILD short + S, EA|S|C, // FISTTP short + S, EA|C, // FIST short + S, EA|S|C, // FISTP short + EA, S|C, // FBLD packed BCD + EA, S|C, // FILD long long + S, EA|S|C, // FBSTP packed BCD + S, EA|S|C, // FISTP long long +}; + + +/******************************************** + * Micro-ops for floating point opcodes 0xD8..0xDF, with Irm < 0xC0. + */ + +static unsigned char uopsgrpf1[8][8] = +{ + // 0xD8 + 2, // FADD float + 2, // FMUL float + 2, // FCOM float + 2, // FCOMP float + 2, // FSUB float + 2, // FSUBR float + 2, // FDIV float + 2, // FDIVR float + + // 0xD9 + 1, // FLD float + 0, // + 2, // FST float + 2, // FSTP float + 5, // FLDENV + 3, // FLDCW + 5, // FSTENV + 5, // FSTCW + + // 0xDA + 5, // FIADD long + 5, // FIMUL long + 5, // FICOM long + 5, // FICOMP long + 5, // FISUB long + 5, // FISUBR long + 5, // FIDIV long + 5, // FIDIVR long + + // 0xDB + 4, // FILD long + 0, // + 4, // FIST long + 4, // FISTP long + 0, // + 4, // FLD real80 + 0, // + 5, // FSTP real80 + + // 0xDC + 2, // FADD double + 2, // FMUL double + 2, // FCOM double + 2, // FCOMP double + 2, // FSUB double + 2, // FSUBR double + 2, // FDIV double + 2, // FDIVR double + + // 0xDD + 1, // FLD double + 0, // + 2, // FST double + 2, // FSTP double + 5, // FRSTOR + 0, // + 5, // FSAVE + 5, // FSTSW + + // 0xDE + 5, // FIADD short + 5, // FIMUL short + 5, // FICOM short + 5, // FICOMP short + 5, // FISUB short + 5, // FISUBR short + 5, // FIDIV short + 5, // FIDIVR short + + // 0xDF + 4, // FILD short + 0, // + 4, // FIST short + 4, // FISTP short + 5, // FBLD packed BCD + 4, // FILD long long + 5, // FBSTP packed BCD + 4, // FISTP long long +}; + +/************************************************** + * Determine number of micro-ops for Pentium Pro and Pentium II processors. + * 0 means special case, + * 5 means 'complex' + */ + +static const unsigned char insuops[256] = +{ 0,0,0,0, 1,1,4,5, /* 00 */ + 0,0,0,0, 1,1,4,0, /* 08 */ + 0,0,0,0, 2,2,4,5, /* 10 */ + 0,0,0,0, 2,2,4,5, /* 18 */ + 0,0,0,0, 1,1,0,1, /* 20 */ + 0,0,0,0, 1,1,0,1, /* 28 */ + 0,0,0,0, 1,1,0,1, /* 30 */ + 0,0,0,0, 1,1,0,1, /* 38 */ + 1,1,1,1, 1,1,1,1, /* 40 */ + 1,1,1,1, 1,1,1,1, /* 48 */ + 3,3,3,3, 3,3,3,3, /* 50 */ + 2,2,2,2, 3,2,2,2, /* 58 */ + 5,5,5,5, 0,0,0,0, /* 60 */ + 3,3,0,0, 5,5,5,5, /* 68 */ + 1,1,1,1, 1,1,1,1, /* 70 */ + 1,1,1,1, 1,1,1,1, /* 78 */ + 0,0,0,0, 0,0,0,0, /* 80 */ + 0,0,0,0, 0,1,4,0, /* 88 */ + 1,3,3,3, 3,3,3,3, /* 90 */ + 1,1,5,0, 5,5,1,1, /* 98 */ + 1,1,2,2, 5,5,5,5, /* A0 */ + 1,1,3,3, 2,2,3,3, /* A8 */ + 1,1,1,1, 1,1,1,1, /* B0 */ + 1,1,1,1, 1,1,1,1, /* B8 */ + 0,0,5,4, 0,0,0,0, /* C0 */ + 5,3,5,5, 5,3,5,5, /* C8 */ + 0,0,0,0, 4,3,0,2, /* D0 */ + 0,0,0,0, 0,0,0,0, /* D8 */ + 4,4,4,2, 5,5,5,5, /* E0 */ + 4,1,5,1, 5,5,5,5, /* E8 */ + 0,0,5,5, 5,1,0,0, /* F0 */ + 1,1,5,5, 4,4,0,0, /* F8 */ +}; + +static unsigned char uopsx[8] = { 1,1,2,5,1,1,1,5 }; + +/************************************************ + * Determine number of micro-ops for Pentium Pro and Pentium II processors. + * 5 means 'complex'. + * Doesn't currently handle: + * floating point + * MMX + * 0F opcodes + * prefix bytes + */ + +STATIC int uops(code *c) +{ int n; + int op; + int op2; + + op = c->Iop & 0xFF; + if ((c->Iop & 0xFF00) == 0x0F00) + op = 0x0F; + n = insuops[op]; + if (!n) // if special case + { unsigned char irm,mod,reg,rm; + + irm = c->Irm; + mod = (irm >> 6) & 3; + reg = (irm >> 3) & 7; + rm = irm & 7; + + switch (op) + { + case 0x10: + case 0x11: // ADC rm,r + case 0x18: + case 0x19: // SBB rm,r + n = (mod == 3) ? 2 : 4; + break; + + case 0x12: + case 0x13: // ADC r,rm + case 0x1A: + case 0x1B: // SBB r,rm + n = (mod == 3) ? 2 : 3; + break; + + case 0x00: + case 0x01: // ADD rm,r + case 0x08: + case 0x09: // OR rm,r + case 0x20: + case 0x21: // AND rm,r + case 0x28: + case 0x29: // SUB rm,r + case 0x30: + case 0x31: // XOR rm,r + n = (mod == 3) ? 1 : 4; + break; + + case 0x02: + case 0x03: // ADD r,rm + case 0x0A: + case 0x0B: // OR r,rm + case 0x22: + case 0x23: // AND r,rm + case 0x2A: + case 0x2B: // SUB r,rm + case 0x32: + case 0x33: // XOR r,rm + case 0x38: + case 0x39: // CMP rm,r + case 0x3A: + case 0x3B: // CMP r,rm + case 0x69: // IMUL rm,r,imm + case 0x6B: // IMUL rm,r,imm8 + case 0x84: + case 0x85: // TEST rm,r + n = (mod == 3) ? 1 : 2; + break; + + case 0x80: + case 0x81: + case 0x82: + case 0x83: + if (reg == 2 || reg == 3) // ADC/SBB rm,imm + n = (mod == 3) ? 2 : 4; + else if (reg == 7) // CMP rm,imm + n = (mod == 3) ? 1 : 2; + else + n = (mod == 3) ? 1 : 4; + break; + + case 0x86: + case 0x87: // XCHG rm,r + n = (mod == 3) ? 3 : 5; + break; + + case 0x88: + case 0x89: // MOV rm,r + n = (mod == 3) ? 1 : 2; + break; + + case 0x8A: + case 0x8B: // MOV r,rm + n = 1; + break; + + case 0x8C: // MOV Sreg,rm + n = (mod == 3) ? 1 : 3; + break; + + case 0x8F: + if (reg == 0) // POP m + n = 5; + break; + + case 0xC6: + case 0xC7: + if (reg == 0) // MOV rm,imm + n = (mod == 3) ? 1 : 2; + break; + + case 0xD0: + case 0xD1: + if (reg == 2 || reg == 3) // RCL/RCR rm,1 + n = (mod == 3) ? 2 : 4; + else + n = (mod == 3) ? 1 : 4; + break; + + case 0xC0: + case 0xC1: // RCL/RCR rm,imm8 + case 0xD2: + case 0xD3: + if (reg == 2 || reg == 3) // RCL/RCR rm,CL + n = 5; + else + n = (mod == 3) ? 1 : 4; + break; + + case 0xD8: + case 0xD9: + case 0xDA: + case 0xDB: + case 0xDC: + case 0xDD: + case 0xDE: + case 0xDF: + // Floating point opcodes + if (irm < 0xC0) + { n = uopsgrpf1[op - 0xD8][reg]; + break; + } + n = uopsx[op - 0xD8]; + switch (op) + { + case 0xD9: + switch (irm) + { + case 0xE0: // FCHS + n = 3; + break; + case 0xE8: + case 0xE9: + case 0xEA: + case 0xEB: + case 0xEC: + case 0xED: + n = 2; + break; + case 0xF0: + case 0xF1: + case 0xF2: + case 0xF3: + case 0xF4: + case 0xF5: + case 0xF8: + case 0xF9: + case 0xFB: + case 0xFC: + case 0xFD: + case 0xFE: + case 0xFF: + n = 5; + break; + } + break; + case 0xDE: + if (irm == 0xD9) // FCOMPP + n = 2; + break; + } + break; + + case 0xF6: + if (reg == 6 || reg == 7) // DIV AL,rm8 + n = (mod == 3) ? 3 : 4; + else if (reg == 4 || reg == 5 || reg == 0) // MUL/IMUL/TEST rm8 + n = (mod == 3) ? 1 : 2; + else if (reg == 2 || reg == 3) // NOT/NEG rm + n = (mod == 3) ? 1 : 4; + break; + + case 0xF7: + if (reg == 6 || reg == 7) // DIV EAX,rm + n = 4; + else if (reg == 4 || reg == 5) // MUL/IMUL rm + n = (mod == 3) ? 3 : 4; + else if (reg == 2 || reg == 3) // NOT/NEG rm + n = (mod == 3) ? 1 : 4; + break; + + case 0xFF: + if (reg == 2 || reg == 3 || // CALL rm, CALL m,rm + reg == 5) // JMP seg:offset + n = 5; + else if (reg == 4) + n = (mod == 3) ? 1 : 2; + else if (reg == 0 || reg == 1) // INC/DEC rm + n = (mod == 3) ? 1 : 4; + else if (reg == 6) // PUSH rm + n = (mod == 3) ? 3 : 4; + break; + + case 0x0F: + op2 = c->Iop & 0xFF; + if ((op2 & 0xF0) == 0x80) // Jcc + { n = 1; + break; + } + if ((op2 & 0xF0) == 0x90) // SETcc + { n = (mod == 3) ? 1 : 3; + break; + } + if (op2 == 0xB6 || op2 == 0xB7 || // MOVZX + op2 == 0xBE || op2 == 0xBF) // MOVSX + { n = 1; + break; + } + if (op2 == 0xAF) // IMUL r,m + { n = (mod == 3) ? 1 : 2; + break; + } + break; + } + } + if (n == 0) + n = 5; // copout for now + return n; +} + +/****************************************** + * Determine pairing classification. + * Don't deal with floating point, just assume they are all NP (Not Pairable). + * Returns: + * NP,UV,PU,PV optionally OR'd with PE + */ + +STATIC int pair_class(code *c) +{ unsigned char op; + unsigned char irm,mod,reg,rm; + unsigned a32; + int pc; + + // Of course, with Intel this is *never* simple, and Intel's + // documentation is vague about the specifics. + + op = c->Iop & 0xFF; + if ((c->Iop & 0xFF00) == 0x0F00) + op = 0x0F; + pc = pentcycl[op]; + a32 = I32; + if (c->Iflags & CFaddrsize) + a32 ^= 1; + irm = c->Irm; + mod = (irm >> 6) & 3; + reg = (irm >> 3) & 7; + rm = irm & 7; + switch (op) + { + case 0x0F: // 2 byte opcode + if ((c->Iop & 0xF0) == 0x80) // if Jcc + pc = PV | PF; + break; + + case 0x80: + case 0x81: + case 0x83: + if (reg == 2 || // ADC EA,immed + reg == 3) // SBB EA,immed + { pc = PU; + goto L2; + } + goto L1; // AND/OR/XOR/ADD/SUB/CMP EA,immed + + case 0x84: + case 0x85: // TEST EA,reg + if (mod == 3) // TEST reg,reg + pc = UV; + break; + + case 0xC0: + case 0xC1: + if (reg >= 4) + pc = PU; + break; + + case 0xC6: + case 0xC7: + if (reg == 0) // MOV EA,immed + { + L1: + pc = UV; + L2: + // if EA contains a displacement then + // can't execute in V, or pair in U + switch (mod) + { case 0: + if (a32) + { if (rm == 5 || + (rm == 4 && (c->Isib & 7) == 5) + ) + pc = NP; + } + else if (rm == 6) + pc = NP; + break; + case 1: + case 2: + pc = NP; + break; + } + } + break; + + case 0xD9: + if (irm < 0xC0) + { + if (reg == 0) + pc = FX; + } + else if (irm < 0xC8) + pc = FX; + else if (irm < 0xD0) + pc = PV; + else + { + switch (irm) + { + case 0xE0: + case 0xE1: + case 0xE4: + pc = FX; + break; + } + } + break; + + case 0xDB: + if (irm < 0xC0 && (reg == 0 || reg == 5)) + pc = FX; + break; + + case 0xDD: + if (irm < 0xC0) + { + if (reg == 0) + pc = FX; + } + else if (irm >= 0xE0 && irm < 0xF0) + pc = FX; + break; + + case 0xDF: + if (irm < 0xC0 && (reg == 0 || reg == 5)) + pc = FX; + break; + + case 0xFE: + if (reg == 0 || reg == 1) // INC/DEC EA + pc = UV; + break; + case 0xFF: + if (reg == 0 || reg == 1) // INC/DEC EA + pc = UV; + else if (reg == 2 || reg == 4) // CALL/JMP near ptr EA + pc = PE|PV; + else if (reg == 6 && mod == 3) // PUSH reg + pc = PE | UV; + break; + } + if (c->Iflags & CFPREFIX && pc == UV) // if prefix byte + pc = PU; + return pc; +} + +/****************************************** + * For an instruction, determine what is read + * and what is written, and what is used for addressing. + * Determine operand size if EA (larger is ok). + */ + +STATIC void getinfo(Cinfo *ci,code *c) +{ + memset(ci,0,sizeof(Cinfo)); + if (!c) + return; + ci->c = c; + + if (PRO) + { + ci->uops = uops(c); + ci->isz = calccodsize(c); + } + else + ci->pair = pair_class(c); + + unsigned char op; + unsigned char op2; + unsigned char irm,mod,reg,rm; + unsigned a32; + int pc; + unsigned r,w; + int sz = I32 ? 4 : 2; + + ci->r = 0; + ci->w = 0; + ci->a = 0; + op = c->Iop & 0xFF; + if ((c->Iop & 0xFF00) == 0x0F00) + op = 0x0F; + //printf("\tgetinfo %x, op %x \n",c,op); + pc = pentcycl[op]; + a32 = I32; + if (c->Iflags & CFaddrsize) + a32 ^= 1; + if (c->Iflags & CFopsize) + sz ^= 2 | 4; + irm = c->Irm; + mod = (irm >> 6) & 3; + reg = (irm >> 3) & 7; + rm = irm & 7; + + r = oprw[op][0]; + w = oprw[op][1]; + + switch (op) + { + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x55: + case 0x56: + case 0x57: // PUSH reg + ci->flags |= CIFLpush; + case 0x54: // PUSH ESP + case 0x6A: // PUSH imm8 + case 0x68: // PUSH imm + case 0x0E: + case 0x16: + case 0x1E: + case 0x06: + case 0x9C: + Lpush: + ci->spadjust = -sz; + ci->a |= mSP; + break; + + case 0x58: + case 0x59: + case 0x5A: + case 0x5B: + case 0x5C: + case 0x5D: + case 0x5E: + case 0x5F: // POP reg + case 0x1F: + case 0x07: + case 0x17: + case 0x9D: // POPF + Lpop: + ci->spadjust = sz; + ci->a |= mSP; + break; + + case 0x80: + if (reg == 7) // CMP + c->Iflags |= CFpsw; + r = B | grprw[0][reg][0]; // Grp 1 (byte) + w = B | grprw[0][reg][1]; + break; + + case 0x81: + case 0x83: + if (reg == 7) // CMP + c->Iflags |= CFpsw; + else if (irm == modregrm(3,0,SP)) // ADD ESP,imm + { + assert(c->IFL2 == FLconst); + ci->spadjust = (op == 0x81) ? c->IEV2.Vint : (signed char)c->IEV2.Vint; + } + else if (irm == modregrm(3,5,SP)) // SUB ESP,imm + { + assert(c->IFL2 == FLconst); + ci->spadjust = (op == 0x81) ? -c->IEV2.Vint : -(signed char)c->IEV2.Vint; + } + r = grprw[0][reg][0]; // Grp 1 + w = grprw[0][reg][1]; + break; + + case 0x8F: + if (reg == 0) // POP rm + goto Lpop; + break; + + case 0xA0: + case 0xA1: + case 0xA2: + case 0xA3: + // Fake having an EA to simplify code in conflict() + ci->flags |= CIFLea; + ci->reg = 0; + ci->sibmodrm = a32 ? modregrm(0,0,5) : modregrm(0,0,6); + c->IFL1 = c->IFL2; + c->IEV1 = c->IEV2; + break; + + case 0xC2: + case 0xC3: + case 0xCA: + case 0xCB: // RET + ci->a |= mSP; + break; + + case 0xE8: + if (c->Iflags & CFclassinit) // call to __j_classinit + { r = 0; + w = F; +#if CLASSINIT2 + ci->pair = UV; // it is patched to CMP EAX,0 +#else + ci->pair = NP; +#endif + } + break; + + case 0xF6: + r = grprw[3][reg][0]; // Grp 3, byte version + w = grprw[3][reg][1]; + break; + + case 0xF7: + r = grprw[1][reg][0]; // Grp 3 + w = grprw[1][reg][1]; + break; + + case 0x0F: + op2 = c->Iop & 0xFF; + if ((op2 & 0xF0) == 0x80) // if Jxx instructions + { + ci->r = F | N; + ci->w = N; + goto Lret; + } + ci->r = N; + ci->w = N; // copout for now + goto Lret; + + case 0xD7: // XLAT + ci->a = mAX | mBX; + break; + + case 0xFF: + r = grprw[2][reg][0]; // Grp 5 + w = grprw[2][reg][1]; + if (reg == 6) // PUSH rm + goto Lpush; + break; + + case 0x38: + case 0x39: + case 0x3A: + case 0x3B: + case 0x3C: // CMP AL,imm8 + case 0x3D: // CMP EAX,imm32 + // For CMP opcodes, always test for flags + c->Iflags |= CFpsw; + break; + + case ESCAPE: + if (c->Iop == (ESCAPE | ESCadjfpu)) + ci->fpuadjust = c->IEV1.Vint; + break; + + case 0xD0: + case 0xD1: + case 0xD2: + case 0xD3: + case 0xC0: + case 0xC1: + if (reg == 2 || reg == 3) // if RCL or RCR + c->Iflags |= CFpsw; // always test for flags + break; + + case 0xD8: + case 0xD9: + case 0xDA: + case 0xDB: + case 0xDC: + case 0xDD: + case 0xDE: + case 0xDF: + if (irm < 0xC0) + { r = grpf1[op - 0xD8][reg][0]; + w = grpf1[op - 0xD8][reg][1]; + switch (op) + { + case 0xD8: + if (reg == 3) // if FCOMP + ci->fpuadjust = -1; + else + ci->fp_op = FPfop; + break; + + case 0xD9: + if (reg == 0) // if FLD float + { ci->fpuadjust = 1; + ci->fp_op = FPfld; + } + else if (reg == 3) // if FSTP float + { ci->fpuadjust = -1; + ci->fp_op = FPfstp; + } + else if (reg == 5 || reg == 7) + sz = 2; + else if (reg == 4 || reg == 6) + sz = 28; + break; + case 0xDA: + if (reg == 3) // if FICOMP + ci->fpuadjust = -1; + break; + case 0xDB: + if (reg == 0 || reg == 5) + { ci->fpuadjust = 1; + ci->fp_op = FPfld; // FILD / FLD long double + } + if (reg == 3 || reg == 7) + ci->fpuadjust = -1; + if (reg == 7) + ci->fp_op = FPfstp; // FSTP long double + if (reg == 5 || reg == 7) + sz = 10; + break; + case 0xDC: + sz = 8; + if (reg == 3) // if FCOMP + ci->fpuadjust = -1; + else + ci->fp_op = FPfop; + break; + case 0xDD: + if (reg == 0) // if FLD double + { ci->fpuadjust = 1; + ci->fp_op = FPfld; + } + if (reg == 3) // if FSTP double + { ci->fpuadjust = -1; + ci->fp_op = FPfstp; + } + if (reg == 7) + sz = 2; + else if (reg == 4 || reg == 6) + sz = 108; + else + sz = 8; + break; + case 0xDE: + sz = 2; + if (reg == 3) // if FICOMP + ci->fpuadjust = -1; + break; + case 0xDF: + sz = 2; + if (reg == 4 || reg == 6) + sz = 10; + else if (reg == 5 || reg == 7) + sz = 8; + if (reg == 0 || reg == 4 || reg == 5) + ci->fpuadjust = 1; + else if (reg == 3 || reg == 6 || reg == 7) + ci->fpuadjust = -1; + break; + } + break; + } + else if (op == 0xDE) + { ci->fpuadjust = -1; // pop versions of Fop's + if (irm == 0xD9) + ci->fpuadjust = -2; // FCOMPP + } + + // Most floating point opcodes aren't staged, but are + // sent right through, in order to make use of the large + // latencies with floating point instructions. + if (ci->fp_op == FPfld || + (op == 0xD9 && (irm & 0xF8) == 0xC0)) + ; // FLD ST(i) + else + ci->flags |= CIFLnostage; + + switch (op) + { + case 0xD8: + r = S; + w = C; + if ((irm & ~7) == 0xD0) + w |= S; + break; + case 0xD9: + // FCHS or FABS or FSQRT + if (irm == 0xE0 || irm == 0xE1 || irm == 0xFA) + ci->fp_op = FPfop; + r = S; + w = S|C; + break; + case 0xDA: + if (irm == 0xE9) // FUCOMPP + { r = S; + w = S|C; + break; + } + break; + case 0xDB: + if (irm == 0xE2) // FCLEX + { r = 0; + w = C; + break; + } + if (irm == 0xE3) // FINIT + { r = 0; + w = S|C; + break; + } + break; + case 0xDC: + case 0xDE: + if ((irm & 0xF0) != 0xD0) + { r = S; + w = S|C; + break; + } + break; + case 0xDD: + // Not entirely correct, but conservative + r = S; + w = S|C; + break; + case 0xDF: + if (irm == 0xE0) // FSTSW AX + { r = C; + w = mAX; + break; + } + break; + } + break; +#if DEBUG + default: + //printf("\t\tNo special case\n"); + break; +#endif + } + + if ((r | w) & B) // if byte operation + sz = 1; // operand size is 1 + + ci->r = r & ~(R | EA); + ci->w = w & ~(R | EA); + if (r & R) + ci->r |= mask[(r & B) ? (reg & 3) : reg]; + if (w & R) + ci->w |= mask[(w & B) ? (reg & 3) : reg]; + + // OR in bits for EA addressing mode + if ((r | w) & EA) + { unsigned char sib; + + sib = 0; + switch (mod) + { + case 0: + if (a32) + { + if (rm == 4) + { sib = c->Isib; + if ((sib & modregrm(0,7,0)) != modregrm(0,4,0)) + ci->a |= mask[(sib >> 3) & 7]; // index register + if ((sib & 7) != 5) + ci->a |= mask[sib & 7]; // base register + } + else if (rm != 5) + ci->a |= mask[rm]; + } + else + { static unsigned char ea16[8] = {mBX|mSI,mBX|mDI,mBP|mSI,mBP|mDI,mSI,mDI,0,mBX}; + ci->a |= ea16[rm]; + } + goto Lmem; + + case 1: + case 2: + if (a32) + { + if (rm == 4) + { sib = c->Isib; + if ((sib & modregrm(0,7,0)) != modregrm(0,4,0)) + ci->a |= mask[(sib >> 3) & 7]; // index register + ci->a |= mask[sib & 7]; // base register + } + else + ci->a |= mask[rm]; + } + else + { static unsigned char ea16[8] = {mBX|mSI,mBX|mDI,mBP|mSI,mBP|mDI,mSI,mDI,mBP,mBX}; + ci->a |= ea16[rm]; + } + + Lmem: + if (r & EA) + ci->r |= mMEM; + if (w & EA) + ci->w |= mMEM; + ci->flags |= CIFLea; + break; + + case 3: + if (r & EA) + ci->r |= mask[(r & B) ? (rm & 3) : rm]; + if (w & EA) + ci->w |= mask[(w & B) ? (rm & 3) : rm]; + break; + } + // Adjust sibmodrm so that addressing modes can be compared simply + irm &= modregrm(3,0,7); + if (a32) + { + if (irm != modregrm(0,0,5)) + { + switch (mod) + { case 0: + if ((sib & 7) != 5) // if not disp32[index] + { c->IFL1 = FLconst; + c->IEVpointer1 = 0; + irm |= 0x80; + } + break; + case 1: + c->IEVpointer1 = (signed char) c->IEVpointer1; + irm = modregrm(2,0,rm); + break; + } + } + } + else + { + if (irm != modregrm(0,0,6)) + { + switch (mod) + { case 0: + c->IFL1 = FLconst; + c->IEVpointer1 = 0; + irm |= 0x80; + break; + case 1: + c->IEVpointer1 = (signed char) c->IEVpointer1; + irm = modregrm(2,0,rm); + break; + } + } + } + + ci->r |= ci->a; + ci->reg = reg; + ci->sibmodrm = (sib << 8) | irm; + } +Lret: + if (ci->w & mSP) // if stack pointer is modified + ci->w |= mMEM; // then we are implicitly writing to memory + if (op == 0x8D) // if LEA + ci->r &= ~mMEM; // memory is not actually read + ci->sz = sz; +#if DEBUG + //printf("\t\t"); ci->print(); +#endif +} + +/****************************************** + * Determine if two instructions can pair. + * Assume that in general, cu can pair in the U pipe and cv in the V. + * Look for things like register contentions. + * Input: + * cu instruction for U pipe + * cv instruction for V pipe + * Returns: + * !=0 if they can pair + */ + +STATIC int pair_test(Cinfo *cu,Cinfo *cv) +{ unsigned pcu; + unsigned pcv; + unsigned r1,w1; + unsigned r2,w2; + unsigned x; + + pcu = cu->pair; + if (!(pcu & PU)) + { + // See if pairs with FXCH and cv is FXCH + if (pcu & FX && cv->c->Iop == 0xD9 && (cv->c->Irm & ~7) == 0xC8) + goto Lpair; + goto Lnopair; + } + pcv = cv->pair; + if (!(pcv & PV)) + goto Lnopair; + + r1 = cu->r; + w1 = cu->w; + r2 = cv->r; + w2 = cv->w; + + x = w1 & (r2 | w2) & ~(F|mMEM); // register contention + if (x && // if register contention + !(x == mSP && pcu & pcv & PE) // and not exception + ) + goto Lnopair; + + // Look for flags contention + if (w1 & r2 & F && !(pcv & PF)) + goto Lnopair; + +Lpair: + return 1; + +Lnopair: + return 0; +} + +/****************************************** + * Determine if two instructions have an AGI or register contention. + * Returns: + * !=0 if they have an AGI + */ + +STATIC int pair_agi(Cinfo *c1,Cinfo *c2) +{ unsigned x; + + x = c1->w & c2->a; + return x && !(x == mSP && c1->pair & c2->pair & PE); +} + +/******************************************** + * Determine if three instructions can decode simultaneously + * in Pentium Pro and Pentium II. + * Input: + * c0,c1,c2 candidates for decoders 0,1,2 + * c2 can be NULL + * Returns: + * !=0 if they can decode simultaneously + */ + +STATIC int triple_test(Cinfo *c0,Cinfo *c1,Cinfo *c2) +{ int c2isz; + + assert(c0); + if (!c1) + goto Lnopair; + c2isz = c2 ? c2->isz : 0; + if (c0->isz > 7 || c1->isz > 7 || c2isz > 7 || + c0->isz + c1->isz + c2isz > 16) + goto Lnopair; + + // 4-1-1 decode + if (c1->uops > 1 || + (c2 && c2->uops > 1)) + goto Lnopair; + +Lpair: + return 1; + +Lnopair: + return 0; +} + +/******************************************** + * Get next instruction worth looking at for scheduling. + * Returns: + * NULL no more instructions + */ + +STATIC code * cnext(code *c) +{ + while (1) + { + c = code_next(c); + if (!c) + break; + if (c->Iflags & (CFtarg | CFtarg2)) + break; + if (!(c->Iop == NOP || + c->Iop == (ESCAPE | ESClinnum))) + break; + } + return c; +} + +/****************************************** + * Instruction scheduler. + * Input: + * c list of instructions to schedule + * scratch scratch registers we can use + * Returns: + * revised list of scheduled instructions + */ + +/////////////////////////////////// +// Determine if c1 and c2 are swappable. +// c1 comes before c2. +// If they do not conflict +// return 0 +// If they do conflict +// return 0x100 + delay_clocks +// Input: +// fpsched if 1, then adjust fxch_pre and fxch_post to swap, +// then return 0 +// if 2, then adjust ci1 as well as ci2 + +STATIC int conflict(Cinfo *ci1,Cinfo *ci2,int fpsched) +{ + code *c1; + code *c2; + unsigned r1,w1,a1; + unsigned r2,w2,a2; + int sz1,sz2; + int i = 0; + int delay_clocks; + + c1 = ci1->c; + c2 = ci2->c; + + //printf("conflict %x %x\n",c1,c2); + + r1 = ci1->r; + w1 = ci1->w; + a1 = ci1->a; + sz1 = ci1->sz; + + r2 = ci2->r; + w2 = ci2->w; + a2 = ci2->a; + sz2 = ci2->sz; + + //printf("r1 %lx w1 %lx a1 %lx sz1 %x\n",r1,w1,a1,sz1); + //printf("r2 %lx w2 %lx a2 %lx sz2 %x\n",r2,w2,a2,sz2); + + if ((c1->Iflags | c2->Iflags) & CFvolatile) + goto Lconflict; + + // Determine if we should handle FPU register conflicts separately + //if (fpsched) printf("fp_op %d,%d:\n",ci1->fp_op,ci2->fp_op); + if (fpsched && ci1->fp_op && ci2->fp_op) + { + w1 &= ~(S|C); + r1 &= ~(S|C); + w2 &= ~(S|C); + r2 &= ~(S|C); + } + else + fpsched = 0; + + if ((r1 | r2) & N) + { + goto Lconflict; + } + +#if 0 + if (c1->Iop == 0xFF && c2->Iop == 0x8B) + { c1->print(); c2->print(); i = 1; + printf("r1=%lx, w1=%lx, a1=%lx, sz1=%d, r2=%lx, w2=%lx, a2=%lx, sz2=%d\n",r1,w1,a1,sz1,r2,w2,a2,sz2); + } +#endif +L1: + if (w1 & r2 || (r1 | w1) & w2) + { unsigned char ifl1,ifl2; + +if (i) printf("test\n"); + +#if 0 +if (c1->IFL1 != c2->IFL1) printf("t1\n"); +if ((c1->Irm & modregrm(3,0,7)) != (c2->Irm & modregrm(3,0,7))) printf("t2\n"); +if ((issib(c1->Irm) && c1->Isib != c2->Isib)) printf("t3\n"); +if (c1->IEVpointer1 + sz1 <= c2->IEVpointer1) printf("t4\n"); +if (c2->IEVpointer1 + sz2 <= c1->IEVpointer1) printf("t5\n"); +#endif + +#if 1 // make sure CFpsw is reliably set + if (w1 & w2 & F && // if both instructions write to flags + w1 != F && + w2 != F && + !((r1 | r2) & F) && // but neither instruction reads them + !((c1->Iflags | c2->Iflags) & CFpsw)) // and we don't care about flags + { + w1 &= ~F; + w2 &= ~F; // remove conflict + goto L1; // and try again + } +#endif + // If other than the memory reference is a conflict + if (w1 & r2 & ~mMEM || (r1 | w1) & w2 & ~mMEM) + { if (i) printf("\t1\n"); + if (i) printf("r1=%x, w1=%x, a1=%x, sz1=%d, r2=%x, w2=%x, a2=%x, sz2=%d\n",r1,w1,a1,sz1,r2,w2,a2,sz2); + goto Lconflict; + } + + // If referring to distinct types, then no dependency + if (c1->Irex && c2->Irex && c1->Irex != c2->Irex) + goto Lswap; + + ifl1 = c1->IFL1; + ifl2 = c2->IFL1; + + // Special case: Allow indexed references using registers other than + // ESP and EBP to be swapped with PUSH instructions + if (((c1->Iop & ~7) == 0x50 || // PUSH reg + c1->Iop == 0x6A || // PUSH imm8 + c1->Iop == 0x68 || // PUSH imm16/imm32 + (c1->Iop == 0xFF && ci1->reg == 6) // PUSH EA + ) && + ci2->flags & CIFLea && !(a2 & mSP) && + !(a2 & mBP && (long)c2->IEVpointer1 < 0) + ) + { + if (c1->Iop == 0xFF) + { + if (!(w2 & mMEM)) + goto Lswap; + } + else + goto Lswap; + } + + // Special case: Allow indexed references using registers other than + // ESP and EBP to be swapped with PUSH instructions + if (((c2->Iop & ~7) == 0x50 || // PUSH reg + c2->Iop == 0x6A || // PUSH imm8 + c2->Iop == 0x68 || // PUSH imm16/imm32 + (c2->Iop == 0xFF && ci2->reg == 6) // PUSH EA + ) && + ci1->flags & CIFLea && !(a1 & mSP) && + !(a2 & mBP && (long)c2->IEVpointer1 < 0) + ) + { + if (c2->Iop == 0xFF) + { + if (!(w1 & mMEM)) + goto Lswap; + } + else + goto Lswap; + } + + // If not both an EA addressing mode, conflict + if (!(ci1->flags & ci2->flags & CIFLea)) + { if (i) printf("\t2\n"); + goto Lconflict; + } + + if (ci1->sibmodrm == ci2->sibmodrm) + { if (ifl1 != ifl2) + goto Lswap; + switch (ifl1) + { + case FLconst: + if (c1->IEV1.Vint != c2->IEV1.Vint && + (c1->IEV1.Vint + sz1 <= c2->IEV1.Vint || + c2->IEV1.Vint + sz2 <= c1->IEV1.Vint)) + goto Lswap; + break; + case FLdatseg: + if (c1->IEVseg1 != c2->IEVseg1 || + c1->IEV1.Vint + sz1 <= c2->IEV1.Vint || + c2->IEV1.Vint + sz2 <= c1->IEV1.Vint) + goto Lswap; + break; + } + } + + if ((c1->Iflags | c2->Iflags) & CFunambig && + (ifl1 != ifl2 || + ci1->sibmodrm != ci2->sibmodrm || + (c1->IEV1.Vint != c2->IEV1.Vint && + (c1->IEV1.Vint + sz1 <= c2->IEV1.Vint || + c2->IEV1.Vint + sz2 <= c1->IEV1.Vint) + ) + ) + ) + { + // Assume that [EBP] and [ESP] can point to the same location + if (((a1 | a2) & (mBP | mSP)) == (mBP | mSP)) + goto Lconflict; + goto Lswap; + } + + if (i) printf("\t3\n"); + goto Lconflict; + } + +Lswap: + if (fpsched) + { unsigned char a1,b1; + unsigned char a2,b2; + + //printf("\tfpsched %d,%d:\n",ci1->fp_op,ci2->fp_op); + a1 = ci1->fxch_pre; + b1 = ci1->fxch_post; + a2 = ci2->fxch_pre; + b2 = ci2->fxch_post; + + #define X(a,b) ((a << 8) | b) + switch (X(ci1->fp_op,ci2->fp_op)) + { + case X(FPfstp,FPfld): + if (a1 || b1) + goto Lconflict; + if (a2) + goto Lconflict; + if (b2 == 0) + ci2->fxch_post++; + else if (b2 == 1) + { + ci2->fxch_pre++; + ci2->fxch_post++; + } + else + { + goto Lconflict; + } + break; + + case X(FPfstp,FPfop): + if (a1 || b1) + goto Lconflict; + ci2->fxch_pre++; + ci2->fxch_post++; + break; + + case X(FPfop,FPfop): + if (a1 == 0 && b1 == 1 && a2 == 0 && b2 == 0) + { ci2->fxch_pre = 1; + ci2->fxch_post = 1; + break; + } + if (a1 == 0 && b1 == 0 && a2 == 1 && b2 == 1) + break; + goto Lconflict; + + case X(FPfop,FPfld): + if (a1 || b1) + goto Lconflict; + if (a2) + goto Lconflict; + if (b2) + break; + else if (fpsched == 2) + ci1->fxch_post = 1; + ci2->fxch_post = 1; + break; + + default: + goto Lconflict; + } + #undef X + //printf("\tpre = %d, post = %d\n",ci2->fxch_pre,ci2->fxch_post); + } + + //printf("w1 = x%x, w2 = x%x\n",w1,w2); + if (i) printf("no conflict\n\n"); + return 0; + +Lconflict: + //printf("r1=%x, w1=%x, r2=%x, w2=%x\n",r1,w1,r2,w2); + delay_clocks = 0; + + // Determine if AGI + if (!PRO && pair_agi(ci1,ci2)) + delay_clocks = 1; + + // Special delays for floating point + if (fpsched) + { if (ci1->fp_op == FPfld && ci2->fp_op == FPfstp) + delay_clocks = 1; + else if (ci1->fp_op == FPfop && ci2->fp_op == FPfstp) + delay_clocks = 3; + else if (ci1->fp_op == FPfop && ci2->fp_op == FPfop) + delay_clocks = 2; + } + else if (PRO) + { + // Look for partial register write stalls + if (w1 & r2 & ALLREGS && sz1 < sz2) + delay_clocks = 7; + } + else if ((w1 | r1) & (w2 | r2) & (C | S)) + { int reg; + int op; + + op = c1->Iop; + reg = c1->Irm & modregrm(0,7,0); + if (ci1->fp_op == FPfld || + (op == 0xD9 && (c1->Irm & 0xF8) == 0xC0) + ) + ; // FLD + else if (op == 0xD9 && (c1->Irm & 0xF8) == 0xC8) + ; // FXCH + else if (c2->Iop == 0xD9 && (c2->Irm & 0xF8) == 0xC8) + ; // FXCH + else + delay_clocks = 3; + } + + if (i) printf("conflict %d\n\n",delay_clocks); + return 0x100 + delay_clocks; +} + +struct Schedule +{ + #define TBLMAX (2*3*20) // must be divisible by both 2 and 3 + // (U,V pipe in Pentium, 3 decode units + // in Pentium Pro) + + Cinfo *tbl[TBLMAX]; // even numbers are U pipe, odd numbers are V + int tblmax; // max number of slots used + + Cinfo cinfo[TBLMAX]; + int cinfomax; + + list_t stagelist; // list of instructions in staging area + + int fpustackused; // number of slots in FPU stack that are used + + void initialize(int fpustackinit); // initialize scheduler + int stage(code *c); // stage instruction + int insert(Cinfo *ci); // insert c into schedule + code **assemble(code **pc); // reassemble scheduled instructions +}; + +/****************************** + */ + +void Schedule::initialize(int fpustackinit) +{ + //printf("Schedule::initialize(fpustackinit = %d)\n", fpustackinit); + memset(this,0,sizeof(Schedule)); + fpustackused = fpustackinit; +} + +/****************************** + */ + +code **Schedule::assemble(code **pc) +{ int i; + list_t l; + code *c; + +#ifdef DEBUG + if (debugs) printf("assemble:\n"); +#endif + assert(!*pc); + + // Try to insert the rest of the staged instructions + for (l = stagelist; l; l = list_next(l)) + { Cinfo *ci; + + ci = (Cinfo *)list_ptr(l); + if (!insert(ci)) + break; + } + + // Get the instructions out of the schedule table + assert((unsigned)tblmax <= TBLMAX); + for (i = 0; i < tblmax; i++) + { Cinfo *ci; + + ci = tbl[i]; +#ifdef DEBUG + if (debugs) + { + if (PRO) + { static char tbl[3][4] = { "0 "," 1 "," 2" }; + + if (ci) + printf("%s %d ",tbl[i - ((i / 3) * 3)],ci->uops); + else + printf("%s ",tbl[i - ((i / 3) * 3)]); + } + else + { + printf((i & 1) ? " V " : "U "); + } + if (ci) + ci->c->print(); + else + printf("\n"); + } +#endif + if (!ci) + continue; + fpustackused += ci->fpuadjust; + //printf("stage()1: fpustackused = %d\n", fpustackused); + c = ci->c; + if (i == 0) + c->Iflags |= CFtarg; // by definition, first is always a jump target + else + c->Iflags &= ~CFtarg; // the rest are not + + // Put in any FXCH prefix + if (ci->fxch_pre) + { code *cf; + assert(i); + cf = gen2(NULL,0xD9,0xC8 + ci->fxch_pre); + *pc = cf; + pc = &code_next(cf); + } + + *pc = c; + do + { + assert(*pc != code_next(*pc)); + pc = &code_next(*pc); + } while (*pc); + + // Put in any FXCH postfix + if (ci->fxch_post) + { int j; + + for (j = i + 1; j < tblmax; j++) + { if (tbl[j]) + { if (tbl[j]->fxch_pre == ci->fxch_post) + { + tbl[j]->fxch_pre = 0; // they cancel each other out + goto L1; + } + break; + } + } + { code *cf; + cf = gen2(NULL,0xD9,0xC8 + ci->fxch_post); + *pc = cf; + pc = &code_next(cf); + } + } + L1: ; + } + + // Just append any instructions left in the staging area + for (; l; l = list_next(l)) + { Cinfo *ci = (Cinfo *)list_ptr(l); + code *c = ci->c; + +#ifdef DEBUG + if (debugs) { printf("appending: "); c->print(); } +#endif + *pc = c; + do + { + pc = &code_next(*pc); + + } while (*pc); + fpustackused += ci->fpuadjust; + //printf("stage()2: fpustackused = %d\n", fpustackused); + } + list_free(&stagelist); + + return pc; +} + +/****************************** + * Insert c into scheduling table. + * Returns: + * 0 could not be scheduled; have to start a new one + */ + +int Schedule::insert(Cinfo *ci) +{ code *c; + int clocks; + int i; + int ic = 0; + int imin; + targ_size_t offset; + targ_size_t vpointer; + int movesp = 0; + int reg2 = -1; // avoid "may be uninitialized" warning + + //printf("insert "); ci->c->print(); + //printf("insert() %d\n", fpustackused); + c = ci->c; + //printf("\tc->Iop %x\n",c->Iop); + vpointer = c->IEVpointer1; + assert((unsigned)tblmax <= TBLMAX); + if (tblmax == TBLMAX) // if out of space + goto Lnoinsert; + if (tblmax == 0) // if table is empty + { // Just stuff it in the first slot + i = tblmax; + goto Linsert; + } + else if (c->Iflags & (CFtarg | CFtarg2)) + // Jump targets can only be first in the scheduler + goto Lnoinsert; + + // Special case of: + // PUSH reg1 + // MOV reg2,x[ESP] + if (c->Iop == 0x8B && + (c->Irm & modregrm(3,0,7)) == modregrm(1,0,4) && + c->Isib == modregrm(0,4,SP) && + c->IFL1 == FLconst && + ((signed char)c->IEVpointer1) >= REGSIZE + ) + { + movesp = 1; // this is a MOV reg2,offset[ESP] + offset = (signed char)c->IEVpointer1; + reg2 = (c->Irm >> 3) & 7; + } + + + // Start at tblmax, and back up until we get a conflict + ic = -1; + imin = 0; + for (i = tblmax; i >= 0; i--) + { Cinfo *cit; + + cit = tbl[i]; + if (!cit) + continue; + + // Look for special case swap + if (movesp && + (cit->c->Iop & ~7) == 0x50 && // if PUSH reg1 + (cit->c->Iop & 7) != reg2 && // if reg1 != reg2 + ((signed char)c->IEVpointer1) >= -cit->spadjust + ) + { + c->IEVpointer1 += cit->spadjust; + //printf("\t1, spadjust = %d, ptr = x%x\n",cit->spadjust,c->IEVpointer1); + continue; + } + + if (movesp && + cit->c->Iop == 0x83 && + cit->c->Irm == modregrm(3,5,SP) && // if SUB ESP,offset + cit->c->IFL2 == FLconst && + ((signed char)c->IEVpointer1) >= -cit->spadjust + ) + { + //printf("\t2, spadjust = %d\n",cit->spadjust); + c->IEVpointer1 += cit->spadjust; + continue; + } + + clocks = conflict(cit,ci,1); + if (clocks) + { int j; + + ic = i; // where the conflict occurred + clocks &= 0xFF; // convert to delay count + + // Move forward the delay clocks + if (clocks == 0) + j = i + 1; + else if (PRO) + j = (((i + 3) / 3) * 3) + clocks * 3; + else + { j = ((i + 2) & ~1) + clocks * 2; + + // It's possible we skipped over some AGI generating + // instructions due to movesp. + int k; + for (k = i + 1; k < j; k++) + { + if (k >= TBLMAX) + goto Lnoinsert; + if (tbl[k] && pair_agi(tbl[k],ci)) + { + k = ((k + 2) & ~1) + 1; + } + } + j = k; + } + + if (j >= TBLMAX) // exceed table size? + goto Lnoinsert; + imin = j; // first possible slot c can go in + break; + } + } + + + // Scan forward looking for a hole to put it in + for (i = imin; i < TBLMAX; i++) + { + if (tbl[i]) + { + // In case, due to movesp, we skipped over some AGI instructions + if (!PRO && pair_agi(tbl[i],ci)) + { + i = ((i + 2) & ~1) + 1; + if (i >= TBLMAX) + goto Lnoinsert; + } + } + else + { + if (PRO) + { int i0 = (i / 3) * 3; // index of decode unit 0 + Cinfo *ci0; + + assert(((TBLMAX / 3) * 3) == TBLMAX); + switch (i - i0) + { + case 0: // i0 can handle any instruction + goto Linsert; + case 1: + ci0 = tbl[i0]; + if (ci->uops > 1) + { + if (i0 >= imin && ci0->uops == 1) + goto L1; + i++; + break; + } + if (triple_test(ci0,ci,tbl[i0 + 2])) + goto Linsert; + break; + case 2: + ci0 = tbl[i0]; + if (ci->uops > 1) + { + if (i0 >= imin && ci0->uops == 1) + { + if (i >= tblmax) + { if (i + 1 >= TBLMAX) + goto Lnoinsert; + tblmax = i + 1; + } + tbl[i0 + 2] = tbl[i0 + 1]; + tbl[i0 + 1] = ci0; + i = i0; + goto Linsert; + } + break; + } + if (triple_test(ci0,tbl[i0 + 1],ci)) + goto Linsert; + break; + default: + assert(0); + } + } + else + { + assert((TBLMAX & 1) == 0); + if (i & 1) // if V pipe + { + if (pair_test(tbl[i - 1],ci)) + { + goto Linsert; + } + else if (i > imin && pair_test(ci,tbl[i - 1])) + { + L1: + tbl[i] = tbl[i - 1]; + if (i >= tblmax) + tblmax = i + 1; + i--; + //printf("\tswapping with x%02x\n",tbl[i + 1]->c->Iop); + goto Linsert; + } + } + else // will always fit in U pipe + { + assert(!tbl[i + 1]); // because V pipe should be empty + goto Linsert; + } + } + } + } + +Lnoinsert: + //printf("\tnoinsert\n"); + c->IEVpointer1 = vpointer; // reset to original value + return 0; + +Linsert: + // Insert at location i + assert(i < TBLMAX); + assert(tblmax <= TBLMAX); + tbl[i] = ci; + //printf("\tinsert at location %d\n",i); + + // If it's a scheduled floating point code, we have to adjust + // the FXCH values + if (ci->fp_op) + { int j; + + ci->fxch_pre = 0; + ci->fxch_post = 0; // start over again + + int fpu = fpustackused; + for (j = 0; j < tblmax; j++) + { + if (tbl[j]) + { + fpu += tbl[j]->fpuadjust; + if (fpu >= 8) // if FPU stack overflow + { tbl[i] = NULL; + //printf("fpu stack overflow\n"); + goto Lnoinsert; + } + } + } + + for (j = tblmax; j > i; j--) + { + if (j < TBLMAX && tbl[j]) + conflict(tbl[j],ci,2); + } + } + + if (movesp) + { // Adjust [ESP] offsets + int j; + + //printf("\tic = %d, inserting at %d\n",ic,i); + assert((unsigned)tblmax <= TBLMAX); + for (j = ic + 1; j < i; j++) + { Cinfo *cit; + + cit = tbl[j]; + if (cit) + { + c->IEVpointer1 -= cit->spadjust; + //printf("\t3, spadjust = %d, ptr = x%x\n",cit->spadjust,c->IEVpointer1); + } + } + } + if (i >= tblmax) + tblmax = i + 1; + + // Now do a hack. Look back at immediately preceding instructions, + // and see if we can swap with a push. + if (0 && movesp) + { int j; + + while (1) + { + for (j = 1; i > j; j++) + if (tbl[i - j]) + break; + + if (i >= j && tbl[i - j] && + (tbl[i - j]->c->Iop & ~7) == 0x50 && // if PUSH reg1 + (tbl[i - j]->c->Iop & 7) != reg2 && // if reg1 != reg2 + (signed char)c->IEVpointer1 >= REGSIZE) + { + //printf("\t-4 prec, i-j=%d, i=%d\n",i-j,i); + assert((unsigned)i < TBLMAX); + assert((unsigned)(i - j) < TBLMAX); + tbl[i] = tbl[i - j]; + tbl[i - j] = ci; + i -= j; + c->IEVpointer1 -= REGSIZE; + } + else + break; + } + } + + //printf("\tinsert\n"); + return 1; +} + + +/****************************** + * Insert c into staging area. + * Returns: + * 0 could not be scheduled; have to start a new one + */ + +int Schedule::stage(code *c) +{ Cinfo *ci; + list_t l; + list_t ln; + int agi; + + //printf("stage: "); c->print(); + if (cinfomax == TBLMAX) // if out of space + goto Lnostage; + ci = &cinfo[cinfomax++]; + getinfo(ci,c); + + if (c->Iflags & (CFtarg | CFtarg2 | CFvolatile)) + { + // Insert anything in stagelist + for (l = stagelist; l; l = ln) + { Cinfo *cs; + + ln = list_next(l); + cs = (Cinfo *)list_ptr(l); + if (!insert(cs)) + return 0; + list_subtract(&stagelist,cs); + } + return insert(ci); + } + + // Look through stagelist, and insert any AGI conflicting instructions + agi = 0; + for (l = stagelist; l; l = ln) + { Cinfo *cs; + + ln = list_next(l); + cs = (Cinfo *)list_ptr(l); + if (pair_agi(cs,ci)) + { + if (!insert(cs)) + goto Lnostage; + list_subtract(&stagelist,cs); + agi = 1; // we put out an AGI + } + } + + // Look through stagelist, and insert any other conflicting instructions + for (l = stagelist; l; l = ln) + { Cinfo *cs; + + ln = list_next(l); + cs = (Cinfo *)list_ptr(l); + if (conflict(cs,ci,0) && // if conflict + !(cs->flags & ci->flags & CIFLpush)) + { + if (cs->spadjust) + { + // We need to insert all previous adjustments to ESP + list_t la,lan; + + for (la = stagelist; la != l; la = lan) + { Cinfo *ca; + + lan = list_next(la); + ca = (Cinfo *)list_ptr(la); + if (ca->spadjust) + { if (!insert(ca)) + goto Lnostage; + list_subtract(&stagelist,ca); + } + } + } + + if (!insert(cs)) + goto Lnostage; + list_subtract(&stagelist,cs); + } + } + + // If floating point opcode, don't stage it, send it right out + if (!agi && ci->flags & CIFLnostage) + { + if (!insert(ci)) + goto Lnostage; + return 1; + } + + list_append(&stagelist,ci); // append to staging list + return 1; + +Lnostage: + return 0; +} + +/******************************************** + * Snip off tail of instruction sequence. + * Returns: + * next instruction (the tail) or + * NULL for no more instructions + */ + +STATIC code * csnip(code *c) +{ code **pc; + unsigned iflags; + + if (c) + { iflags = c->Iflags & CFclassinit; + while (1) + { + pc = &code_next(c); + c = *pc; + if (!c) + break; + if (c->Iflags & (CFtarg | CFtarg2)) + break; + if (!(c->Iop == NOP || + c->Iop == (ESCAPE | ESClinnum) || + c->Iflags & iflags)) + break; + } + *pc = NULL; + } + return c; +} + + +/****************************** + * Schedule Pentium instructions, + * based on Steve Russell's algorithm. + */ + +code *schedule(code *c,regm_t scratch) +{ + code *cresult = NULL; + code **pctail = &cresult; + Schedule sch; + + sch.initialize(0); // initialize scheduling table + while (c) + { + if ((c->Iop == NOP || + ((c->Iop & 0xFF) == ESCAPE && c->Iop != (ESCAPE | ESCadjfpu)) || + c->Iflags & CFclassinit) && + !(c->Iflags & (CFtarg | CFtarg2))) + { code *cn; + + // Just append this instruction to pctail and go to the next one + *pctail = c; + cn = code_next(c); + code_next(c) = NULL; + pctail = &code_next(c); + c = cn; + continue; + } + + //printf("init\n"); + sch.initialize(sch.fpustackused); // initialize scheduling table + + while (c) + { + //printf("insert %p\n",c); + if (!sch.stage(c)) // store c in scheduling table + break; + c = csnip(c); + } + + //printf("assem %d\n",sch.tblmax); + pctail = sch.assemble(pctail); // reassemble instruction stream + } + + return cresult; +} + +/**************************************************************************/ + +/******************************************** + * Replace any occurrence of r1 in EA with r2. + */ + +STATIC void repEA(code *c,unsigned r1,unsigned r2) +{ + unsigned mod,reg,rm; + unsigned rmn; + + rmn = c->Irm; + mod = rmn & 0xC0; + reg = rmn & modregrm(0,7,0); + rm = rmn & 7; + + if (mod == 0xC0 && rm == r1) + ; //c->Irm = mod | reg | r2; + else if (is32bitaddr(I32,c->Iflags) && + // If not disp32 + (rmn & modregrm(3,0,7)) != modregrm(0,0,5)) + { + if (rm == 4) + { // SIB byte addressing + unsigned sib; + unsigned base; + unsigned index; + + sib = c->Isib; + base = sib & 7; + index = (sib >> 3) & 7; + if (base == r1 && + !(r1 == 5 && mod == 0) && + !(r2 == 5 && mod == 0) + ) + base = r2; + if (index == r1) + index = r2; + c->Isib = (sib & 0xC0) | (index << 3) | base; + } + else if (rm == r1) + { + if (r1 == BP && r2 == SP) + { // Replace [EBP] with [ESP] + c->Irm = mod | reg | 4; + c->Isib = modregrm(0,4,SP); + } + else if (r2 == BP && mod == 0) + { + c->Irm = modregrm(1,0,0) | reg | r2; + c->IFL1 = FLconst; + c->IEV1.Vint = 0; + } + else + c->Irm = mod | reg | r2; + } + } +} + +/****************************************** + * Instruction scheduler. + * Input: + * c list of instructions to schedule + * scratch scratch registers we can use + * Returns: + * revised list of scheduled instructions + */ + +/****************************************** + * Swap c1 and c2. + * c1 comes before c2. + * Swap in place to not disturb addresses of jmp targets + */ + +STATIC void code_swap(code *c1,code *c2) +{ code cs; + + // Special case of: + // PUSH reg1 + // MOV reg2,x[ESP] + //printf("code_swap(%x, %x)\n",c1,c2); + if ((c1->Iop & ~7) == 0x50 && + c2->Iop == 0x8B && + (c2->Irm & modregrm(3,0,7)) == modregrm(1,0,4) && + c2->Isib == modregrm(0,4,SP) && + c2->IFL1 == FLconst && + ((signed char)c2->IEVpointer1) >= REGSIZE && + (c1->Iop & 7) != ((c2->Irm >> 3) & 7) + ) + c2->IEVpointer1 -= REGSIZE; + + + cs = *c2; + *c2 = *c1; + *c1 = cs; + // Retain original CFtarg + c1->Iflags = (c1->Iflags & ~(CFtarg | CFtarg2)) | (c2->Iflags & (CFtarg | CFtarg2)); + c2->Iflags = (c2->Iflags & ~(CFtarg | CFtarg2)) | (cs.Iflags & (CFtarg | CFtarg2)); + + c1->next = c2->next; + c2->next = cs.next; +} + +code *peephole(code *cstart,regm_t scratch) +{ + // Look for cases of: + // MOV r1,r2 + // OP ?,r1 + // we can replace with: + // MOV r1,r2 + // OP ?,r2 + // to improve pairing + code *c; + code *c1; + unsigned r1,r2; + unsigned mod,reg,rm; + + //printf("peephole\n"); + for (c = cstart; c; c = c1) + { unsigned char rmi; + unsigned char rmn; + + //c->print(); + c1 = cnext(c); + Ln: + if (!c1) + break; + if (c1->Iflags & (CFtarg | CFtarg2)) + continue; + + // Do: + // PUSH reg + if (I32 && (c->Iop & ~7) == 0x50) + { unsigned reg = c->Iop & 7; + + // MOV [ESP],reg => NOP + if (c1->Iop == 0x8B && + c1->Irm == modregrm(0,reg,4) && + c1->Isib == modregrm(0,4,SP)) + { c1->Iop = NOP; + continue; + } + + // PUSH [ESP] => PUSH reg + if (c1->Iop == 0xFF && + c1->Irm == modregrm(0,6,4) && + c1->Isib == modregrm(0,4,SP)) + { c1->Iop = 0x50 + reg; + continue; + } + + // CMP [ESP],imm => CMP reg,i,, + if (c1->Iop == 0x83 && + c1->Irm == modregrm(0,7,4) && + c1->Isib == modregrm(0,4,SP)) + { c1->Irm = modregrm(3,7,reg); + if (c1->IFL2 == FLconst && (signed char)c1->IEV2.Vuns == 0) + { // to TEST reg,reg + c1->Iop = (c1->Iop & 1) | 0x84; + c1->Irm = modregrm(3,reg,reg); + } + continue; + } + + } + + rmi = c->Irm; + + // Do: + // MOV reg,[ESP] => PUSH reg + // ADD ESP,4 => NOP + if (I32 && c->Iop == 0x8B && (rmi & 0xC7) == modregrm(0,0,4) && + c->Isib == modregrm(0,4,SP) && + c1->Iop == 0x83 && (c1->Irm & 0xC7) == modregrm(3,0,SP) && + !(c1->Iflags & CFpsw) && c1->IFL2 == FLconst && c1->IEV2.Vint == 4) + { unsigned reg = (rmi >> 3) & 7; + c->Iop = 0x58 + reg; + c1->Iop = NOP; + continue; + } + + if ((rmi & 0xC0) != 0xC0) + { + continue; + } + + // Combine two SUBs of the same register + if (c->Iop == c1->Iop && + c->Iop == 0x83 && + (rmi & modregrm(3,0,7)) == (c1->Irm & modregrm(3,0,7)) && + !(c1->Iflags & CFpsw) && + c->IFL2 == FLconst && c1->IFL2 == FLconst + ) + { int i = (signed char)c->IEV2.Vint; + int i1 = (signed char)c1->IEV2.Vint; + switch ((rmi & modregrm(0,7,0)) | ((c1->Irm & modregrm(0,7,0)) >> 3)) + { + case (0 << 3) | 0: // ADD, ADD + case (5 << 3) | 5: // SUB, SUB + i += i1; + goto Laa; + case (0 << 3) | 5: // ADD, SUB + case (5 << 3) | 0: // SUB, ADD + i -= i1; + goto Laa; + Laa: + if ((signed char)i != i) + c->Iop &= ~2; + c->IEV2.Vint = i; + c1->Iop = NOP; + if (i == 0) + c->Iop = NOP; + continue; + } + } + + if (c->Iop == 0x8B) // MOV r1,EA + { r1 = (rmi >> 3) & 7; + r2 = rmi & 7; + } + else if (c->Iop == 0x89) // MOV EA,r2 + { r1 = rmi & 7; + r2 = (rmi >> 3) & 7; + } + else + { + continue; + } + + rmn = c1->Irm; + mod = rmn & 0xC0; + reg = rmn & modregrm(0,7,0); + rm = rmn & 7; + if (cod3_EA(c1)) + repEA(c1,r1,r2); + switch (c1->Iop) + { + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: // PUSH reg + if ((c1->Iop & 7) == r1) + { c1->Iop = 0x50 | r2; + //printf("schedule PUSH reg\n"); + } + break; + + case 0x81: + case 0x83: + // Look for CMP EA,imm + if (reg == modregrm(0,7,0)) + { + if (mod == 0xC0 && rm == r1) + c1->Irm = mod | reg | r2; + } + break; + + case 0x84: // TEST reg,byte ptr EA + if (r1 >= 4 || r2 >= 4) // if not a byte register + break; + if ((rmn & 0xC0) == 0xC0) + { + if ((rmn & 3) == r1) + { c1->Irm = rmn = (rmn & modregrm(3,7,4)) | r2; + //printf("schedule 1\n"); + } + } + if ((rmn & modregrm(0,3,0)) == modregrm(0,r1,0)) + { c1->Irm = (rmn & modregrm(3,4,7)) | modregrm(0,r2,0); + //printf("schedule 2\n"); + } + break; + case 0x85: // TEST reg,word ptr EA + if ((rmn & 0xC0) == 0xC0) + { + if ((rmn & 7) == r1) + { c1->Irm = rmn = (rmn & modregrm(3,7,0)) | r2; + //printf("schedule 3\n"); + } + } + if ((rmn & modregrm(0,7,0)) == modregrm(0,r1,0)) + { c1->Irm = (rmn & modregrm(3,0,7)) | modregrm(0,r2,0); + //printf("schedule 4\n"); + } + break; + + case 0x89: // MOV EA,reg + if ((rmn & modregrm(0,7,0)) == modregrm(0,r1,0)) + { c1->Irm = (rmn & modregrm(3,0,7)) | modregrm(0,r2,0); + //printf("schedule 5\n"); + if (c1->Irm == modregrm(3,r2,r2)) + goto Lnop; + } + break; + + case 0x8B: // MOV reg,EA + if ((rmn & 0xC0) == 0xC0 && + (rmn & 7) == r1) // if EA == r1 + { c1->Irm = (rmn & modregrm(3,7,0)) | r2; + //printf("schedule 6\n"); + if (c1->Irm == modregrm(3,r2,r2)) + goto Lnop; + } + break; + + case 0x3C: // CMP AL,imm8 + if (r1 == AX && r2 < 4) + { c1->Iop = 0x80; + c1->Irm = modregrm(3,7,r2); + //printf("schedule 7, r2 = %d\n", r2); + } + break; + + case 0x3D: // CMP AX,imm16 + if (r1 == AX) + { c1->Iop = 0x81; + c1->Irm = modregrm(3,7,r2); + if (c1->IFL2 == FLconst && + c1->IEV2.Vuns == (signed char)c1->IEV2.Vuns) + c1->Iop = 0x83; + //printf("schedule 8\n"); + } + break; + } + continue; +Lnop: + c1->Iop = NOP; + c1 = cnext(c1); + goto Ln; + } +L1: ; + return cstart; +} + +/*****************************************************************/ + +/********************************************** + * Replace complex instructions with simple ones more conducive + * to scheduling. + */ + +code *simpleops(code *c,regm_t scratch) +{ code *cstart; + code **pc; + unsigned reg; + code *c2; + + // Worry about using registers not saved yet by prolog + scratch &= ~fregsaved; + + if (!(scratch & (scratch - 1))) // if 0 or 1 registers + return c; + + reg = findreg(scratch); + + cstart = c; + for (pc = &cstart; *pc; pc = &code_next(*pc)) + { + c = *pc; + if (c->Iflags & (CFtarg | CFtarg2 | CFopsize)) + continue; + if (c->Iop == 0x83 && + (c->Irm & modregrm(0,7,0)) == modregrm(0,7,0) && + (c->Irm & modregrm(3,0,0)) != modregrm(3,0,0) + ) + { // Replace CMP mem,imm with: + // MOV reg,mem + // CMP reg,imm + targ_long imm; + + //printf("replacing CMP\n"); + c->Iop = 0x8B; + c->Irm = (c->Irm & modregrm(3,0,7)) | modregrm(0,reg,0); + + c2 = code_calloc(); + if (reg == AX) + c2->Iop = 0x3D; + else + { c2->Iop = 0x83; + c2->Irm = modregrm(3,7,reg); + } + c2->IFL2 = c->IFL2; + c2->IEV2 = c->IEV2; + + // See if c2 should be replaced by a TEST + imm = c2->IEV2.Vuns; + if (!(c2->Iop & 1)) + imm &= 0xFF; + else if (I32 ? c->Iflags & CFopsize : !(c->Iflags & CFopsize)) + imm = (short) imm; + if (imm == 0) + { + c2->Iop = 0x85; // TEST reg,reg + c2->Irm = modregrm(3,reg,reg); + } + goto L1; + } + else if (c->Iop == 0xFF && + (c->Irm & modregrm(0,7,0)) == modregrm(0,6,0) && + (c->Irm & modregrm(3,0,0)) != modregrm(3,0,0) + ) + { // Replace PUSH mem with: + // MOV reg,mem + // PUSH reg + + // printf("replacing PUSH\n"); + c->Iop = 0x8B; + c->Irm = (c->Irm & modregrm(3,0,7)) | modregrm(0,reg,0); + + c2 = gen1(NULL,0x50 + reg); + L1: +//c->print(); +//c2->print(); + c2->next = c->next; + c->next = c2; + + // Switch to another reg + if (scratch & ~mask[reg]) + reg = findreg(scratch & ~mask[reg]); + } + } + return cstart; +} + +#if DEBUG +static const char *fpops[] = {"fstp","fld","fop"}; +void Cinfo::print() +{ + Cinfo *ci = this; + + if (ci == NULL) + { + printf("Cinfo 0\n"); + return; + } + + printf("Cinfo %p: c %p, pair %x, sz %d, isz %d, flags - ", + ci,c,pair,sz,isz); + if (ci->flags & CIFLarraybounds) + printf("arraybounds,"); + if (ci->flags & CIFLea) + printf("ea,"); + if (ci->flags & CIFLnostage) + printf("nostage,"); + if (ci->flags & CIFLpush) + printf("push,"); + if (ci->flags & ~(CIFLarraybounds|CIFLnostage|CIFLpush|CIFLea)) + printf("bad flag,"); + printf("\n\tr %lx w %lx a %lx reg %x uops %x sibmodrm %x spadjust %ld\n", + (long)r,(long)w,(long)a,reg,uops,sibmodrm,(long)spadjust); + if (ci->fp_op) + printf("\tfp_op %s, fxch_pre %x, fxch_post %x\n", + fpops[fp_op-1],fxch_pre,fxch_post); +} +#endif +#endif diff --git a/backend/cgxmm.c b/backend/cgxmm.c new file mode 100644 index 00000000..727b9c0e --- /dev/null +++ b/backend/cgxmm.c @@ -0,0 +1,780 @@ +// Copyright (C) 2011-2012 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "oper.h" +#include "el.h" +#include "code.h" +#include "global.h" +#include "type.h" +#if SCPP +#include "exh.h" +#endif +#include "xmm.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +unsigned xmmoperator(tym_t tym, unsigned oper); + +/******************************************* + * Move constant value into xmm register xreg. + */ + +code *movxmmconst(unsigned xreg, unsigned sz, targ_size_t value, regm_t flags) +{ + /* Generate: + * MOV reg,value + * MOV xreg,reg + * Not so efficient. We should at least do a PXOR for 0. + */ + assert(mask[xreg] & XMMREGS); + assert(sz == 4 || sz == 8); + code *c; + if (I32 && sz == 8) + { + unsigned r; + regm_t rm = ALLREGS; + c = allocreg(&rm,&r,TYint); // allocate scratch register + union { targ_size_t s; targ_long l[2]; } u; + u.l[1] = 0; + u.s = value; + targ_long *p = &u.l[0]; + c = movregconst(c,r,p[0],0); + c = genfltreg(c,0x89,r,0); // MOV floatreg,r + c = movregconst(c,r,p[1],0); + c = genfltreg(c,0x89,r,4); // MOV floatreg+4,r + + unsigned op = xmmload(TYdouble); + c = genfltreg(c,op,xreg - XMM0,0); // MOVSD XMMreg,floatreg + } + else + { + unsigned reg; + c = regwithvalue(CNIL,ALLREGS,value,®,(sz == 8) ? 64 : 0); + c = gen2(c,LODD,modregxrmx(3,xreg-XMM0,reg)); // MOVD xreg,reg + if (sz == 8) + code_orrex(c, REX_W); + } + return c; +} + +/*********************************************** + * Do simple orthogonal operators for XMM registers. + */ + +code *orthxmm(elem *e, regm_t *pretregs) +{ elem *e1 = e->E1; + elem *e2 = e->E2; + regm_t retregs = *pretregs & XMMREGS; + if (!retregs) + retregs = XMMREGS; + code *c = codelem(e1,&retregs,FALSE); // eval left leaf + unsigned reg = findreg(retregs); + regm_t rretregs = XMMREGS & ~retregs; + code *cr = scodelem(e2, &rretregs, retregs, TRUE); // eval right leaf + + unsigned op = xmmoperator(e1->Ety, e->Eoper); + unsigned rreg = findreg(rretregs); + + code *cg; + if (OTrel(e->Eoper)) + { + retregs = mPSW; + cg = NULL; + code *cc = gen2(CNIL,op,modregxrmx(3,rreg-XMM0,reg-XMM0)); + return cat4(c,cr,cg,cc); + } + else + cg = getregs(retregs); + + code *co = gen2(CNIL,op,modregxrmx(3,reg-XMM0,rreg-XMM0)); + if (retregs != *pretregs) + co = cat(co,fixresult(e,retregs,pretregs)); + + return cat4(c,cr,cg,co); +} + + +/************************ + * Generate code for an assignment using XMM registers. + */ + +code *xmmeq(elem *e,regm_t *pretregs) +{ + tym_t tymll; + unsigned reg; + int i; + code *cl,*cr,*c,cs; + elem *e11; + bool regvar; /* TRUE means evaluate into register variable */ + regm_t varregm; + unsigned varreg; + targ_int postinc; + + //printf("xmmeq(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + elem *e1 = e->E1; + elem *e2 = e->E2; + int e2oper = e2->Eoper; + tym_t tyml = tybasic(e1->Ety); /* type of lvalue */ + regm_t retregs = *pretregs; + + if (!(retregs & XMMREGS)) + retregs = XMMREGS; // pick any XMM reg + + cs.Iop = xmmstore(tyml); + regvar = FALSE; + varregm = 0; + if (config.flags4 & CFG4optimized) + { + // Be careful of cases like (x = x+x+x). We cannot evaluate in + // x if x is in a register. + if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable + doinreg(e1->EV.sp.Vsym,e2) // and we can compute directly into it + ) + { regvar = TRUE; + retregs = varregm; + reg = varreg; /* evaluate directly in target register */ + } + } + if (*pretregs & mPSW && !EOP(e1)) // if evaluating e1 couldn't change flags + { // Be careful that this lines up with jmpopcode() + retregs |= mPSW; + *pretregs &= ~mPSW; + } + cr = scodelem(e2,&retregs,0,TRUE); // get rvalue + + // Look for special case of (*p++ = ...), where p is a register variable + if (e1->Eoper == OPind && + ((e11 = e1->E1)->Eoper == OPpostinc || e11->Eoper == OPpostdec) && + e11->E1->Eoper == OPvar && + e11->E1->EV.sp.Vsym->Sfl == FLreg + ) + { + postinc = e11->E2->EV.Vint; + if (e11->Eoper == OPpostdec) + postinc = -postinc; + cl = getlvalue(&cs,e11,RMstore | retregs); + freenode(e11->E2); + } + else + { postinc = 0; + cl = getlvalue(&cs,e1,RMstore | retregs); // get lvalue (cl == CNIL if regvar) + } + + c = getregs_imm(varregm); + + reg = findreg(retregs & XMMREGS); + cs.Irm |= modregrm(0,(reg - XMM0) & 7,0); + if ((reg - XMM0) & 8) + cs.Irex |= REX_R; + + // Do not generate mov from register onto itself + if (!(regvar && reg == XMM0 + ((cs.Irm & 7) | (cs.Irex & REX_B ? 8 : 0)))) + c = gen(c,&cs); // MOV EA+offset,reg + + if (e1->Ecount || // if lvalue is a CSE or + regvar) // rvalue can't be a CSE + { + c = cat(c,getregs_imm(retregs)); // necessary if both lvalue and + // rvalue are CSEs (since a reg + // can hold only one e at a time) + cssave(e1,retregs,EOP(e1)); // if lvalue is a CSE + } + + c = cat4(cr,cl,c,fixresult(e,retregs,pretregs)); +Lp: + if (postinc) + { + int reg = findreg(idxregm(&cs)); + if (*pretregs & mPSW) + { // Use LEA to avoid touching the flags + unsigned rm = cs.Irm & 7; + if (cs.Irex & REX_B) + rm |= 8; + c = genc1(c,0x8D,buildModregrm(2,reg,rm),FLconst,postinc); + if (tysize(e11->E1->Ety) == 8) + code_orrex(c, REX_W); + } + else if (I64) + { + c = genc2(c,0x81,modregrmx(3,0,reg),postinc); + if (tysize(e11->E1->Ety) == 8) + code_orrex(c, REX_W); + } + else + { + if (postinc == 1) + c = gen1(c,0x40 + reg); // INC reg + else if (postinc == -(targ_int)1) + c = gen1(c,0x48 + reg); // DEC reg + else + { + c = genc2(c,0x81,modregrm(3,0,reg),postinc); + } + } + } + freenode(e1); + return c; +} + +/******************************** + * Generate code for conversion using SSE2 instructions. + * + * OPs32_d + * OPs64_d (64-bit only) + * OPu32_d (64-bit only) + * OPd_f + * OPf_d + * OPd_s32 + * OPd_s64 (64-bit only) + * + */ + +code *xmmcnvt(elem *e,regm_t *pretregs) +{ + code *c; + unsigned op=0, regs; + tym_t ty; + unsigned char rex = 0; + bool zx = false; // zero extend uint + + /* There are no ops for integer <-> float/real conversions + * but there are instructions for them. In order to use these + * try to fuse chained conversions. Be careful not to loose + * precision for real to long. + */ + elem *e1 = e->E1; + switch (e->Eoper) + { + case OPd_f: + if (e1->Eoper == OPs32_d) + ; + else if (I64 && e1->Eoper == OPs64_d) + rex = REX_W; + else if (I64 && e1->Eoper == OPu32_d) + { rex = REX_W; + zx = true; + } + else + { regs = XMMREGS; + op = CVTSD2SS; + ty = TYfloat; + break; + } + // directly use si2ss + regs = ALLREGS; + e1 = e1->E1; + op = CVTSI2SS; + ty = TYfloat; + break; + + case OPs32_d: goto Litod; + case OPs64_d: rex = REX_W; goto Litod; + case OPu32_d: rex = REX_W; zx = true; goto Litod; + Litod: + regs = ALLREGS; + op = CVTSI2SD; + ty = TYdouble; + break; + + case OPd_s32: ty = TYint; goto Ldtoi; + case OPd_s64: ty = TYlong; rex = REX_W; goto Ldtoi; + Ldtoi: + regs = XMMREGS; + switch (e1->Eoper) + { + case OPf_d: + e1 = e1->E1; + op = CVTTSS2SI; + break; + case OPld_d: + if (e->Eoper == OPd_s64) + return cnvt87(e,pretregs); // precision + /* FALL-THROUGH */ + default: + op = CVTTSD2SI; + break; + } + break; + + case OPf_d: + regs = XMMREGS; + op = CVTSS2SD; + ty = TYdouble; + break; + } + assert(op); + + c = codelem(e1, ®s, FALSE); + unsigned reg = findreg(regs); + if (reg >= XMM0) + reg -= XMM0; + else if (zx) + { assert(I64); + c = cat(c,getregs(regs)); + c = genregs(c,0x89,reg,reg); // MOV reg,reg to zero upper 32-bit + code_orflag(c,CFvolatile); + } + + unsigned retregs = *pretregs; + if (tyxmmreg(ty)) // target is XMM + { if (!(*pretregs & XMMREGS)) + retregs = XMMREGS; + } + else // source is XMM + { assert(regs & XMMREGS); + if (!(retregs & ALLREGS)) + retregs = ALLREGS; + } + + unsigned rreg; + c = cat(c,allocreg(&retregs,&rreg,ty)); + if (rreg >= XMM0) + rreg -= XMM0; + + c = gen2(c, op, modregxrmx(3,rreg,reg)); + assert(I64 || !rex); + if (rex) + code_orrex(c, rex); + + if (*pretregs != retregs) + c = cat(c,fixresult(e,retregs,pretregs)); + return c; +} + +/******************************** + * Generate code for op= + */ + +code *xmmopass(elem *e,regm_t *pretregs) +{ elem *e1 = e->E1; + elem *e2 = e->E2; + tym_t ty1 = tybasic(e1->Ety); + unsigned sz1 = tysize[ty1]; + regm_t rretregs = XMMREGS & ~*pretregs; + if (!rretregs) + rretregs = XMMREGS; + + code *cr = codelem(e2,&rretregs,FALSE); // eval right leaf + unsigned rreg = findreg(rretregs); + + code cs; + code *cl,*cg; + + regm_t retregs; + unsigned reg; + bool regvar = FALSE; + if (config.flags4 & CFG4optimized) + { + // Be careful of cases like (x = x+x+x). We cannot evaluate in + // x if x is in a register. + unsigned varreg; + regm_t varregm; + if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable + doinreg(e1->EV.sp.Vsym,e2) // and we can compute directly into it + ) + { regvar = TRUE; + retregs = varregm; + reg = varreg; // evaluate directly in target register + cl = NULL; + cg = getregs(retregs); // destroy these regs + } + } + + if (!regvar) + { + cl = getlvalue(&cs,e1,rretregs); // get EA + retregs = *pretregs & XMMREGS & ~rretregs; + if (!retregs) + retregs = XMMREGS & ~rretregs; + cg = allocreg(&retregs,®,ty1); + cs.Iop = xmmload(ty1); // MOVSD xmm,xmm_m64 + code_newreg(&cs,reg - XMM0); + cg = gen(cg,&cs); + } + + unsigned op = xmmoperator(e1->Ety, e->Eoper); + code *co = gen2(CNIL,op,modregxrmx(3,reg-XMM0,rreg-XMM0)); + + if (!regvar) + { + cs.Iop = xmmstore(ty1); // reverse operand order of MOVS[SD] + gen(co,&cs); + } + + if (e1->Ecount || // if lvalue is a CSE or + regvar) // rvalue can't be a CSE + { + cl = cat(cl,getregs_imm(retregs)); // necessary if both lvalue and + // rvalue are CSEs (since a reg + // can hold only one e at a time) + cssave(e1,retregs,EOP(e1)); // if lvalue is a CSE + } + + co = cat(co,fixresult(e,retregs,pretregs)); + freenode(e1); + return cat4(cr,cl,cg,co); +} + +/****************** + * Negate operator + */ + +code *xmmneg(elem *e,regm_t *pretregs) +{ + //printf("xmmneg()\n"); + //elem_print(e); + assert(*pretregs); + tym_t tyml = tybasic(e->E1->Ety); + int sz = tysize[tyml]; + + regm_t retregs = *pretregs & XMMREGS; + if (!retregs) + retregs = XMMREGS; + + /* Generate: + * MOV reg,e1 + * MOV rreg,signbit + * XOR reg,rreg + */ + code *cl = codelem(e->E1,&retregs,FALSE); + cl = cat(cl,getregs(retregs)); + unsigned reg = findreg(retregs); + regm_t rretregs = XMMREGS & ~retregs; + unsigned rreg; + cl = cat(cl,allocreg(&rretregs,&rreg,tyml)); + targ_size_t signbit = 0x80000000; + if (sz == 8) + signbit = 0x8000000000000000LL; + code *c = movxmmconst(rreg, sz, signbit, 0); + + code *cg = getregs(retregs); + unsigned op = (sz == 8) ? XORPD : XORPS; // XORPD/S reg,rreg + code *co = gen2(CNIL,op,modregxrmx(3,reg-XMM0,rreg-XMM0)); + co = cat(co,fixresult(e,retregs,pretregs)); + return cat4(cl,c,cg,co); +} + +/***************************** + * Get correct load operator based on type. + * It is important to use the right one even if the number of bits moved is the same, + * as there are performance consequences for using the wrong one. + */ + +unsigned xmmload(tym_t tym) +{ unsigned op; + switch (tybasic(tym)) + { + case TYfloat: + case TYifloat: op = LODSS; break; // MOVSS + case TYdouble: + case TYidouble: op = LODSD; break; // MOVSD + + case TYfloat4: op = LODAPS; break; // MOVAPS + case TYdouble2: op = LODAPD; break; // MOVAPD + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: op = LODDQA; break; // MOVDQA + + default: + printf("tym = x%x\n", tym); + assert(0); + } + return op; +} + +/***************************** + * Get correct store operator based on type. + */ + +unsigned xmmstore(tym_t tym) +{ unsigned op; + switch (tybasic(tym)) + { + case TYfloat: + case TYifloat: op = STOSS; break; // MOVSS + case TYdouble: + case TYidouble: + case TYllong: + case TYullong: + case TYuint: + case TYlong: + case TYcfloat: op = STOSD; break; // MOVSD + + case TYfloat4: op = STOAPS; break; // MOVAPS + case TYdouble2: op = STOAPD; break; // MOVAPD + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: op = STODQA; break; // MOVDQA + + default: + printf("tym = x%x\n", tym); + assert(0); + } + return op; +} + +/************************************ + * Get correct XMM operator based on type and operator. + */ + +unsigned xmmoperator(tym_t tym, unsigned oper) +{ + tym = tybasic(tym); + unsigned op; + switch (oper) + { + case OPadd: + case OPaddass: + switch (tym) + { + case TYfloat: + case TYifloat: op = ADDSS; break; + case TYdouble: + case TYidouble: op = ADDSD; break; + + // SIMD vector types + case TYfloat4: op = ADDPS; break; + case TYdouble2: op = ADDPD; break; + case TYschar16: + case TYuchar16: op = PADDB; break; + case TYshort8: + case TYushort8: op = PADDW; break; + case TYlong4: + case TYulong4: op = PADDD; break; + case TYllong2: + case TYullong2: op = PADDQ; break; + + default: assert(0); + } + break; + + case OPmin: + case OPminass: + switch (tym) + { + case TYfloat: + case TYifloat: op = SUBSS; break; + case TYdouble: + case TYidouble: op = SUBSD; break; + + // SIMD vector types + case TYfloat4: op = SUBPS; break; + case TYdouble2: op = SUBPD; break; + case TYschar16: + case TYuchar16: op = PSUBB; break; + case TYshort8: + case TYushort8: op = PSUBW; break; + case TYlong4: + case TYulong4: op = PSUBD; break; + case TYllong2: + case TYullong2: op = PSUBQ; break; + + default: assert(0); + } + break; + + case OPmul: + case OPmulass: + switch (tym) + { + case TYfloat: + case TYifloat: op = MULSS; break; + case TYdouble: + case TYidouble: op = MULSD; break; + + // SIMD vector types + case TYfloat4: op = MULPS; break; + case TYdouble2: op = MULPD; break; + case TYshort8: + case TYushort8: op = PMULLW; break; + + default: assert(0); + } + break; + + case OPdiv: + case OPdivass: + switch (tym) + { + case TYfloat: + case TYifloat: op = DIVSS; break; + case TYdouble: + case TYidouble: op = DIVSD; break; + + // SIMD vector types + case TYfloat4: op = DIVPS; break; + case TYdouble2: op = DIVPD; break; + + default: assert(0); + } + break; + + case OPor: + case OPorass: + switch (tym) + { + // SIMD vector types + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: op = POR; break; + + default: assert(0); + } + break; + + case OPand: + case OPandass: + switch (tym) + { + // SIMD vector types + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: op = PAND; break; + + default: assert(0); + } + break; + + case OPxor: + case OPxorass: + switch (tym) + { + // SIMD vector types + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: op = PXOR; break; + + default: assert(0); + } + break; + + case OPlt: + case OPle: + case OPgt: + case OPge: + case OPne: + case OPeqeq: + case OPunord: /* !<>= */ + case OPlg: /* <> */ + case OPleg: /* <>= */ + case OPule: /* !> */ + case OPul: /* !>= */ + case OPuge: /* !< */ + case OPug: /* !<= */ + case OPue: /* !<> */ + case OPngt: + case OPnge: + case OPnlt: + case OPnle: + case OPord: + case OPnlg: + case OPnleg: + case OPnule: + case OPnul: + case OPnuge: + case OPnug: + case OPnue: + switch (tym) + { + case TYfloat: + case TYifloat: op = UCOMISS; break; + case TYdouble: + case TYidouble: op = UCOMISD; break; + + default: assert(0); + } + break; + + default: + assert(0); + } + return op; +} + +code *cdvector(elem *e, regm_t *pretregs) +{ + /* e should look like: + * vector + * | + * param + * / \ + * param op2 + * / \ + * op op1 + */ + + if (!config.fpxmmregs) + { printf("SIMD operations not supported on this platform\n"); + exit(1); + } + + elem *e1 = e->E1; + assert(e1->Eoper == OPparam); + elem *op2 = e1->E2; + e1 = e1->E1; + assert(e1->Eoper == OPparam); + elem *eop = e1->E1; + assert(eop->Eoper == OPconst); + elem *op1 = e1->E2; + + tym_t ty1 = tybasic(op1->Ety); + unsigned sz1 = tysize[ty1]; + assert(sz1 == 16); // float or double + regm_t retregs = *pretregs & XMMREGS; + if (!retregs) + retregs = XMMREGS; + code *c = codelem(op1,&retregs,FALSE); // eval left leaf + unsigned reg = findreg(retregs); + regm_t rretregs = XMMREGS & ~retregs; + code *cr = scodelem(op2, &rretregs, retregs, TRUE); // eval right leaf + unsigned rreg = findreg(rretregs); + code *cg = getregs(retregs); + unsigned op = el_tolong(eop); + code *co = gen2(CNIL,op,modregxrmx(3,reg-XMM0,rreg-XMM0)); + co = cat(co,fixresult(e,retregs,pretregs)); + return cat4(c,cr,cg,co); +} + +#endif // !SPP diff --git a/backend/cod1.c b/backend/cod1.c new file mode 100644 index 00000000..4474989c --- /dev/null +++ b/backend/cod1.c @@ -0,0 +1,3990 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2012 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "global.h" +#include "type.h" +#include "xmm.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/* Generate the appropriate ESC instruction */ +#define ESC(MF,b) (0xD8 + ((MF) << 1) + (b)) +enum MF +{ // Values for MF + MFfloat = 0, + MFlong = 1, + MFdouble = 2, + MFword = 3 +}; +code * genf2(code *c,unsigned op,unsigned rm); + +targ_size_t paramsize(elem *e,unsigned stackalign); +STATIC code * funccall (elem *,unsigned,unsigned,regm_t *,regm_t); + +/* array to convert from index register to r/m field */ + /* AX CX DX BX SP BP SI DI */ +static const signed char regtorm32[8] = { 0, 1, 2, 3,-1, 5, 6, 7 }; + signed char regtorm [8] = { -1,-1,-1, 7,-1, 6, 4, 5 }; + +/************************** + * Determine if e is a 32 bit scaled index addressing mode. + * Returns: + * 0 not a scaled index addressing mode + * !=0 the value for ss in the SIB byte + */ + +int isscaledindex(elem *e) +{ targ_uns ss; + + assert(!I16); + while (e->Eoper == OPcomma) + e = e->E2; + if (!(e->Eoper == OPshl && !e->Ecount && + e->E2->Eoper == OPconst && + (ss = e->E2->EV.Vuns) <= 3 + ) + ) + ss = 0; + return ss; +} + +/********************************************* + * Generate code for which isscaledindex(e) returned a non-zero result. + */ + +code *cdisscaledindex(elem *e,regm_t *pidxregs,regm_t keepmsk) +{ code *c; + regm_t r; + + // Load index register with result of e->E1 + c = NULL; + while (e->Eoper == OPcomma) + { + r = 0; + c = cat(c,scodelem(e->E1,&r,keepmsk,TRUE)); + freenode(e); + e = e->E2; + } + assert(e->Eoper == OPshl); + c = cat(c,scodelem(e->E1,pidxregs,keepmsk,TRUE)); + freenode(e->E2); + freenode(e); + return c; +} + +/*********************************** + * Determine index if we can do two LEA instructions as a multiply. + * Returns: + * 0 can't do it + */ + +static struct Ssindex +{ + targ_uns product; + char ss1; + char ss2; + char ssflags; + #define SSFLnobp 1 // can't have EBP in relconst + #define SSFLnobase1 2 // no base register for first LEA + #define SSFLnobase 4 // no base register + #define SSFLlea 8 // can do it in one LEA +} ssindex_array[] = +{ {0, 0,0}, // [0] is a place holder + + {3, 1,0,SSFLnobp | SSFLlea}, + {5, 2,0,SSFLnobp | SSFLlea}, + {9, 3,0,SSFLnobp | SSFLlea}, + + {6, 1,1,SSFLnobase}, + {12,1,2,SSFLnobase}, + {24,1,3,SSFLnobase}, + {10,2,1,SSFLnobase}, + {20,2,2,SSFLnobase}, + {40,2,3,SSFLnobase}, + {18,3,1,SSFLnobase}, + {36,3,2,SSFLnobase}, + {72,3,3,SSFLnobase}, + + {15,2,1,SSFLnobp}, + {25,2,2,SSFLnobp}, + {27,3,1,SSFLnobp}, + {45,3,2,SSFLnobp}, + {81,3,3,SSFLnobp}, + + {16,3,1,SSFLnobase1 | SSFLnobase}, + {32,3,2,SSFLnobase1 | SSFLnobase}, + {64,3,3,SSFLnobase1 | SSFLnobase}, +}; + +int ssindex(int op,targ_uns product) +{ int i; + + if (op == OPshl) + product = 1 << product; + for (i = 1; i < arraysize(ssindex_array); i++) + { + if (ssindex_array[i].product == product) + return i; + } + return 0; +} + +/*************************************** + * Build an EA of the form disp[base][index*scale]. + * Input: + * c struct to fill in + * base base register (-1 if none) + * index index register (-1 if none) + * scale scale factor - 1,2,4,8 + * disp displacement + */ + +void buildEA(code *c,int base,int index,int scale,targ_size_t disp) +{ unsigned char rm; + unsigned char sib; + unsigned char rex = 0; + + sib = 0; + if (!I16) + { unsigned ss; + + assert(index != SP); + + switch (scale) + { case 1: ss = 0; break; + case 2: ss = 1; break; + case 4: ss = 2; break; + case 8: ss = 3; break; + default: assert(0); + } + + if (base == -1) + { + if (index == -1) + rm = modregrm(0,0,5); + else + { + rm = modregrm(0,0,4); + sib = modregrm(ss,index & 7,5); + if (index & 8) + rex |= REX_X; + } + } + else if (index == -1) + { + if (base == SP) + { + rm = modregrm(2,0,4); + sib = modregrm(0,4,SP); + } + else + { rm = modregrm(2,0,base & 7); + if (base & 8) + { rex |= REX_B; + if (base == R12) + { + rm = modregrm(2,0,4); + sib = modregrm(0,4,4); + } + } + } + } + else + { + rm = modregrm(2,0,4); + sib = modregrm(ss,index & 7,base & 7); + if (index & 8) + rex |= REX_X; + if (base & 8) + rex |= REX_B; + } + } + else + { + // -1 AX CX DX BX SP BP SI DI + static unsigned char EA16rm[9][9] = + { + { 0x06,0x09,0x09,0x09,0x87,0x09,0x86,0x84,0x85, }, // -1 + { 0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09, }, // AX + { 0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09, }, // CX + { 0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09, }, // DX + { 0x87,0x09,0x09,0x09,0x09,0x09,0x09,0x80,0x81, }, // BX + { 0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09, }, // SP + { 0x86,0x09,0x09,0x09,0x09,0x09,0x09,0x82,0x83, }, // BP + { 0x84,0x09,0x09,0x09,0x80,0x09,0x82,0x09,0x09, }, // SI + { 0x85,0x09,0x09,0x09,0x81,0x09,0x83,0x09,0x09, } // DI + }; + + assert(scale == 1); + rm = EA16rm[base + 1][index + 1]; + assert(rm != 9); + } + c->Irm = rm; + c->Isib = sib; + c->Irex = rex; + c->IFL1 = FLconst; + c->IEV1.Vuns = disp; +} + +/********************************************* + * Build REX, modregrm and sib bytes + */ + +unsigned buildModregrm(int mod, int reg, int rm) +{ unsigned m; + if (I16) + m = modregrm(mod, reg, rm); + else + { + if ((rm & 7) == SP && mod != 3) + m = (modregrm(0,4,SP) << 8) | modregrm(mod,reg & 7,4); + else + m = modregrm(mod,reg & 7,rm & 7); + if (reg & 8) + m |= REX_R << 16; + if (rm & 8) + m |= REX_B << 16; + } + return m; +} + +/**************************************** + * Generate code for eecontext + */ + +void genEEcode() +{ regm_t retregs; + code *c; + + eecontext.EEin++; + regcon.immed.mval = 0; + retregs = 0; //regmask(eecontext.EEelem->Ety); + assert(EEoffset >= REGSIZE); + c = genc2(NULL,0x81,modregrm(3,5,SP),EEoffset - REGSIZE); // SUB ESP,EEoffset + gen1(c,0x50 + SI); // PUSH ESI + genadjesp(c,EEoffset); + c = gencodelem(c,eecontext.EEelem,&retregs, FALSE); + assignaddrc(c); + pinholeopt(c,NULL); + jmpaddr(c); + eecontext.EEcode = gen1(c,0xCC); // INT 3 + eecontext.EEin--; +} + +/******************************************** + * Gen a save/restore sequence for mask of registers. + */ + +void gensaverestore2(regm_t regm,code **csave,code **crestore) +{ + code *cs1 = *csave; + code *cs2 = *crestore; + + //printf("gensaverestore2(%s)\n", regm_str(regm)); + regm &= mBP | mES | ALLREGS | XMMREGS | mST0 | mST01; + for (int i = 0; regm; i++) + { + if (regm & 1) + { + if (i == ES) + { + cs1 = gen1(cs1, 0x06); // PUSH ES + cs2 = cat(gen1(CNIL, 0x07),cs2); // POP ES + } + else if (i == ST0 || i == ST01) + { + gensaverestore87(1 << i, &cs1, &cs2); + } + else if (i >= XMM0) + { unsigned idx; + cs1 = regsave.save(cs1, i, &idx); + cs2 = regsave.restore(cs2, i, idx); + } + else + { + cs1 = gen1(cs1,0x50 + (i & 7)); // PUSH i + code *c = gen1(NULL, 0x58 + (i & 7)); // POP i + if (i & 8) + { code_orrex(cs1, REX_B); + code_orrex(c, REX_B); + } + cs2 = cat(c,cs2); + } + } + regm >>= 1; + } + *csave = cs1; + *crestore = cs2; +} + +void gensaverestore(regm_t regm,code **csave,code **crestore) +{ + *csave = NULL; + *crestore = NULL; + gensaverestore2(regm, csave, crestore); +} + +/**************************************** + * Clean parameters off stack. + * Input: + * numpara amount to adjust stack pointer + * keepmsk mask of registers to not destroy + */ + +code *genstackclean(code *c,unsigned numpara,regm_t keepmsk) +{ + //dbg_printf("genstackclean(numpara = %d, stackclean = %d)\n",numpara,cgstate.stackclean); + if (numpara && (cgstate.stackclean || STACKALIGN == 16)) + { +#if 0 // won't work if operand of scodelem + if (numpara == stackpush && // if this is all those pushed + needframe && // and there will be a BP + !config.windows && + !(regcon.mvar & fregsaved) // and no registers will be pushed + ) + c = genregs(c,0x89,BP,SP); // MOV SP,BP + else +#endif + { regm_t scratchm = 0; + + if (numpara == REGSIZE && config.flags4 & CFG4space) + { + scratchm = ALLREGS & ~keepmsk & regcon.used & ~regcon.mvar; + } + + if (scratchm) + { unsigned r; + c = cat(c,allocreg(&scratchm,&r,TYint)); + c = gen1(c,0x58 + r); // POP r + } + else + { c = genc2(c,0x81,modregrm(3,0,SP),numpara); // ADD SP,numpara + if (I64) + code_orrex(c, REX_W); + } + } + stackpush -= numpara; + c = genadjesp(c,-numpara); + } + return c; +} + + +/********************************* + * Generate code for a logical expression. + * Input: + * e elem + * jcond + * bit 1 if TRUE then goto jump address if e + * if FALSE then goto jump address if !e + * 2 don't call save87() + * fltarg FLcode or FLblock, flavor of target if e evaluates to jcond + * targ either code or block pointer to destination + */ + +code *logexp(elem *e,int jcond,unsigned fltarg,code *targ) +{ code *c,*ce,*cnop; + regm_t retregs; + unsigned op; + + //printf("logexp(e = %p, jcond = %d)\n", e, jcond); + int no87 = (jcond & 2) == 0; + _chkstack(); + code *cc = docommas(&e); // scan down commas + cgstate.stackclean++; + + if (EOP(e) && !e->Ecount) /* if operator and not common sub */ + { con_t regconsave; + + switch (e->Eoper) + { case OPoror: + if (jcond & 1) + { c = logexp(e->E1,jcond,fltarg,targ); + regconsave = regcon; + ce = logexp(e->E2,jcond,fltarg,targ); + } + else + { cnop = gennop(CNIL); + c = logexp(e->E1,jcond | 1,FLcode,cnop); + regconsave = regcon; + ce = logexp(e->E2,jcond,fltarg,targ); + ce = cat(ce,cnop); + } + cnop = CNIL; + goto L1; + + case OPandand: + if (jcond & 1) + { cnop = gennop(CNIL); /* a dummy target address */ + c = logexp(e->E1,jcond & ~1,FLcode,cnop); + regconsave = regcon; + ce = logexp(e->E2,jcond,fltarg,targ); + } + else + { c = logexp(e->E1,jcond,fltarg,targ); + regconsave = regcon; + ce = logexp(e->E2,jcond,fltarg,targ); + cnop = CNIL; + } + L1: andregcon(®consave); + freenode(e); + c = cat4(cc,c,ce,cnop); + goto Lret; + + case OPnot: + jcond ^= 1; + case OPbool: + case OPs8_16: + case OPu8_16: + case OPs16_32: + case OPu16_32: + case OPs32_64: + case OPu32_64: + case OPu32_d: + case OPd_ld: + c = logexp(e->E1,jcond,fltarg,targ); + freenode(e); + goto Lretc; + + case OPcond: + { + code *cnop2 = gennop(CNIL); // addresses of start of leaves + cnop = gennop(CNIL); + c = logexp(e->E1,FALSE,FLcode,cnop2); /* eval condition */ + con_t regconold = regcon; + ce = logexp(e->E2->E1,jcond,fltarg,targ); + ce = genjmp(ce,JMP,FLcode,(block *) cnop); /* skip second leaf */ + + regconsave = regcon; + regcon = regconold; + + code_next(cnop2) = logexp(e->E2->E2,jcond,fltarg,targ); + andregcon(®conold); + andregcon(®consave); + freenode(e->E2); + freenode(e); + c = cat6(cc,c,NULL,ce,cnop2,cnop); + goto Lret; + } + } + } + + /* Special code for signed long compare. + * Not necessary for I64 until we do cents. + */ + if (OTrel2(e->Eoper) && /* if < <= >= > */ + !e->Ecount && + ( (I16 && tybasic(e->E1->Ety) == TYlong && tybasic(e->E2->Ety) == TYlong) || + (I32 && tybasic(e->E1->Ety) == TYllong && tybasic(e->E2->Ety) == TYllong)) + ) + { + c = longcmp(e,jcond,fltarg,targ); + goto Lretc; + } + + retregs = mPSW; /* return result in flags */ + op = jmpopcode(e); /* get jump opcode */ + if (!(jcond & 1)) + op ^= 0x101; // toggle jump condition(s) + c = codelem(e,&retregs,TRUE); /* evaluate elem */ + if (no87) + c = cat(c,cse_flush(no87)); // flush CSE's to memory + genjmp(c,op,fltarg,(block *) targ); /* generate jmp instruction */ +Lretc: + c = cat(cc,c); +Lret: + cgstate.stackclean--; + return c; +} + + +/****************************** + * Routine to aid in setting things up for gen(). + * Look for common subexpression. + * Can handle indirection operators, but not if they're common subs. + * Input: + * e -> elem where we get some of the data from + * cs -> partially filled code to add + * op = opcode + * reg = reg field of (mod reg r/m) + * offset = data to be added to Voffset field + * keepmsk = mask of registers we must not destroy + * desmsk = mask of registers destroyed by executing the instruction + * Returns: + * pointer to code generated + */ + +code *loadea(elem *e,code *cs,unsigned op,unsigned reg,targ_size_t offset, + regm_t keepmsk,regm_t desmsk) +{ + code *c,*cg,*cd; + +#ifdef DEBUG + if (debugw) + printf("loadea: e=%p cs=%p op=x%x reg=%d offset=%lld keepmsk=x%x desmsk=x%x\n", + e,cs,op,reg,(unsigned long long)offset,keepmsk,desmsk); +#endif + + assert(e); + cs->Iflags = 0; + cs->Irex = 0; + cs->Iop = op; + tym_t tym = e->Ety; + int sz = tysize(tym); + + /* Determine if location we want to get is in a register. If so, */ + /* substitute the register for the EA. */ + /* Note that operators don't go through this. CSE'd operators are */ + /* picked up by comsub(). */ + if (e->Ecount && /* if cse */ + e->Ecount != e->Ecomsub && /* and cse was generated */ + op != 0x8D && op != 0xC4 && /* and not an LEA or LES */ + (op != 0xFF || reg != 3) && /* and not CALLF MEM16 */ + (op & 0xFFF8) != 0xD8) // and not 8087 opcode + { + assert(!EOP(e)); /* can't handle this */ + regm_t rm = regcon.cse.mval & ~regcon.cse.mops & ~regcon.mvar; // possible regs + if (sz > REGSIZE) // value is in 2 or 4 registers + { + if (I16 && sz == 8) // value is in 4 registers + { static regm_t rmask[4] = { mDX,mCX,mBX,mAX }; + rm &= rmask[offset >> 1]; + } + + else if (offset) + rm &= mMSW; /* only high words */ + else + rm &= mLSW; /* only low words */ + } + for (unsigned i = 0; rm; i++) + { if (mask[i] & rm) + { if (regcon.cse.value[i] == e && // if register has elem + /* watch out for a CWD destroying DX */ + !(i == DX && op == 0xF7 && desmsk & mDX)) + { + /* if ES, then it can only be a load */ + if (i == ES) + { if (op != 0x8B) + goto L1; /* not a load */ + cs->Iop = 0x8C; /* MOV reg,ES */ + cs->Irm = modregrm(3,0,reg & 7); + if (reg & 8) + code_orrex(cs, REX_B); + } + else // XXX reg,i + { + cs->Irm = modregrm(3,reg & 7,i & 7); + if (reg & 8) + cs->Irex |= REX_R; + if (i & 8) + cs->Irex |= REX_B; + if (sz == 1 && I64 && (i >= 4 || reg >= 4)) + cs->Irex |= REX; + if (I64 && (sz == 8 || sz == 16)) + cs->Irex |= REX_W; + } + c = CNIL; + goto L2; + } + rm &= ~mask[i]; + } + } + } + +L1: + c = getlvalue(cs,e,keepmsk); + if (offset == REGSIZE) + getlvalue_msw(cs); + else + cs->IEVoffset1 += offset; + if (I64) + { if (reg >= 4 && sz == 1) // if byte register + // Can only address those 8 bit registers if a REX byte is present + cs->Irex |= REX; + if ((op & 0xFFFFFFF8) == 0xD8) + cs->Irex &= ~REX_W; // not needed for x87 ops + } + code_newreg(cs, reg); // OR in reg field + if (!I16) + { + if (reg == 6 && op == 0xFF || /* don't PUSH a word */ + op == 0x0FB7 || op == 0x0FBF || /* MOVZX/MOVSX */ + (op & 0xFFF8) == 0xD8 || /* 8087 instructions */ + op == 0x8D) /* LEA */ + { + cs->Iflags &= ~CFopsize; + if (reg == 6 && op == 0xFF) // if PUSH + cs->Irex &= ~REX_W; // REX is ignored for PUSH anyway + } + } + else if ((op & 0xFFF8) == 0xD8 && ADDFWAIT()) + cs->Iflags |= CFwait; +L2: + cg = getregs(desmsk); /* save any regs we destroy */ + + /* KLUDGE! fix up DX for divide instructions */ + cd = CNIL; + if (op == 0xF7 && desmsk == (mAX|mDX)) /* if we need to fix DX */ + { if (reg == 7) /* if IDIV */ + { cd = gen1(cd,0x99); // CWD + if (I64 && sz == 8) + code_orrex(cd, REX_W); + } + else if (reg == 6) // if DIV + { cd = genregs(cd,0x33,DX,DX); // XOR DX,DX + if (I64 && sz == 8) + code_orrex(cd, REX_W); + } + } + + // Eliminate MOV reg,reg + if ((cs->Iop & ~3) == 0x88 && + (cs->Irm & 0xC7) == modregrm(3,0,reg & 7)) + { + unsigned r = cs->Irm & 7; + if (cs->Irex & REX_B) + r |= 8; + if (r == reg) + cs->Iop = NOP; + } + + return cat4(c,cg,cd,gen(NULL,cs)); +} + +/************************** + * Get addressing mode. + */ + +unsigned getaddrmode(regm_t idxregs) +{ + unsigned mode; + + if (I16) + { + mode = (idxregs & mBX) ? modregrm(2,0,7) : /* [BX] */ + (idxregs & mDI) ? modregrm(2,0,5): /* [DI] */ + (idxregs & mSI) ? modregrm(2,0,4): /* [SI] */ + (assert(0),1); + } + else + { unsigned reg = findreg(idxregs & (ALLREGS | mBP)); + if (reg == R12) + mode = (REX_B << 16) | (modregrm(0,4,4) << 8) | modregrm(2,0,4); + else + mode = modregrmx(2,0,reg); + } + return mode; +} + +void setaddrmode(code *c, regm_t idxregs) +{ + unsigned mode = getaddrmode(idxregs); + c->Irm = mode & 0xFF; + c->Isib = mode >> 8; + c->Irex &= ~REX_B; + c->Irex |= mode >> 16; +} + +/********************************************** + */ + +void getlvalue_msw(code *c) +{ + if (c->IFL1 == FLreg) + { + unsigned regmsw = c->IEVsym1->Sregmsw; + c->Irm = (c->Irm & ~7) | (regmsw & 7); + if (regmsw & 8) + c->Irex |= REX_B; + else + c->Irex &= ~REX_B; + } + else + c->IEVoffset1 += REGSIZE; +} + +/********************************************** + */ + +void getlvalue_lsw(code *c) +{ + if (c->IFL1 == FLreg) + { + unsigned reglsw = c->IEVsym1->Sreglsw; + c->Irm = (c->Irm & ~7) | (reglsw & 7); + if (reglsw & 8) + c->Irex |= REX_B; + else + c->Irex &= ~REX_B; + } + else + c->IEVoffset1 -= REGSIZE; +} + +/****************** + * Compute addressing mode. + * Generate & return sequence of code (if any). + * Return in cs the info on it. + * Input: + * pcs -> where to store data about addressing mode + * e -> the lvalue elem + * keepmsk mask of registers we must not destroy or use + * if (keepmsk & RMstore), this will be only a store operation + * into the lvalue + * if (keepmsk & RMload), this will be a read operation only + */ + +code *getlvalue(code *pcs,elem *e,regm_t keepmsk) +{ regm_t idxregs; + unsigned fl,f,opsave; + code *c; + elem *e1; + elem *e11; + elem *e12; + bool e1isadd,e1free; + unsigned reg; + tym_t e1ty; + symbol *s; + + //printf("getlvalue(e = %p)\n",e); + //elem_print(e); + assert(e); + elem_debug(e); + if (e->Eoper == OPvar || e->Eoper == OPrelconst) + { s = e->EV.sp.Vsym; + fl = s->Sfl; + if (tyfloating(s->ty())) + obj_fltused(); + } + else + fl = FLoper; + pcs->IFL1 = fl; + pcs->Iflags = CFoff; /* only want offsets */ + pcs->Irex = 0; + pcs->IEVoffset1 = 0; + + tym_t ty = e->Ety; + unsigned sz = tysize(ty); + if (tyfloating(ty)) + obj_fltused(); + if (I64 && (sz == 8 || sz == 16)) + pcs->Irex |= REX_W; + if (!I16 && sz == SHORTSIZE) + pcs->Iflags |= CFopsize; + if (ty & mTYvolatile) + pcs->Iflags |= CFvolatile; + c = CNIL; + switch (fl) + { +#if 0 && TARGET_LINUX + case FLgot: + case FLgotoff: + gotref = 1; + pcs->IEVsym1 = s; + pcs->IEVoffset1 = e->EV.sp.Voffset; + if (e->Eoper == OPvar && fl == FLgot) + { + code *c1; + unsigned saveop = pcs->Iop; + idxregs = allregs & ~keepmsk; // get a scratch register + c = allocreg(&idxregs,®,TYptr); + pcs->Irm = modregrm(2,reg,BX); // BX has GOT + pcs->Isib = 0; + //pcs->Iflags |= CFvolatile; + pcs->Iop = 0x8B; + c = gen(c,pcs); // MOV reg,disp[EBX] + pcs->Irm = modregrm(0,0,reg); + pcs->IEVoffset1 = 0; + pcs->Iop = saveop; + } + else + { + pcs->Irm = modregrm(2,0,BX); // disp[EBX] is addr + pcs->Isib = 0; + } + break; +#endif + case FLoper: +#ifdef DEBUG + if (debugw) printf("getlvalue(e = %p, km = x%x)\n",e,keepmsk); +#endif + switch (e->Eoper) + { + case OPadd: // this way when we want to do LEA + e1 = e; + e1free = FALSE; + e1isadd = TRUE; + break; + case OPind: + case OPpostinc: // when doing (*p++ = ...) + case OPpostdec: // when doing (*p-- = ...) + case OPbt: + case OPbtc: + case OPbtr: + case OPbts: + e1 = e->E1; + e1free = TRUE; + e1isadd = e1->Eoper == OPadd; + break; + default: +#ifdef DEBUG + elem_print(e); +#endif + assert(0); + } + e1ty = tybasic(e1->Ety); + if (e1isadd) + { e12 = e1->E2; + e11 = e1->E1; + } + + /* First see if we can replace *(e+&v) with + * MOV idxreg,e + * EA = [ES:] &v+idxreg + */ + f = FLconst; + if (e1isadd && + ((e12->Eoper == OPrelconst +#if TARGET_SEGMENTED + && (f = el_fl(e12)) != FLfardata +#endif + ) || + (e12->Eoper == OPconst && !I16 && !e1->Ecount && (!I64 || el_signx32(e12)))) && + !(I64 && config.flags3 & CFG3pic) && + e1->Ecount == e1->Ecomsub && +#if TARGET_SEGMENTED + (!e1->Ecount || (~keepmsk & ALLREGS & mMSW) || (e1ty != TYfptr && e1ty != TYhptr)) && +#endif + tysize(e11->Ety) == REGSIZE + ) + { unsigned char t; /* component of r/m field */ + int ss; + int ssi; + +#if !TARGET_SEGMENTED + if (e12->Eoper == OPrelconst) + f = el_fl(e12); +#endif + /*assert(datafl[f]);*/ /* what if addr of func? */ + if (!I16) + { /* Any register can be an index register */ + regm_t idxregs = allregs & ~keepmsk; + assert(idxregs); + + /* See if e1->E1 can be a scaled index */ + ss = isscaledindex(e11); + if (ss) + { + /* Load index register with result of e11->E1 */ + c = cdisscaledindex(e11,&idxregs,keepmsk); + reg = findreg(idxregs); + { + t = stackfl[f] ? 2 : 0; + pcs->Irm = modregrm(t,0,4); + pcs->Isib = modregrm(ss,reg & 7,5); + if (reg & 8) + pcs->Irex |= REX_X; + } + } + else if ((e11->Eoper == OPmul || e11->Eoper == OPshl) && + !e11->Ecount && + e11->E2->Eoper == OPconst && + (ssi = ssindex(e11->Eoper,e11->E2->EV.Vuns)) != 0 + ) + { + regm_t scratchm; + +#if 0 && TARGET_LINUX + assert(f != FLgot && f != FLgotoff); +#endif + char ssflags = ssindex_array[ssi].ssflags; + if (ssflags & SSFLnobp && stackfl[f]) + goto L6; + + // Load index register with result of e11->E1 + c = scodelem(e11->E1,&idxregs,keepmsk,TRUE); + reg = findreg(idxregs); + + int ss1 = ssindex_array[ssi].ss1; + if (ssflags & SSFLlea) + { + assert(!stackfl[f]); + pcs->Irm = modregrm(2,0,4); + pcs->Isib = modregrm(ss1,reg & 7,reg & 7); + if (reg & 8) + pcs->Irex |= REX_X | REX_B; + } + else + { int rbase; + unsigned r; + + scratchm = ALLREGS & ~keepmsk; + c = cat(c,allocreg(&scratchm,&r,TYint)); + + if (ssflags & SSFLnobase1) + { t = 0; + rbase = 5; + } + else + { t = 0; + rbase = reg; + if (rbase == BP || rbase == R13) + { static unsigned imm32[4] = {1+1,2+1,4+1,8+1}; + + // IMUL r,BP,imm32 + c = genc2(c,0x69,modregxrmx(3,r,rbase),imm32[ss1]); + goto L7; + } + } + + c = gen2sib(c,0x8D,modregxrm(t,r,4),modregrm(ss1,reg & 7,rbase & 7)); + if (reg & 8) + code_orrex(c, REX_X); + if (rbase & 8) + code_orrex(c, REX_B); + if (I64) + code_orrex(c, REX_W); + + if (ssflags & SSFLnobase1) + { code_last(c)->IFL1 = FLconst; + code_last(c)->IEV1.Vuns = 0; + } + L7: + if (ssflags & SSFLnobase) + { t = stackfl[f] ? 2 : 0; + rbase = 5; + } + else + { t = 2; + rbase = r; + assert(rbase != BP); + } + pcs->Irm = modregrm(t,0,4); + pcs->Isib = modregrm(ssindex_array[ssi].ss2,r & 7,rbase & 7); + if (r & 8) + pcs->Irex |= REX_X; + if (rbase & 8) + pcs->Irex |= REX_B; + } + freenode(e11->E2); + freenode(e11); + } + else + { + L6: + /* Load index register with result of e11 */ + c = scodelem(e11,&idxregs,keepmsk,TRUE); + setaddrmode(pcs, idxregs); +#if 0 && TARGET_LINUX + if (e12->EV.sp.Vsym->Sfl == FLgot || e12->EV.sp.Vsym->Sfl == FLgotoff) + { + gotref = 1; +#if 1 + reg = findreg(idxregs & (ALLREGS | mBP)); + pcs->Irm = modregrm(2,0,4); + pcs->Isib = modregrm(0,reg,BX); +#else + pcs->Isib = modregrm(0,pcs->Irm,BX); + pcs->Irm = modregrm(2,0,4); +#endif + } + else +#endif + if (stackfl[f]) /* if we need [EBP] too */ + { unsigned idx = pcs->Irm & 7; + if (pcs->Irex & REX_B) + pcs->Irex = (pcs->Irex & ~REX_B) | REX_X; + pcs->Isib = modregrm(0,idx,BP); + pcs->Irm = modregrm(2,0,4); + } + } + } + else + { + idxregs = IDXREGS & ~keepmsk; /* only these can be index regs */ + assert(idxregs); +#if 0 && TARGET_LINUX + assert(f != FLgot && f != FLgotoff); +#endif + if (stackfl[f]) /* if stack data type */ + { idxregs &= mSI | mDI; /* BX can't index off stack */ + if (!idxregs) goto L1; /* index regs aren't avail */ + t = 6; /* [BP+SI+disp] */ + } + else + t = 0; /* [SI + disp] */ + c = scodelem(e11,&idxregs,keepmsk,TRUE); /* load idx reg */ + pcs->Irm = getaddrmode(idxregs) ^ t; + } + if (f == FLpara) + refparam = TRUE; + else if (f == FLauto || f == FLtmp || f == FLbprel || f == FLfltreg) + reflocal = TRUE; +#if TARGET_SEGMENTED + else if (f == FLcsdata || tybasic(e12->Ety) == TYcptr) + pcs->Iflags |= CFcs; +#endif + else + assert(f != FLreg); + pcs->IFL1 = f; + if (f != FLconst) + pcs->IEVsym1 = e12->EV.sp.Vsym; + pcs->IEVoffset1 = e12->EV.sp.Voffset; /* += ??? */ + + /* If e1 is a CSE, we must generate an addressing mode */ + /* but also leave EA in registers so others can use it */ + if (e1->Ecount) + { unsigned flagsave; + + idxregs = IDXREGS & ~keepmsk; + c = cat(c,allocreg(&idxregs,®,TYoffset)); + +#if TARGET_SEGMENTED + /* If desired result is a far pointer, we'll have */ + /* to load another register with the segment of v */ + if (e1ty == TYfptr) + { + unsigned msreg; + + idxregs |= mMSW & ALLREGS & ~keepmsk; + c = cat(c,allocreg(&idxregs,&msreg,TYfptr)); + msreg = findregmsw(idxregs); + /* MOV msreg,segreg */ + c = genregs(c,0x8C,segfl[f],msreg); + } +#endif + opsave = pcs->Iop; + flagsave = pcs->Iflags; + pcs->Iop = 0x8D; + code_newreg(pcs, reg); + if (!I16) + pcs->Iflags &= ~CFopsize; + if (I64) + pcs->Irex |= REX_W; + c = gen(c,pcs); /* LEA idxreg,EA */ + cssave(e1,idxregs,TRUE); + if (!I16) + pcs->Iflags = flagsave; + if (stackfl[f] && (config.wflags & WFssneds)) // if pointer into stack + pcs->Iflags |= CFss; // add SS: override + pcs->Iop = opsave; + pcs->IFL1 = FLoffset; + pcs->IEV1.Vuns = 0; + setaddrmode(pcs, idxregs); + } + freenode(e12); + if (e1free) + freenode(e1); + goto Lptr; + } + + L1: + + /* The rest of the cases could be a far pointer */ + + idxregs = (I16 ? IDXREGS : allregs) & ~keepmsk; // only these can be index regs + assert(idxregs); + if (!I16 && + (sz == REGSIZE || (I64 && sz == 4)) && + keepmsk & RMstore) + idxregs |= regcon.mvar; + +#if TARGET_SEGMENTED + switch (e1ty) + { case TYfptr: /* if far pointer */ + case TYhptr: + idxregs = (mES | IDXREGS) & ~keepmsk; // need segment too + assert(idxregs & mES); + pcs->Iflags |= CFes; /* ES segment override */ + break; + case TYsptr: /* if pointer to stack */ + if (config.wflags & WFssneds) // if SS != DS + pcs->Iflags |= CFss; /* then need SS: override */ + break; + case TYcptr: /* if pointer to code */ + pcs->Iflags |= CFcs; /* then need CS: override */ + break; + } +#endif + pcs->IFL1 = FLoffset; + pcs->IEV1.Vuns = 0; + + /* see if we can replace *(e+c) with + * MOV idxreg,e + * [MOV ES,segment] + * EA = [ES:]c[idxreg] + */ + if (e1isadd && e12->Eoper == OPconst && + (!I64 || el_signx32(e12)) && + (tysize(e12->Ety) == REGSIZE || (I64 && tysize(e12->Ety) == 4)) && + (!e1->Ecount || !e1free) + ) + { int ss; + + pcs->IEV1.Vuns = e12->EV.Vuns; + freenode(e12); + if (e1free) freenode(e1); + if (!I16 && e11->Eoper == OPadd && !e11->Ecount && + tysize(e11->Ety) == REGSIZE) + { + e12 = e11->E2; + e11 = e11->E1; + e1 = e1->E1; + e1free = TRUE; + goto L4; + } + if (!I16 && (ss = isscaledindex(e11)) != 0) + { // (v * scale) + const + c = cdisscaledindex(e11,&idxregs,keepmsk); + reg = findreg(idxregs); + pcs->Irm = modregrm(0,0,4); + pcs->Isib = modregrm(ss,reg & 7,5); + if (reg & 8) + pcs->Irex |= REX_X; + } + else + { + c = scodelem(e11,&idxregs,keepmsk,TRUE); // load index reg + setaddrmode(pcs, idxregs); + } + goto Lptr; + } + + /* Look for *(v1 + v2) + * EA = [v1][v2] + */ + + if (!I16 && e1isadd && (!e1->Ecount || !e1free) && + (tysize[e1ty] == REGSIZE || (I64 && tysize[e1ty] == 4))) + { code *c2; + regm_t idxregs2; + unsigned base,index; + int ss; + + L4: + // Look for *(v1 + v2 << scale) + ss = isscaledindex(e12); + if (ss) + { + c = scodelem(e11,&idxregs,keepmsk,TRUE); + idxregs2 = allregs & ~(idxregs | keepmsk); + c2 = cdisscaledindex(e12,&idxregs2,keepmsk | idxregs); + } + + // Look for *(v1 << scale + v2) + else if ((ss = isscaledindex(e11)) != 0) + { + idxregs2 = idxregs; + c = cdisscaledindex(e11,&idxregs2,keepmsk); + idxregs = allregs & ~(idxregs2 | keepmsk); + c2 = scodelem(e12,&idxregs,keepmsk | idxregs2,TRUE); + } + // Look for *(((v1 << scale) + c1) + v2) + else if (e11->Eoper == OPadd && !e11->Ecount && + e11->E2->Eoper == OPconst && + (ss = isscaledindex(e11->E1)) != 0 + ) + { + pcs->IEV1.Vuns = e11->E2->EV.Vuns; + idxregs2 = idxregs; + c = cdisscaledindex(e11->E1,&idxregs2,keepmsk); + idxregs = allregs & ~(idxregs2 | keepmsk); + c2 = scodelem(e12,&idxregs,keepmsk | idxregs2,TRUE); + freenode(e11->E2); + freenode(e11); + } + else + { + c = scodelem(e11,&idxregs,keepmsk,TRUE); + idxregs2 = allregs & ~(idxregs | keepmsk); + c2 = scodelem(e12,&idxregs2,keepmsk | idxregs,TRUE); + } + c = cat(c,c2); + base = findreg(idxregs); + index = findreg(idxregs2); + pcs->Irm = modregrm(2,0,4); + pcs->Isib = modregrm(ss,index & 7,base & 7); + if (index & 8) + pcs->Irex |= REX_X; + if (base & 8) + pcs->Irex |= REX_B; + if (e1free) freenode(e1); + goto Lptr; + } + + /* give up and replace *e1 with + * MOV idxreg,e + * EA = 0[idxreg] + * pinholeopt() will usually correct the 0, we need it in case + * we have a pointer to a long and need an offset to the second + * word. + */ + + assert(e1free); + c = scodelem(e1,&idxregs,keepmsk,TRUE); /* load index register */ + setaddrmode(pcs, idxregs); + Lptr: + if (config.flags3 & CFG3ptrchk) + cod3_ptrchk(&c,pcs,keepmsk); // validate pointer code + break; + case FLdatseg: + assert(0); +#if 0 + pcs->Irm = modregrm(0,0,BPRM); + pcs->IEVpointer1 = e->EVpointer; + break; +#endif + case FLfltreg: + reflocal = TRUE; + pcs->Irm = modregrm(2,0,BPRM); + pcs->IEV1.Vint = 0; + break; + case FLreg: + goto L2; + case FLpara: + refparam = TRUE; + pcs->Irm = modregrm(2,0,BPRM); + goto L2; + + case FLauto: + if (s->Sclass == SCfastpar && regcon.params & mask[s->Spreg]) + { + if (keepmsk & RMload) + { + if (sz == REGSIZE) // could this be (sz <= REGSIZE) ? + { + pcs->Irm = modregrm(3,0,s->Spreg & 7); + if (s->Spreg & 8) + pcs->Irex |= REX_B; + regcon.used |= mask[s->Spreg]; + break; + } + } + else + regcon.params &= ~mask[s->Spreg]; + } + case FLtmp: + case FLbprel: + reflocal = TRUE; + pcs->Irm = modregrm(2,0,BPRM); + goto L2; + case FLextern: + if (s->Sident[0] == '_' && memcmp(s->Sident + 1,"tls_array",10) == 0) + { +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + // Rewrite as GS:[0000], or FS:[0000] for 64 bit + if (I64) + { + pcs->Irm = modregrm(0, 0, 4); + pcs->Isib = modregrm(0, 4, 5); // don't use [RIP] addressing + pcs->IFL1 = FLconst; + pcs->IEV1.Vuns = 0; + pcs->Iflags = CFfs; + pcs->Irex |= REX_W; + } + else + { + pcs->Irm = modregrm(0, 0, BPRM); + pcs->IFL1 = FLconst; + pcs->IEV1.Vuns = 0; + pcs->Iflags = CFgs; + } + break; +#else + pcs->Iflags |= CFfs; // add FS: override +#endif + } +#if TARGET_SEGMENTED + if (s->ty() & mTYcs && LARGECODE) + goto Lfardata; +#endif + goto L3; + case FLdata: + case FLudata: +#if TARGET_SEGMENTED + case FLcsdata: +#endif +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case FLgot: + case FLgotoff: + case FLtlsdata: +#endif + L3: + pcs->Irm = modregrm(0,0,BPRM); + L2: + if (fl == FLreg) + { +#ifdef DEBUG + if (!(s->Sregm & regcon.mvar)) symbol_print(s); +#endif + assert(s->Sregm & regcon.mvar); + + /* Attempting to paint a float as an integer or an integer as a float + * will cause serious problems since the EA is loaded separatedly from + * the opcode. The only way to deal with this is to prevent enregistering + * such variables. + */ + if (tyxmmreg(ty) && !(s->Sregm & XMMREGS) || + !tyxmmreg(ty) && (s->Sregm & XMMREGS)) + cgreg_unregister(s->Sregm); + + if ( + s->Sclass == SCregpar || + s->Sclass == SCparameter) + { refparam = TRUE; + reflocal = TRUE; // kludge to set up prolog + } + pcs->Irm = modregrm(3,0,s->Sreglsw & 7); + if (s->Sreglsw & 8) + pcs->Irex |= REX_B; + if (e->EV.sp.Voffset == 1 && sz == 1) + { assert(s->Sregm & BYTEREGS); + assert(s->Sreglsw < 4); + pcs->Irm |= 4; // use 2nd byte of register + } + else + { assert(!e->EV.sp.Voffset); + if (I64 && sz == 1 && s->Sreglsw >= 4) + pcs->Irex |= REX; + } + } +#if TARGET_SEGMENTED + else if (s->ty() & mTYcs && !(fl == FLextern && LARGECODE)) + { + pcs->Iflags |= CFcs | CFoff; + } +#endif +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (I64 && config.flags3 & CFG3pic && + (fl == FLtlsdata || s->ty() & mTYthread)) + { + pcs->Iflags |= CFopsize; + pcs->Irex = 0x48; + } +#endif + pcs->IEVsym1 = s; + pcs->IEVoffset1 = e->EV.sp.Voffset; + if (sz == 1) + { /* Don't use SI or DI for this variable */ + s->Sflags |= GTbyte; + if (e->EV.sp.Voffset > 1) + s->Sflags &= ~GTregcand; + } + else if (e->EV.sp.Voffset) + s->Sflags &= ~GTregcand; + if (!(keepmsk & RMstore)) // if not store only + { s->Sflags |= SFLread; // assume we are doing a read + } + break; + case FLpseudo: +#if MARS + assert(0); +#else + { + unsigned u = s->Sreglsw; + c = getregs(pseudomask[u]); + pcs->Irm = modregrm(3,0,pseudoreg[u] & 7); + break; + } +#endif +#if TARGET_SEGMENTED + case FLfardata: +#endif + case FLfunc: /* reading from code seg */ + if (config.exe & EX_flat) + goto L3; + Lfardata: + { + regm_t regm = ALLREGS & ~keepmsk; // need scratch register + code *c1 = allocreg(®m,®,TYint); + /* MOV mreg,seg of symbol */ + c = gencs(CNIL,0xB8 + reg,0,FLextern,s); + c->Iflags = CFseg; + c = gen2(c,0x8E,modregrmx(3,0,reg)); /* MOV ES,reg */ + c = cat3(c1,getregs(mES),c); + pcs->Iflags |= CFes | CFoff; /* ES segment override */ + goto L3; + } + + case FLstack: + assert(!I16); + pcs->Irm = modregrm(2,0,4); + pcs->Isib = modregrm(0,4,SP); + pcs->IEVsym1 = s; + pcs->IEVoffset1 = e->EV.sp.Voffset; + break; + + default: +#ifdef DEBUG + WRFL((enum FL)fl); + symbol_print(s); +#endif + assert(0); + } + return c; +} + +/***************************** + * Given an opcode and EA in cs, generate code + * for each floating register in turn. + * Input: + * tym either TYdouble or TYfloat + */ + +code *fltregs(code *pcs,tym_t tym) +{ code *c; + + assert(!I64); + tym = tybasic(tym); + if (I32) + { + c = getregs((tym == TYfloat) ? mAX : mAX | mDX); + if (tym != TYfloat) + { + pcs->IEVoffset1 += REGSIZE; + NEWREG(pcs->Irm,DX); + c = gen(c,pcs); + pcs->IEVoffset1 -= REGSIZE; + } + NEWREG(pcs->Irm,AX); + c = gen(c,pcs); + } + else + { + c = getregs((tym == TYfloat) ? FLOATREGS_16 : DOUBLEREGS_16); + pcs->IEVoffset1 += (tym == TYfloat) ? 2 : 6; + if (tym == TYfloat) + NEWREG(pcs->Irm,DX); + else + NEWREG(pcs->Irm,AX); + c = gen(c,pcs); + pcs->IEVoffset1 -= 2; + if (tym == TYfloat) + NEWREG(pcs->Irm,AX); + else + NEWREG(pcs->Irm,BX); + gen(c,pcs); + if (tym != TYfloat) + { pcs->IEVoffset1 -= 2; + NEWREG(pcs->Irm,CX); + gen(c,pcs); + pcs->IEVoffset1 -= 2; /* note that exit is with Voffset unaltered */ + NEWREG(pcs->Irm,DX); + gen(c,pcs); + } + } + return c; +} + + +/***************************** + * Given a result in registers, test it for TRUE or FALSE. + * Will fail if TYfptr and the reg is ES! + * If saveflag is TRUE, preserve the contents of the + * registers. + */ + +code *tstresult(regm_t regm,tym_t tym,unsigned saveflag) +{ + unsigned scrreg; /* scratch register */ + regm_t scrregm; + +#ifdef DEBUG + //if (!(regm & (mBP | ALLREGS))) + // printf("tstresult(regm = %s, tym = x%x, saveflag = %d)\n", + // regm_str(regm),tym,saveflag); +#endif + assert(regm & (XMMREGS | mBP | ALLREGS)); + tym = tybasic(tym); + code *ce = CNIL; + unsigned reg = findreg(regm); + unsigned sz = tysize[tym]; + if (sz == 1) + { assert(regm & BYTEREGS); + ce = genregs(ce,0x84,reg,reg); // TEST regL,regL + if (I64 && reg >= 4) + code_orrex(ce, REX); + return ce; + } + if (regm & XMMREGS) + { + unsigned xreg; + regm_t xregs = XMMREGS & ~regm; + ce = allocreg(&xregs, &xreg, TYdouble); + unsigned op = 0; + if (tym == TYdouble || tym == TYidouble || tym == TYcdouble) + op = 0x660000; + ce = gen2(ce,op | 0x0F57,modregrm(3,xreg-XMM0,xreg-XMM0)); // XORPS xreg,xreg + gen2(ce,op | 0x0F2E,modregrm(3,xreg-XMM0,reg-XMM0)); // UCOMISS xreg,reg + if (tym == TYcfloat || tym == TYcdouble) + { code *cnop = gennop(CNIL); + genjmp(ce,JNE,FLcode,(block *) cnop); // JNE L1 + genjmp(ce,JP, FLcode,(block *) cnop); // JP L1 + reg = findreg(regm & ~mask[reg]); + gen2(ce,op | 0x0F2E,modregrm(3,xreg-XMM0,reg-XMM0)); // UCOMISS xreg,reg + ce = cat(ce, cnop); + } + return ce; + } + if (sz <= REGSIZE) + { + if (!I16) + { + if (tym == TYfloat) + { if (saveflag) + { + scrregm = allregs & ~regm; /* possible scratch regs */ + ce = allocreg(&scrregm,&scrreg,TYoffset); /* allocate scratch reg */ + ce = genmovreg(ce,scrreg,reg); /* MOV scrreg,msreg */ + reg = scrreg; + } + ce = cat(ce,getregs(mask[reg])); + return gen2(ce,0xD1,modregrmx(3,4,reg)); // SHL reg,1 + } + ce = gentstreg(ce,reg); // TEST reg,reg + if (sz == SHORTSIZE) + ce->Iflags |= CFopsize; /* 16 bit operands */ + else if (sz == 8) + code_orrex(ce, REX_W); + } + else + ce = gentstreg(ce,reg); // TEST reg,reg + return ce; + } + if (saveflag || tyfv(tym)) + { + scrregm = ALLREGS & ~regm; /* possible scratch regs */ + ce = allocreg(&scrregm,&scrreg,TYoffset); /* allocate scratch reg */ + if (I32 || sz == REGSIZE * 2) + { code *c; + + assert(regm & mMSW && regm & mLSW); + + reg = findregmsw(regm); + if (I32) + { + if (tyfv(tym)) + { c = genregs(CNIL,0x0FB7,scrreg,reg); // MOVZX scrreg,msreg + ce = cat(ce,c); + } + else + { ce = genmovreg(ce,scrreg,reg); /* MOV scrreg,msreg */ + if (tym == TYdouble || tym == TYdouble_alias) + gen2(ce,0xD1,modregrm(3,4,scrreg)); /* SHL scrreg,1 */ + } + } + else + { + ce = genmovreg(ce,scrreg,reg); /* MOV scrreg,msreg */ + if (tym == TYfloat) + gen2(ce,0xD1,modregrm(3,4,scrreg)); /* SHL scrreg,1 */ + } + reg = findreglsw(regm); + genorreg(ce,scrreg,reg); /* OR scrreg,lsreg */ + } + else if (sz == 8) + { /* !I32 */ + ce = genmovreg(ce,scrreg,AX); /* MOV scrreg,AX */ + if (tym == TYdouble || tym == TYdouble_alias) + gen2(ce,0xD1,modregrm(3,4,scrreg)); // SHL scrreg,1 + genorreg(ce,scrreg,BX); /* OR scrreg,BX */ + genorreg(ce,scrreg,CX); /* OR scrreg,CX */ + genorreg(ce,scrreg,DX); /* OR scrreg,DX */ + } + else + assert(0); + } + else + { + if (I32 || sz == REGSIZE * 2) + { + /* can't test ES:LSW for 0 */ + assert(regm & mMSW & ALLREGS && regm & (mLSW | mBP)); + + reg = findregmsw(regm); + ce = getregs(mask[reg]); /* we're going to trash reg */ + if (tyfloating(tym) && sz == 2 * intsize) + ce = gen2(ce,0xD1,modregrm(3,4,reg)); // SHL reg,1 + ce = genorreg(ce,reg,findreglsw(regm)); // OR reg,reg+1 + if (I64) + code_orrex(ce, REX_W); + } + else if (sz == 8) + { assert(regm == DOUBLEREGS_16); + ce = getregs(mAX); // allocate AX + if (tym == TYdouble || tym == TYdouble_alias) + ce = gen2(ce,0xD1,modregrm(3,4,AX)); // SHL AX,1 + genorreg(ce,AX,BX); // OR AX,BX + genorreg(ce,AX,CX); // OR AX,CX + genorreg(ce,AX,DX); // OR AX,DX + } + else + assert(0); + } + code_orflag(ce,CFpsw); + return ce; +} + + +/****************************** + * Given the result of an expression is in retregs, + * generate necessary code to return result in *pretregs. + */ + +code *fixresult(elem *e,regm_t retregs,regm_t *pretregs) +{ code *c,*ce; + unsigned reg,rreg; + regm_t forccs,forregs; + tym_t tym; + int sz; + + //printf("fixresult(e = %p, retregs = %s, *pretregs = %s)\n",e,regm_str(retregs),regm_str(*pretregs)); + if (*pretregs == 0) return CNIL; /* if don't want result */ + assert(e && retregs); /* need something to work with */ + forccs = *pretregs & mPSW; + forregs = *pretregs & (mST01 | mST0 | mBP | ALLREGS | mES | mSTACK | XMMREGS); + tym = tybasic(e->Ety); +#if TARGET_SEGMENTED + if (tym == TYstruct) + // Hack to support cdstreq() + tym = (forregs & mMSW) ? TYfptr : TYnptr; +#else + if (tym == TYstruct) + { + // Hack to support cdstreq() + assert(!(forregs & mMSW)); + tym = TYnptr; + } +#endif + c = CNIL; + sz = tysize[tym]; + if (sz == 1) + { + assert(retregs & BYTEREGS); + unsigned reg = findreg(retregs); + if (e->Eoper == OPvar && + e->EV.sp.Voffset == 1 && + e->EV.sp.Vsym->Sfl == FLreg) + { + assert(reg < 4); + if (forccs) + c = gen2(c,0x84,modregrm(3,reg | 4,reg | 4)); // TEST regH,regH + forccs = 0; + } + } + if ((retregs & forregs) == retregs) /* if already in right registers */ + *pretregs = retregs; + else if (forregs) /* if return the result in registers */ + { + if (forregs & (mST01 | mST0)) + return fixresult87(e,retregs,pretregs); + ce = CNIL; + unsigned opsflag = FALSE; + if (I16 && sz == 8) + { if (forregs & mSTACK) + { assert(retregs == DOUBLEREGS_16); + /* Push floating regs */ + c = CNIL; + ce = gen1(ce,0x50 + AX); + gen1(ce,0x50 + BX); + gen1(ce,0x50 + CX); + gen1(ce,0x50 + DX); + stackpush += DOUBLESIZE; + } + else if (retregs & mSTACK) + { assert(forregs == DOUBLEREGS_16); + /* Pop floating regs */ + c = getregs(forregs); + ce = gen1(ce,0x58 + DX); + gen1(ce,0x58 + CX); + gen1(ce,0x58 + BX); + gen1(ce,0x58 + AX); + stackpush -= DOUBLESIZE; + retregs = DOUBLEREGS_16; /* for tstresult() below */ + } + else +#ifdef DEBUG + printf("retregs = x%x, forregs = x%x\n",retregs,forregs), +#endif + assert(0); + if (EOP(e)) + opsflag = TRUE; + } + else + { + c = allocreg(pretregs,&rreg,tym); /* allocate return regs */ + if (retregs & XMMREGS) + { + reg = findreg(retregs & XMMREGS); + // MOVSD floatreg, XMM? + ce = genfltreg(ce,xmmstore(tym),reg - XMM0,0); + if (mask[rreg] & XMMREGS) + // MOVSD XMM?, floatreg + ce = genfltreg(ce,xmmload(tym),rreg - XMM0,0); + else + { + // MOV rreg,floatreg + ce = genfltreg(ce,0x8B,rreg,0); + if (sz == 8) + { + if (I32) + { + rreg = findregmsw(*pretregs); + ce = genfltreg(ce,0x8B,rreg,4); + } + else + code_orrex(ce,REX_W); + } + } + } + else if (forregs & XMMREGS) + { + reg = findreg(retregs & (mBP | ALLREGS)); + // MOV floatreg,reg + ce = genfltreg(ce,0x89,reg,0); + if (sz == 8) + { + if (I32) + { + reg = findregmsw(retregs); + ce = genfltreg(ce,0x89,reg,4); + } + else + code_orrex(ce,REX_W); + } + // MOVSS/MOVSD XMMreg,floatreg + ce = genfltreg(ce,xmmload(tym),rreg - XMM0,0); + } + else if (sz > REGSIZE) + { + unsigned msreg = findregmsw(retregs); + unsigned lsreg = findreglsw(retregs); + unsigned msrreg = findregmsw(*pretregs); + unsigned lsrreg = findreglsw(*pretregs); + + ce = genmovreg(ce,msrreg,msreg); /* MOV msrreg,msreg */ + ce = genmovreg(ce,lsrreg,lsreg); /* MOV lsrreg,lsreg */ + } + else + { + assert(!(retregs & XMMREGS)); + assert(!(forregs & XMMREGS)); + reg = findreg(retregs & (mBP | ALLREGS)); + ce = genmovreg(ce,rreg,reg); /* MOV rreg,reg */ + } + } + c = cat(c,ce); + cssave(e,retregs | *pretregs,opsflag); + forregs = 0; /* don't care about result in reg */ + /* cuz we have real result in rreg */ + retregs = *pretregs & ~mPSW; + } + if (forccs) /* if return result in flags */ + c = cat(c,tstresult(retregs,tym,forregs)); + return c; +} + + +/******************************** + * Generate code sequence to call C runtime library support routine. + * clib = CLIBxxxx + * keepmask = mask of registers not to destroy. Currently can + * handle only 1. Should use a temporary rather than + * push/pop for speed. + */ + +int clib_inited = 0; // != 0 if initialized + +code *callclib(elem *e,unsigned clib,regm_t *pretregs,regm_t keepmask) +{ + //printf("callclib(e = %p, clib = %d, *pretregs = %s, keepmask = %s\n", e, clib, regm_str(*pretregs), regm_str(keepmask)); + //elem_print(e); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + static symbol lib[] = + { +/* Convert destroyed regs into saved regs */ +#define Z(desregs) (~(desregs) & (mBP| mES | ALLREGS)) +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define N(name) "_" name +#else +#define N(name) name +#endif + +/* Shorthand to map onto SYMBOLY() */ +#define Y(desregs,name) SYMBOLY(FLfunc,Z(desregs),N(name),0) + + Y(0,"_LCMP__"), // CLIBlcmp + Y(mAX|mCX|mDX,"_LMUL__"), // CLIBlmul +#if 1 + Y(mAX|mBX|mCX|mDX,"_LDIV__"), // CLIBldiv + Y(mAX|mBX|mCX|mDX,"_LDIV__"), // CLIBlmod + Y(mAX|mBX|mCX|mDX,"_ULDIV__"), // CLIBuldiv + Y(mAX|mBX|mCX|mDX,"_ULDIV__"), // CLIBulmod +#else + Y(ALLREGS,"_LDIV__"), // CLIBldiv + Y(ALLREGS,"_LDIV__"), // CLIBlmod + Y(ALLREGS,"_ULDIV__"), // CLIBuldiv + Y(ALLREGS,"_ULDIV__"), // CLIBulmod +#endif +#if 0 + Y(DOUBLEREGS_16,"_DNEG"), + Y(mAX|mBX|mCX|mDX,"_DMUL"), // CLIBdmul + Y(mAX|mBX|mCX|mDX,"_DDIV"), // CLIBddiv + Y(0,"_DTST0"), // CLIBdtst0 + Y(0,"_DTST0EXC"), // CLIBdtst0exc + Y(0,"_DCMP"), // CLIBdcmp + Y(0,"_DCMPEXC"), // CLIBdcmpexc + + Y(mAX|mBX|mCX|mDX,"_DADD"), // CLIBdadd + Y(mAX|mBX|mCX|mDX,"_DSUB"), // CLIBdsub + + Y(mAX|mBX|mCX|mDX,"_FMUL"), // CLIBfmul + Y(mAX|mBX|mCX|mDX,"_FDIV"), // CLIBfdiv + Y(0,"_FTST0"), // CLIBftst0 + Y(0,"_FTST0EXC"), // CLIBftst0exc + Y(0,"_FCMP"), // CLIBfcmp + Y(0,"_FCMPEXC"), // CLIBfcmpexc + Y(FLOATREGS_32,"_FNEG"), // CLIBfneg + Y(mAX|mBX|mCX|mDX,"_FADD"), // CLIBfadd + Y(mAX|mBX|mCX|mDX,"_FSUB"), // CLIBfsub +#endif + Y(DOUBLEREGS_32,"_DBLLNG"), // CLIBdbllng + Y(DOUBLEREGS_32,"_LNGDBL"), // CLIBlngdbl + Y(DOUBLEREGS_32,"_DBLINT"), // CLIBdblint + Y(DOUBLEREGS_32,"_INTDBL"), // CLIBintdbl + Y(DOUBLEREGS_32,"_DBLUNS"), // CLIBdbluns + Y(DOUBLEREGS_32,"_UNSDBL"), // CLIBunsdbl + Y(mAX|mST0,"_DBLULNG"), // CLIBdblulng +#if 0 + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _ULNGDBL@ ulngdbl +#endif + Y(DOUBLEREGS_32,"_DBLFLT"), // CLIBdblflt + Y(DOUBLEREGS_32,"_FLTDBL"), // CLIBfltdbl + + Y(DOUBLEREGS_32,"_DBLLLNG"), // CLIBdblllng + Y(DOUBLEREGS_32,"_LLNGDBL"), // CLIBllngdbl + Y(DOUBLEREGS_32,"_DBLULLNG"), // CLIBdblullng + Y(DOUBLEREGS_32,"_ULLNGDBL"), // CLIBullngdbl + + Y(0,"_DTST"), // CLIBdtst + Y(mES|mBX,"_HTOFPTR"), // CLIBvptrfptr + Y(mES|mBX,"_HCTOFPTR"), // CLIBcvptrfptr + Y(0,"_87TOPSW"), // CLIB87topsw + Y(mST0,"_FLTTO87"), // CLIBfltto87 + Y(mST0,"_DBLTO87"), // CLIBdblto87 + Y(mST0|mAX,"_DBLINT87"), // CLIBdblint87 + Y(mST0|mAX|mDX,"_DBLLNG87"), // CLIBdbllng87 + Y(0,"_FTST"), // CLIBftst + Y(0,"_FCOMPP"), // CLIBfcompp + Y(0,"_FTEST"), // CLIBftest + Y(0,"_FTEST0"), // CLIBftest0 + Y(mST0|mAX|mBX|mCX|mDX,"_FDIVP"), // CLIBfdiv87 + + Y(mST0|mST01,"Cmul"), // CLIBcmul + Y(mAX|mCX|mDX|mST0|mST01,"Cdiv"), // CLIBcdiv + Y(mAX|mST0|mST01,"Ccmp"), // CLIBccmp + + Y(mST0,"_U64_LDBL"), // CLIBu64_ldbl +#if ELFOBJ || MACHOBJ + Y(mST0|mAX|mDX,"_LDBLULLNG"), // CLIBld_u64 +#else + Y(mST0|mAX|mDX,"__LDBLULLNG"), // CLIBld_u64 +#endif + }; +#else + static symbol lib[CLIBMAX] = + { +/* Convert destroyed regs into saved regs */ +#define Z(desregs) (~(desregs) & (mBP| mES | ALLREGS)) + +/* Shorthand to map onto SYMBOLY() */ +#define Y(desregs,name) SYMBOLY(FLfunc,Z(desregs),name,0) + + Y(0,"_LCMP@"), + Y(mAX|mCX|mDX,"_LMUL@"), + Y(ALLREGS,"_LDIV@"), + Y(ALLREGS,"_LDIV@"), + Y(ALLREGS,"_ULDIV@"), + Y(ALLREGS,"_ULDIV@"), + Y(mAX|mBX|mCX|mDX,"_DMUL@"), + Y(mAX|mBX|mCX|mDX,"_DDIV@"), + Y(0,"_DTST0@"), + Y(0,"_DTST0EXC@"), + Y(0,"_DCMP@"), + Y(0,"_DCMPEXC@"), + + /* _DNEG@ only really destroys EDX, but then EAX would hold */ + /* 2 values, and we can't handle that. */ + + /* _DNEG@ only really destroys AX, but then BX,CX,DX would hold */ + /* 2 values, and we can't handle that. */ + + Y(DOUBLEREGS_16,"_DNEG@"), + Y(mAX|mBX|mCX|mDX,"_DADD@"), + Y(mAX|mBX|mCX|mDX,"_DSUB@"), + + Y(mAX|mBX|mCX|mDX,"_FMUL@"), + Y(mAX|mBX|mCX|mDX,"_FDIV@"), + Y(0,"_FTST0@"), + Y(0,"_FTST0EXC@"), + Y(0,"_FCMP@"), + Y(0,"_FCMPEXC@"), + Y(FLOATREGS_16,"_FNEG@"), + Y(mAX|mBX|mCX|mDX,"_FADD@"), + Y(mAX|mBX|mCX|mDX,"_FSUB@"), + Y(DOUBLEREGS_16,"_DBLLNG@"), + Y(DOUBLEREGS_16,"_LNGDBL@"), + Y(DOUBLEREGS_16,"_DBLINT@"), + Y(DOUBLEREGS_16,"_INTDBL@"), + Y(DOUBLEREGS_16,"_DBLUNS@"), + Y(DOUBLEREGS_16,"_UNSDBL@"), + Y(DOUBLEREGS_16,"_DBLULNG@"), + Y(DOUBLEREGS_16,"_ULNGDBL@"), + Y(DOUBLEREGS_16,"_DBLFLT@"), + Y(ALLREGS,"_FLTDBL@"), + + Y(DOUBLEREGS_16,"_DBLLLNG@"), + Y(DOUBLEREGS_16,"_LLNGDBL@"), +#if 0 + Y(DOUBLEREGS_16,"__DBLULLNG"), +#else + Y(DOUBLEREGS_16,"_DBLULLNG@"), +#endif + Y(DOUBLEREGS_16,"_ULLNGDBL@"), + + Y(0,"_DTST@"), + Y(mES|mBX,"_HTOFPTR@"), // CLIBvptrfptr + Y(mES|mBX,"_HCTOFPTR@"), // CLIBcvptrfptr + Y(0,"_87TOPSW@"), // CLIB87topsw + Y(mST0,"_FLTTO87@"), // CLIBfltto87 + Y(mST0,"_DBLTO87@"), // CLIBdblto87 + Y(mST0|mAX,"_DBLINT87@"), // CLIBdblint87 + Y(mST0|mAX|mDX,"_DBLLNG87@"), // CLIBdbllng87 + Y(0,"_FTST@"), + Y(0,"_FCOMPP@"), // CLIBfcompp + Y(0,"_FTEST@"), // CLIBftest + Y(0,"_FTEST0@"), // CLIBftest0 + Y(mST0|mAX|mBX|mCX|mDX,"_FDIVP"), // CLIBfdiv87 + + // NOTE: desregs is wrong for 16 bit code, mBX should be included + Y(mST0|mST01,"_Cmul"), // CLIBcmul + Y(mAX|mCX|mDX|mST0|mST01,"_Cdiv"), // CLIBcdiv + Y(mAX|mST0|mST01,"_Ccmp"), // CLIBccmp + + Y(mST0,"_U64_LDBL"), // CLIBu64_ldbl + Y(mST0|mAX|mDX,"__LDBLULLNG"), // CLIBld_u64 + }; +#endif + + static struct + { + regm_t retregs16; /* registers that 16 bit result is returned in */ + regm_t retregs32; /* registers that 32 bit result is returned in */ + char pop; /* # of bytes popped off of stack upon return */ + char flags; + #define INF32 1 // if 32 bit only + #define INFfloat 2 // if this is floating point + #define INFwkdone 4 // if weak extern is already done + #define INF64 8 // if 64 bit only + char push87; // # of pushes onto the 8087 stack + char pop87; // # of pops off of the 8087 stack + } info[CLIBMAX] = + { + {0,0,0,0}, /* _LCMP@ lcmp */ + {mDX|mAX,mDX|mAX,0,0}, // _LMUL@ lmul + {mDX|mAX,mDX|mAX,0,0}, // _LDIV@ ldiv + {mCX|mBX,mCX|mBX,0,0}, /* _LDIV@ lmod */ + {mDX|mAX,mDX|mAX,0,0}, /* _ULDIV@ uldiv */ + {mCX|mBX,mCX|mBX,0,0}, /* _ULDIV@ ulmod */ + +#if TARGET_WINDOS + {DOUBLEREGS_16,DOUBLEREGS_32,8,INFfloat,1,1}, // _DMUL@ dmul + {DOUBLEREGS_16,DOUBLEREGS_32,8,INFfloat,1,1}, // _DDIV@ ddiv + {0,0,0,2}, // _DTST0@ + {0,0,0,2}, // _DTST0EXC@ + {0,0,8,INFfloat,1,1}, // _DCMP@ dcmp + {0,0,8,INFfloat,1,1}, // _DCMPEXC@ dcmp + {DOUBLEREGS_16,DOUBLEREGS_32,0,2}, // _DNEG@ dneg + {DOUBLEREGS_16,DOUBLEREGS_32,8,INFfloat,1,1}, // _DADD@ dadd + {DOUBLEREGS_16,DOUBLEREGS_32,8,INFfloat,1,1}, // _DSUB@ dsub + + {FLOATREGS_16,FLOATREGS_32,0,INFfloat,1,1}, // _FMUL@ fmul + {FLOATREGS_16,FLOATREGS_32,0,INFfloat,1,1}, // _FDIV@ fdiv + {0,0,0,2}, // _FTST0@ + {0,0,0,2}, // _FTST0EXC@ + {0,0,0,INFfloat,1,1}, // _FCMP@ fcmp + {0,0,0,INFfloat,1,1}, // _FCMPEXC@ fcmp + {FLOATREGS_16,FLOATREGS_32,0,2}, // _FNEG@ fneg + {FLOATREGS_16,FLOATREGS_32,0,INFfloat,1,1}, // _FADD@ fadd + {FLOATREGS_16,FLOATREGS_32,0,INFfloat,1,1}, // _FSUB@ fsub +#endif + + {mDX|mAX,mAX,0,INFfloat,1,1}, // _DBLLNG@ dbllng + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _LNGDBL@ lngdbl + {mAX,mAX,0,INFfloat,1,1}, // _DBLINT@ dblint + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _INTDBL@ intdbl + {mAX,mAX,0,INFfloat,1,1}, // _DBLUNS@ dbluns + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _UNSDBL@ unsdbl +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + {mDX|mAX,mAX,0,INF32|INFfloat,0,1}, // _DBLULNG@ dblulng +#else + {mDX|mAX,mAX,0,INFfloat,1,1}, // _DBLULNG@ dblulng +#endif +#if TARGET_WINDOS + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _ULNGDBL@ ulngdbl +#endif + {FLOATREGS_16,FLOATREGS_32,0,INFfloat,1,1}, // _DBLFLT@ dblflt + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _FLTDBL@ fltdbl + + {DOUBLEREGS_16,mDX|mAX,0,INFfloat,1,1}, // _DBLLLNG@ + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _LLNGDBL@ +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + {DOUBLEREGS_16,mDX|mAX,0,INFfloat,2,2}, // _DBLULLNG@ +#else + {DOUBLEREGS_16,mDX|mAX,0,INFfloat,1,1}, // _DBLULLNG@ +#endif + {DOUBLEREGS_16,DOUBLEREGS_32,0,INFfloat,1,1}, // _ULLNGDBL@ + + {0,0,0,2}, // _DTST@ dtst + {mES|mBX,mES|mBX,0,0}, // _HTOFPTR@ vptrfptr + {mES|mBX,mES|mBX,0,0}, // _HCTOFPTR@ cvptrfptr + {0,0,0,2}, // _87TOPSW@ 87topsw + {mST0,mST0,0,INFfloat,1,0}, // _FLTTO87@ fltto87 + {mST0,mST0,0,INFfloat,1,0}, // _DBLTO87@ dblto87 + {mAX,mAX,0,2}, // _DBLINT87@ dblint87 + {mDX|mAX,mAX,0,2}, // _DBLLNG87@ dbllng87 + {0,0,0,2}, // _FTST@ + {mPSW,mPSW,0,INFfloat,0,2}, // _FCOMPP@ + {mPSW,mPSW,0,2}, // _FTEST@ + {mPSW,mPSW,0,2}, // _FTEST0@ + {mST0,mST0,0,INFfloat,1,1}, // _FDIV@ + + {mST01,mST01,0,INF32|INFfloat,3,5}, // _Cmul + {mST01,mST01,0,INF32|INFfloat,0,2}, // _Cdiv + {mPSW, mPSW, 0,INF32|INFfloat,0,4}, // _Ccmp + + {mST0,mST0,0,INF32|INF64|INFfloat,2,1}, // _U64_LDBL + {0,mDX|mAX,0,INF32|INF64|INFfloat,1,2}, // __LDBLULLNG + }; + + if (!clib_inited) /* if not initialized */ + { + assert(sizeof(lib) / sizeof(lib[0]) == CLIBMAX); + assert(sizeof(info) / sizeof(info[0]) == CLIBMAX); + for (int i = 0; i < CLIBMAX; i++) + { lib[i].Stype = tsclib; +#if MARS + lib[i].Sxtrnnum = 0; + lib[i].Stypidx = 0; +#endif + } + + if (!I16) + { /* Adjust table for 386 */ + lib[CLIBdbllng].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBlngdbl].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBdblint].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBintdbl].Sregsaved = Z(DOUBLEREGS_32); +#if TARGET_WINDOS + lib[CLIBfneg].Sregsaved = Z(FLOATREGS_32); + lib[CLIBdneg].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBdbluns].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBunsdbl].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBdblulng].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBulngdbl].Sregsaved = Z(DOUBLEREGS_32); +#endif + lib[CLIBdblflt].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBfltdbl].Sregsaved = Z(DOUBLEREGS_32); + + lib[CLIBdblllng].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBllngdbl].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBdblullng].Sregsaved = Z(DOUBLEREGS_32); + lib[CLIBullngdbl].Sregsaved = Z(DOUBLEREGS_32); + + if (I64) + { + info[CLIBullngdbl].retregs32 = mAX; + info[CLIBdblullng].retregs32 = mAX; + } + } + clib_inited++; + } +#undef Z + + assert(clib < CLIBMAX); + symbol *s = &lib[clib]; + if (I16) + assert(!(info[clib].flags & (INF32 | INF64))); + code *cpop = CNIL; + code *c = getregs((~s->Sregsaved & (mES | mBP | ALLREGS)) & ~keepmask); // mask of regs destroyed + keepmask &= ~s->Sregsaved; + int npushed = numbitsset(keepmask); + gensaverestore2(keepmask, &c, &cpop); +#if 0 + while (keepmask) + { unsigned keepreg; + + if (keepmask & (mBP|ALLREGS)) + { keepreg = findreg(keepmask & (mBP|ALLREGS)); + c = gen1(c,0x50 + keepreg); /* PUSH keepreg */ + cpop = cat(gen1(CNIL,0x58 + keepreg),cpop); // POP keepreg + keepmask &= ~mask[keepreg]; + npushed++; + } + if (keepmask & mES) + { c = gen1(c,0x06); /* PUSH ES */ + cpop = cat(gen1(CNIL,0x07),cpop); /* POP ES */ + keepmask &= ~mES; + npushed++; + } + } +#endif + + c = cat(c, save87regs(info[clib].push87)); + for (int i = 0; i < info[clib].push87; i++) + c = cat(c, push87()); + + for (int i = 0; i < info[clib].pop87; i++) + pop87(); + + if (config.target_cpu >= TARGET_80386 && clib == CLIBlmul && !I32) + { static char lmul[] = { + 0x66,0xc1,0xe1,0x10, // shl ECX,16 + 0x8b,0xcb, // mov CX,BX ;ECX = CX,BX + 0x66,0xc1,0xe0,0x10, // shl EAX,16 + 0x66,0x0f,0xac,0xd0,0x10, // shrd EAX,EDX,16 ;EAX = DX,AX + 0x66,0xf7,0xe1, // mul ECX + 0x66,0x0f,0xa4,0xc2,0x10, // shld EDX,EAX,16 ;DX,AX = EAX + }; + + c = genasm(c,lmul,sizeof(lmul)); + } + else + { makeitextern(s); + int nalign = 0; + if (STACKALIGN == 16) + { // Align the stack (assume no args on stack) + int npush = npushed * REGSIZE + stackpush; + if (npush & (STACKALIGN - 1)) + { nalign = STACKALIGN - (npush & (STACKALIGN - 1)); + c = genc2(c,0x81,modregrm(3,5,SP),nalign); // SUB ESP,nalign + if (I64) + code_orrex(c, REX_W); + } + } + c = gencs(c,(LARGECODE) ? 0x9A : 0xE8,0,FLfunc,s); // CALL s + if (nalign) + { c = genc2(c,0x81,modregrm(3,0,SP),nalign); // ADD ESP,nalign + if (I64) + code_orrex(c, REX_W); + } + calledafunc = 1; + + if (I16 && // bug in Optlink for weak references + config.flags3 & CFG3wkfloat && + (info[clib].flags & (INFfloat | INFwkdone)) == INFfloat) + { info[clib].flags |= INFwkdone; + makeitextern(rtlsym[RTLSYM_INTONLY]); + obj_wkext(s,rtlsym[RTLSYM_INTONLY]); + } + } + if (I16) + stackpush -= info[clib].pop; + regm_t retregs = I16 ? info[clib].retregs16 : info[clib].retregs32; + return cat(cat(c,cpop),fixresult(e,retregs,pretregs)); +} + +/************************************************* + * Helper function for converting OPparam's into array of Parameters. + */ +struct Parameter { elem *e; int reg; unsigned numalign; }; + +void fillParameters(elem *e, Parameter *parameters, int *pi) +{ + if (e->Eoper == OPparam) + { + fillParameters(e->E1, parameters, pi); + fillParameters(e->E2, parameters, pi); + freenode(e); + } + else + { + parameters[*pi].e = e; + (*pi)++; + } +} + + +/******************************* + * Generate code sequence for function call. + */ + +code *cdfunc(elem *e,regm_t *pretregs) +{ unsigned numpara = 0; + unsigned stackpushsave; + unsigned preg; + regm_t keepmsk; + unsigned numalign = 0; + code *c; + + //printf("cdfunc()\n"); elem_print(e); + assert(e); + stackpushsave = stackpush; /* so we can compute # of parameters */ + cgstate.stackclean++; + c = CNIL; + keepmsk = 0; + if (OTbinary(e->Eoper)) // if parameters + { + if (I16) + { + c = cat(c, params(e->E2,2)); // push parameters + } + else if (I32) + { + unsigned stackalign = REGSIZE; + tym_t tyf = tybasic(e->E1->Ety); + + // First compute numpara, the total bytes pushed on the stack + switch (tyf) + { +#if TARGET_SEGMENTED + case TYf16func: + stackalign = 2; + goto Ldefault; +#endif + case TYmfunc: + case TYjfunc: + // last parameter goes into register + elem *ep; + for (ep = e->E2; ep->Eoper == OPparam; ep = ep->E2) + { + numpara += paramsize(ep->E1,stackalign); + } + unsigned sz; + if (tyf == TYjfunc && + // This must match type_jparam() + !(tyjparam(ep->Ety) || + ((tybasic(ep->Ety) == TYstruct || tybasic(ep->Ety) == TYarray) && + (sz = type_size(ep->ET)) <= intsize && sz != 3 && sz) + ) + ) + { + numpara += paramsize(ep,stackalign); + } + break; + default: + Ldefault: + numpara += paramsize(e->E2,stackalign); + break; + } + assert((numpara & (REGSIZE - 1)) == 0); + assert((stackpush & (REGSIZE - 1)) == 0); + + /* Special handling for call to __tls_get_addr, we must save registers + * before evaluating the parameter, so that the parameter load and call + * are adjacent. + */ + if (e->E2->Eoper != OPparam && e->E1->Eoper == OPvar) + { symbol *s = e->E1->EV.sp.Vsym; + if (s == tls_get_addr_sym) + c = getregs(~s->Sregsaved & (mBP | ALLREGS | mES | XMMREGS)); + } + + + /* Adjust start of the stack so after all args are pushed, + * the stack will be aligned. + */ + if (STACKALIGN == 16 && (numpara + stackpush) & (STACKALIGN - 1)) + { + numalign = STACKALIGN - ((numpara + stackpush) & (STACKALIGN - 1)); + c = genc2(c,0x81,modregrm(3,5,SP),numalign); // SUB ESP,numalign + if (I64) + code_orrex(c, REX_W); + c = genadjesp(c, numalign); + stackpush += numalign; + stackpushsave += numalign; + } + + switch (tyf) + { +#if TARGET_SEGMENTED + case TYf16func: + stackalign = 2; + goto Ldefault2; +#endif + case TYmfunc: // last parameter goes into ECX + preg = CX; + goto L1; + case TYjfunc: // last parameter goes into EAX + preg = AX; + goto L1; + L1: + { elem *ep; + elem *en; + for (ep = e->E2; ep->Eoper == OPparam; ep = en) + { + c = cat(c,params(ep->E1,stackalign)); + en = ep->E2; + freenode(ep); + } + unsigned sz; + if (tyf == TYjfunc && + // This must match type_jparam() + !(tyjparam(ep->Ety) || + ((tybasic(ep->Ety) == TYstruct || tybasic(ep->Ety) == TYarray) && + (sz = type_size(ep->ET)) <= intsize && sz != 3 && sz) + ) + ) + { + c = cat(c,params(ep,stackalign)); + goto Lret; + } + // preg is the register to put the parameter ep in + keepmsk = mask[preg]; // don't change preg when evaluating func address + regm_t retregs = keepmsk; + if (ep->Eoper == OPstrthis) + { code *c2; + + code *c1 = getregs(retregs); + // LEA preg,np[ESP] + unsigned np = stackpush - ep->EV.Vuns; // stack delta to parameter + c2 = genc1(CNIL,0x8D,(modregrm(0,4,SP) << 8) | modregrm(2,preg,4),FLconst,np); + if (I64) + code_orrex(c2, REX_W); + c = cat3(c,c1,c2); + } + else + { code *cp = codelem(ep,&retregs,FALSE); + c = cat(c,cp); + } + goto Lret; + } + default: + Ldefault2: + c = cat(c, params(e->E2,stackalign)); // push parameters + break; + } + } + else + { assert(I64); + + // Easier to deal with parameters as an array: parameters[0..np] + int np = el_nparams(e->E2); + Parameter *parameters = (Parameter *)alloca(np * sizeof(Parameter)); + + { int n = 0; + fillParameters(e->E2, parameters, &n); + assert(n == np); + } + + /* Special handling for call to __tls_get_addr, we must save registers + * before evaluating the parameter, so that the parameter load and call + * are adjacent. + */ + if (np == 1 && e->E1->Eoper == OPvar) + { symbol *s = e->E1->EV.sp.Vsym; + if (s == tls_get_addr_sym) + c = getregs(~s->Sregsaved & (mBP | ALLREGS | mES | XMMREGS)); + } + + unsigned stackalign = REGSIZE; + + // Figure out which parameters go in registers + // Compute numpara, the total bytes pushed on the stack + int r = 0; + int xmmcnt = XMM0; + for (int i = np; --i >= 0;) + { + static const unsigned char argregs[6] = { DI,SI,DX,CX,R8,R9 }; + elem *ep = parameters[i].e; + tym_t ty = ep->Ety; + if (r < sizeof(argregs)/sizeof(argregs[0])) // if more arg regs + { unsigned sz; + if ( + // This must match type_jparam() + ty64reg(ty) || + ((tybasic(ty) == TYstruct || tybasic(ty) == TYarray) && + ((sz = type_size(ep->ET)) == 1 || sz == 2 || sz == 4 || sz == 8)) + ) + { + parameters[i].reg = argregs[r]; + r++; + continue; // goes in register, not stack + } + } + if (xmmcnt <= XMM7) + { + if (tyxmmreg(ty)) + { + parameters[i].reg = xmmcnt; + xmmcnt++; + continue; // goes in register, not stack + } + } + + // Parameter i goes on the stack + parameters[i].reg = -1; // -1 means no register + unsigned alignsize = el_alignsize(ep); + parameters[i].numalign = 0; + if (alignsize > stackalign) + { unsigned newnumpara = (numpara + (alignsize - 1)) & ~(alignsize - 1); + parameters[i].numalign = newnumpara - numpara; + numpara = newnumpara; + } + numpara += paramsize(ep,stackalign); + } + + assert((numpara & (REGSIZE - 1)) == 0); + assert((stackpush & (REGSIZE - 1)) == 0); + + /* Should consider reordering the order of evaluation of the parameters + * so that args that go into registers are evaluated after args that get + * pushed. We can reorder args that are constants or relconst's. + */ + + /* Adjust start of the stack so after all args are pushed, + * the stack will be aligned. + */ + if (STACKALIGN == 16 && (numpara + stackpush) & (STACKALIGN - 1)) + { + numalign = STACKALIGN - ((numpara + stackpush) & (STACKALIGN - 1)); + c = genc2(c,0x81,(REX_W << 16) | modregrm(3,5,SP),numalign); // SUB RSP,numalign + c = genadjesp(c, numalign); + stackpush += numalign; + stackpushsave += numalign; + } + + int regsaved[XMM7 + 1]; + memset(regsaved, -1, sizeof(regsaved)); + code *crest = NULL; + regm_t saved = 0; + + /* Parameters go into the registers RDI,RSI,RDX,RCX,R8,R9 + * float and double parameters go into XMM0..XMM7 + * For variadic functions, count of XMM registers used goes in AL + */ + for (int i = 0; i < np; i++) + { + elem *ep = parameters[i].e; + int preg = parameters[i].reg; + if (preg == -1) + { + /* Push parameter on stack, but keep track of registers used + * in the process. If they interfere with keepmsk, we'll have + * to save/restore them. + */ + code *csave = NULL; + regm_t overlap = msavereg & keepmsk; + msavereg |= keepmsk; + code *cp = params(ep,stackalign); + regm_t tosave = keepmsk & ~msavereg; + msavereg &= ~keepmsk | overlap; + + // tosave is the mask to save and restore + for (int j = 0; tosave; j++) + { regm_t mi = mask[j]; + assert(j <= XMM7); + if (mi & tosave) + { + unsigned idx; + csave = regsave.save(csave, j, &idx); + crest = regsave.restore(crest, j, idx); + saved |= mi; + keepmsk &= ~mi; // don't need to keep these for rest of params + tosave &= ~mi; + } + } + + c = cat4(c, csave, cp, NULL); + + // Alignment for parameter comes after it got pushed + unsigned numalign = parameters[i].numalign; + if (numalign) + { + c = genc2(c,0x81,(REX_W << 16) | modregrm(3,5,SP),numalign); // SUB RSP,numalign + c = genadjesp(c, numalign); + stackpush += numalign; + } + } + else + { + // Goes in register preg, not stack + regm_t retregs = mask[preg]; + if (ep->Eoper == OPstrthis) + { + code *c1 = getregs(retregs); + // LEA preg,np[RSP] + unsigned np = stackpush - ep->EV.Vuns; // stack delta to parameter + code *c2 = genc1(CNIL,0x8D,(REX_W << 16) | + (modregrm(0,4,SP) << 8) | + modregxrm(2,preg,4), FLconst,np); + c = cat3(c,c1,c2); + } + else + { code *cp = scodelem(ep,&retregs,keepmsk,FALSE); + c = cat(c,cp); + } + keepmsk |= retregs; // don't change preg when evaluating func address + } + } + + // Restore any register parameters we saved + c = cat4(c, getregs(saved), crest, NULL); + keepmsk |= saved; + + // Variadic functions store the number of XMM registers used in AL + if (e->Eflags & EFLAGS_variadic) + { code *c1 = getregs(mAX); + c1 = movregconst(c1,AX,xmmcnt - XMM0,1); + c = cat(c, c1); + keepmsk |= mAX; + } + } + } + else + { + /* Adjust start of the stack so + * the stack will be aligned. + */ + if (STACKALIGN == 16 && (stackpush) & (STACKALIGN - 1)) + { + numalign = STACKALIGN - ((stackpush) & (STACKALIGN - 1)); + c = genc2(NULL,0x81,modregrm(3,5,SP),numalign); // SUB ESP,numalign + if (I64) + code_orrex(c, REX_W); + c = genadjesp(c, numalign); + stackpush += numalign; + stackpushsave += numalign; + } + + // Variadic functions store the number of XMM registers used in AL + if (I64 && e->Eflags & EFLAGS_variadic) + { code *c1 = getregs(mAX); + c1 = movregconst(c1,AX,0,1); + c = cat(c, c1); + keepmsk |= mAX; + } + } +Lret: + cgstate.stackclean--; + if (I16) + numpara = stackpush - stackpushsave; + else + { + if (numpara != stackpush - stackpushsave) + printf("numpara = %d, stackpush = %d, stackpushsave = %d\n", numpara, stackpush, stackpushsave); + assert(numpara == stackpush - stackpushsave); + } + return cat(c,funccall(e,numpara,numalign,pretregs,keepmsk)); +} + +/*********************************** + */ + +code *cdstrthis(elem *e,regm_t *pretregs) +{ + code *c1; + code *c2; + + assert(tysize(e->Ety) == REGSIZE); + unsigned reg = findreg(*pretregs & allregs); + c1 = getregs(mask[reg]); + // LEA reg,np[ESP] + unsigned np = stackpush - e->EV.Vuns; // stack delta to parameter + c2 = genc1(CNIL,0x8D,(modregrm(0,4,SP) << 8) | modregxrm(2,reg,4),FLconst,np); + if (I64) + code_orrex(c2, REX_W); + return cat3(c1,c2,fixresult(e,mask[reg],pretregs)); +} + +/****************************** + * Call function. All parameters are pushed onto the stack, numpara gives + * the size of them all. + */ + +STATIC code * funccall(elem *e,unsigned numpara,unsigned numalign,regm_t *pretregs,regm_t keepmsk) +{ + elem *e1; + code *c,*ce,cs; + tym_t tym1; + char farfunc; + regm_t retregs; + symbol *s; + + //printf("funccall(e = %p, *pretregs = x%x, numpara = %d, numalign = %d)\n",e,*pretregs,numpara,numalign); + calledafunc = 1; + /* Determine if we need frame for function prolog/epilog */ +#if TARGET_WINDOS + if (config.memmodel == Vmodel) + { + if (tyfarfunc(funcsym_p->ty())) + needframe = TRUE; + } +#endif + e1 = e->E1; + tym1 = tybasic(e1->Ety); + farfunc = tyfarfunc(tym1) || tym1 == TYifunc; + c = NULL; + if (e1->Eoper == OPvar) + { /* Call function directly */ + code *c1; + +#ifdef DEBUG + if (!tyfunc(tym1)) WRTYxx(tym1); +#endif + assert(tyfunc(tym1)); + s = e1->EV.sp.Vsym; + if (s->Sflags & SFLexit) + c = NULL; + else if (s != tls_get_addr_sym) + c = save87(); // assume 8087 regs are all trashed + if (s->Sflags & SFLexit) + // Function doesn't return, so don't worry about registers + // it may use + c1 = NULL; + else if (!tyfunc(s->ty()) || !(config.flags4 & CFG4optimized)) + // so we can replace func at runtime + c1 = getregs(~fregsaved & (mBP | ALLREGS | mES | XMMREGS)); + else + c1 = getregs(~s->Sregsaved & (mBP | ALLREGS | mES | XMMREGS)); + if (strcmp(s->Sident,"alloca") == 0) + { +#if 1 + s = rtlsym[RTLSYM_ALLOCA]; + makeitextern(s); + c1 = cat(c1,getregs(mCX)); + c1 = genc(c1,0x8D,modregrm(2,CX,BPRM),FLallocatmp,0,0,0); // LEA CX,&localsize[BP] + if (I64) + code_orrex(c1, REX_W); + usedalloca = 2; // new way +#else + usedalloca = 1; // old way +#endif + } + if (sytab[s->Sclass] & SCSS) // if function is on stack (!) + { + retregs = allregs & ~keepmsk; + s->Sflags &= ~GTregcand; + s->Sflags |= SFLread; + ce = cat(c1,cdrelconst(e1,&retregs)); +#if TARGET_SEGMENTED + if (farfunc) + goto LF1; + else +#endif + goto LF2; + } + else + { int fl; + + fl = FLfunc; + if (!tyfunc(s->ty())) + fl = el_fl(e1); + if (tym1 == TYifunc) + c1 = gen1(c1,0x9C); // PUSHF + ce = CNIL; +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (s != tls_get_addr_sym) + { + //printf("call %s\n", s->Sident); + ce = load_localgot(); + } +#endif + ce = gencs(ce,farfunc ? 0x9A : 0xE8,0,fl,s); // CALL extern + ce->Iflags |= farfunc ? (CFseg | CFoff) : (CFselfrel | CFoff); +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (s == tls_get_addr_sym) + { + if (I32) + { + /* Append a NOP so GNU linker has patch room + */ + ce = gen1(ce, 0x90); // NOP + code_orflag(ce, CFvolatile); // don't schedule it + } + else + { /* Prepend 66 66 48 so GNU linker has patch room + */ + assert(I64); + ce->Irex = REX | REX_W; + ce = cat(gen1(CNIL, 0x66), ce); + ce = cat(gen1(CNIL, 0x66), ce); + } + } +#endif + } + ce = cat(c1,ce); + } + else + { /* Call function via pointer */ + elem *e11; + tym_t e11ty; + +#ifdef DEBUG + if (e1->Eoper != OPind + ) { WRFL((enum FL)el_fl(e1)); WROP(e1->Eoper); } +#endif + c = save87(); // assume 8087 regs are all trashed + assert(e1->Eoper == OPind); + e11 = e1->E1; + e11ty = tybasic(e11->Ety); +#if TARGET_SEGMENTED + assert(!I16 || (e11ty == (farfunc ? TYfptr : TYnptr))); +#else + assert(!I16 || (e11ty == TYnptr)); +#endif + + /* if we can't use loadea() */ + if ((EOP(e11) || e11->Eoper == OPconst) && + (e11->Eoper != OPind || e11->Ecount)) + { + unsigned reg; + + retregs = allregs & ~keepmsk; + cgstate.stackclean++; + ce = scodelem(e11,&retregs,keepmsk,TRUE); + cgstate.stackclean--; + /* Kill registers destroyed by an arbitrary function call */ + ce = cat(ce,getregs((mBP | ALLREGS | mES | XMMREGS) & ~fregsaved)); +#if TARGET_SEGMENTED + if (e11ty == TYfptr) + { unsigned lsreg; + LF1: + reg = findregmsw(retregs); + lsreg = findreglsw(retregs); + floatreg = TRUE; /* use float register */ + reflocal = TRUE; + ce = genc1(ce,0x89, /* MOV floatreg+2,reg */ + modregrm(2,reg,BPRM),FLfltreg,REGSIZE); + genc1(ce,0x89, /* MOV floatreg,lsreg */ + modregrm(2,lsreg,BPRM),FLfltreg,0); + if (tym1 == TYifunc) + gen1(ce,0x9C); // PUSHF + genc1(ce,0xFF, /* CALL [floatreg] */ + modregrm(2,3,BPRM),FLfltreg,0); + } + else +#endif + { + LF2: + reg = findreg(retregs); + ce = gen2(ce,0xFF,modregrmx(3,2,reg)); /* CALL reg */ + if (I64) + code_orrex(ce, REX_W); + } + } + else + { + if (tym1 == TYifunc) + c = gen1(c,0x9C); // PUSHF + // CALL [function] + cs.Iflags = 0; + cgstate.stackclean++; + ce = loadea(e11,&cs,0xFF,farfunc ? 3 : 2,0,keepmsk,(mBP|ALLREGS|mES|XMMREGS) & ~fregsaved); + cgstate.stackclean--; + freenode(e11); + } + s = NULL; + } + c = cat(c,ce); + freenode(e1); + + /* See if we will need the frame pointer. + Calculate it here so we can possibly use BP to fix the stack. + */ +#if 0 + if (!needframe) + { SYMIDX si; + + /* If there is a register available for this basic block */ + if (config.flags4 & CFG4optimized && (ALLREGS & ~regcon.used)) + ; + else + { + for (si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + + if (s->Sflags & GTregcand && type_size(s->Stype) != 0) + { + if (config.flags4 & CFG4optimized) + { /* If symbol is live in this basic block and */ + /* isn't already in a register */ + if (s->Srange && vec_testbit(dfoidx,s->Srange) && + s->Sfl != FLreg) + { /* Then symbol must be allocated on stack */ + needframe = TRUE; + break; + } + } + else + { if (mfuncreg == 0) /* if no registers left */ + { needframe = TRUE; + break; + } + } + } + } + } + } +#endif + + retregs = regmask(e->Ety, tym1); + + // If stack needs cleanup + if (OTbinary(e->Eoper) && + !typfunc(tym1) && + !(s && s->Sflags & SFLexit)) + { + if (tym1 == TYhfunc) + { // Hidden parameter is popped off by the callee + c = genadjesp(c, -REGSIZE); + stackpush -= REGSIZE; + if (numpara + numalign > REGSIZE) + c = genstackclean(c, numpara + numalign - REGSIZE, retregs); + } + else + c = genstackclean(c,numpara + numalign,retregs); + } + else + { + c = genadjesp(c,-numpara); + stackpush -= numpara; + if (numalign) + c = genstackclean(c,numalign,retregs); + } + + /* Special handling for functions which return a floating point + value in the top of the 8087 stack. + */ + + if (retregs & mST0) + { + c = genadjfpu(c, 1); + if (*pretregs) // if we want the result + { //assert(stackused == 0); + push87(); // one item on 8087 stack + return cat(c,fixresult87(e,retregs,pretregs)); + } + else + /* Pop unused result off 8087 stack */ + c = gen2(c,0xDD,modregrm(3,3,0)); /* FPOP */ + } + else if (retregs & mST01) + { + c = genadjfpu(c, 2); + if (*pretregs) // if we want the result + { assert(stackused == 0); + push87(); + push87(); // two items on 8087 stack + return cat(c,fixresult_complex87(e,retregs,pretregs)); + } + else + { + // Pop unused result off 8087 stack + c = gen2(c,0xDD,modregrm(3,3,0)); // FPOP + c = gen2(c,0xDD,modregrm(3,3,0)); // FPOP + } + } + + return cat(c,fixresult(e,retregs,pretregs)); +} + +/*************************** + * Determine size of everything that will be pushed. + */ + +targ_size_t paramsize(elem *e,unsigned stackalign) +{ + targ_size_t psize = 0; + targ_size_t szb; + + while (e->Eoper == OPparam) /* if more params */ + { + elem *e2 = e->E2; + psize += paramsize(e->E1,stackalign); // push them backwards + e = e2; + } + tym_t tym = tybasic(e->Ety); + if (tyscalar(tym)) + szb = size(tym); + else if (tym == TYstruct) + szb = type_size(e->ET); + else + { +#ifdef DEBUG + WRTYxx(tym); +#endif + assert(0); + } + psize += align(stackalign,szb); /* align on word stack boundary */ + return psize; +} + +/*************************** + * Generate code to push parameter list. + * stackpush is incremented by stackalign for each PUSH. + */ + +code *params(elem *e,unsigned stackalign) +{ code *c,*ce,cs; + code *cp; + unsigned reg; + targ_size_t szb; // size before alignment + targ_size_t sz; // size after alignment + tym_t tym; + regm_t retregs; + elem *e1; + elem *e2; + symbol *s; + int fl; + + //printf("params(e = %p, stackalign = %d)\n", e, stackalign); + cp = NULL; + stackchanged = 1; + assert(e); + while (e->Eoper == OPparam) /* if more params */ + { + e2 = e->E2; + cp = cat(cp,params(e->E1,stackalign)); // push them backwards + freenode(e); + e = e2; + } + //printf("params()\n"); elem_print(e); + + tym = tybasic(e->Ety); + if (tyfloating(tym)) + obj_fltused(); + + int grex = I64 ? REX_W << 16 : 0; + + /* sz = number of bytes pushed */ + if (tyscalar(tym)) + szb = size(tym); + else if (tym == TYstruct) + szb = type_size(e->ET); + else + { +#ifdef DEBUG + WRTYxx(tym); +#endif + assert(0); + } + sz = align(stackalign,szb); /* align on word stack boundary */ + assert((sz & (stackalign - 1)) == 0); /* ensure that alignment worked */ + assert((sz & (REGSIZE - 1)) == 0); + + c = CNIL; + cs.Iflags = 0; + cs.Irex = 0; + switch (e->Eoper) + { +#if SCPP + case OPstrctor: + { + e1 = e->E1; + c = docommas(&e1); /* skip over any comma expressions */ + + c = genc2(c,0x81,grex | modregrm(3,5,SP),sz); // SUB SP,sizeof(struct) + stackpush += sz; + genadjesp(c,sz); + + // Find OPstrthis and set it to stackpush + exp2_setstrthis(e1,NULL,stackpush,NULL); + + retregs = 0; + ce = codelem(e1,&retregs,TRUE); + goto L2; + } + case OPstrthis: + // This is the parameter for the 'this' pointer corresponding to + // OPstrctor. We push a pointer to an object that was already + // allocated on the stack by OPstrctor. + { unsigned np; + + retregs = allregs; + c = allocreg(&retregs,®,TYoffset); + c = genregs(c,0x89,SP,reg); // MOV reg,SP + if (I64) + code_orrex(c, REX_W); + np = stackpush - e->EV.Vuns; // stack delta to parameter + c = genc2(c,0x81,grex | modregrmx(3,0,reg),np); // ADD reg,np + if (sz > REGSIZE) + { c = gen1(c,0x16); // PUSH SS + stackpush += REGSIZE; + } + c = gen1(c,0x50 + (reg & 7)); // PUSH reg + if (reg & 8) + code_orrex(c, REX_B); + stackpush += REGSIZE; + genadjesp(c,sz); + ce = CNIL; + goto L2; + } +#endif + case OPstrpar: + { code *cc,*c1,*c2,*c3; + unsigned rm; + unsigned seg; // segment override prefix flags + bool doneoff; + unsigned pushsize = REGSIZE; + unsigned op16 = 0; + unsigned npushes; + + e1 = e->E1; + if (sz == 0) + { + ce = docommas(&e1); /* skip over any commas */ + goto L2; + } + if ((sz & 3) == 0 && (sz / REGSIZE) <= 4 && e1->Eoper == OPvar) + { freenode(e); + e = e1; + goto L1; + } + cc = docommas(&e1); /* skip over any commas */ + seg = 0; /* assume no seg override */ + retregs = sz ? IDXREGS : 0; + doneoff = FALSE; + if (!I16 && sz & 2) // if odd number of words to push + { pushsize = 2; + op16 = 1; + } + else if (I16 && config.target_cpu >= TARGET_80386 && (sz & 3) == 0) + { pushsize = 4; // push DWORDs at a time + op16 = 1; + } + npushes = sz / pushsize; + switch (e1->Eoper) + { case OPind: +#if TARGET_SEGMENTED + if (sz) + { switch (tybasic(e1->E1->Ety)) + { + case TYfptr: + case TYhptr: + seg = CFes; + retregs |= mES; + break; + case TYsptr: + if (config.wflags & WFssneds) + seg = CFss; + break; + case TYcptr: + seg = CFcs; + break; + } + } +#endif + c1 = codelem(e1->E1,&retregs,FALSE); + freenode(e1); + break; + case OPvar: + /* Symbol is no longer a candidate for a register */ + e1->EV.sp.Vsym->Sflags &= ~GTregcand; + + if (!e1->Ecount && npushes > 4) + { /* Kludge to point at last word in struct. */ + /* Don't screw up CSEs. */ + e1->EV.sp.Voffset += sz - pushsize; + doneoff = TRUE; + } + //if (LARGEDATA) /* if default isn't DS */ + { static unsigned segtocf[4] = { CFes,CFcs,CFss,0 }; + unsigned s; + int fl; + + fl = el_fl(e1); +#if TARGET_SEGMENTED + if (fl == FLfardata) + { seg = CFes; + retregs |= mES; + } + else +#endif + { + s = segfl[fl]; + assert(s < 4); + seg = segtocf[s]; + if (seg == CFss && !(config.wflags & WFssneds)) + seg = 0; + } + } +#if TARGET_SEGMENTED + if (e1->Ety & mTYfar) + { seg = CFes; + retregs |= mES; + } +#endif + c1 = cdrelconst(e1,&retregs); + /* Reverse the effect of the previous add */ + if (doneoff) + e1->EV.sp.Voffset -= sz - pushsize; + freenode(e1); + break; + case OPstreq: + //case OPcond: + if (!(config.exe & EX_flat)) + { seg = CFes; + retregs |= mES; + } + c1 = codelem(e1,&retregs,FALSE); + break; + default: +#ifdef DEBUG + elem_print(e1); +#endif + assert(0); + } + reg = findreglsw(retregs); + rm = I16 ? regtorm[reg] : regtorm32[reg]; + if (op16) + seg |= CFopsize; // operand size + if (npushes <= 4) + { + assert(!doneoff); + for (c2 = CNIL; npushes > 1; npushes--) + { c2 = genc1(c2,0xFF,buildModregrm(2,6,rm),FLconst,pushsize * (npushes - 1)); // PUSH [reg] + code_orflag(c2,seg); + genadjesp(c2,pushsize); + } + c3 = gen2(CNIL,0xFF,buildModregrm(0,6,rm)); // PUSH [reg] + c3->Iflags |= seg; + genadjesp(c3,pushsize); + ce = cat4(cc,c1,c2,c3); + } + else if (sz) + { int size; + + c2 = getregs_imm(mCX | retregs); + /* MOV CX,sz/2 */ + c2 = movregconst(c2,CX,npushes,0); + if (!doneoff) + { /* This disgusting thing should be done when */ + /* reg is loaded. Too lazy to fix it now. */ + /* ADD reg,sz-2 */ + c2 = genc2(c2,0x81,grex | modregrmx(3,0,reg),sz-pushsize); + } + c3 = getregs(mCX); // the LOOP decrements it + c3 = gen2(c3,0xFF,buildModregrm(0,6,rm)); // PUSH [reg] + c3->Iflags |= seg | CFtarg2; + genc2(c3,0x81,grex | buildModregrm(3,5,reg),pushsize); // SUB reg,2 + size = ((seg & CFSEG) ? -8 : -7) - op16; + if (code_next(c3)->Iop != 0x81) + size++; + //genc2(c3,0xE2,0,size); // LOOP .-7 or .-8 + genjmp(c3,0xE2,FLcode,(block *)c3); // LOOP c3 + regimmed_set(CX,0); + genadjesp(c3,sz); + ce = cat4(cc,c1,c2,c3); + } + else + ce = cat(cc,c1); + stackpush += sz; + goto L2; + } + case OPind: + if (!e->Ecount) /* if *e1 */ + { if (sz <= REGSIZE) + { // Watch out for single byte quantities being up + // against the end of a segment or in memory-mapped I/O + if (!(config.exe & EX_flat) && szb == 1) + break; + goto L1; // can handle it with loadea() + } + + // Avoid PUSH MEM on the Pentium when optimizing for speed + if (config.flags4 & CFG4speed && + (config.target_cpu >= TARGET_80486 && + config.target_cpu <= TARGET_PentiumMMX) && + sz <= 2 * REGSIZE && + !tyfloating(tym)) + break; + + if (tym == TYldouble || tym == TYildouble || tycomplex(tym)) + break; + if (I32) + { + assert(sz == REGSIZE * 2); + ce = loadea(e,&cs,0xFF,6,REGSIZE,0,0); /* PUSH EA+4 */ + ce = genadjesp(ce,REGSIZE); + } + else + { + if (sz == DOUBLESIZE) + { ce = loadea(e,&cs,0xFF,6,DOUBLESIZE - REGSIZE,0,0); /* PUSH EA+6 */ + cs.IEVoffset1 -= REGSIZE; + gen(ce,&cs); /* PUSH EA+4 */ + ce = genadjesp(ce,REGSIZE); + getlvalue_lsw(&cs); + gen(ce,&cs); /* PUSH EA+2 */ + } + else /* TYlong */ + ce = loadea(e,&cs,0xFF,6,REGSIZE,0,0); /* PUSH EA+2 */ + ce = genadjesp(ce,REGSIZE); + } + stackpush += sz; + getlvalue_lsw(&cs); + gen(ce,&cs); /* PUSH EA */ + ce = genadjesp(ce,REGSIZE); + goto L2; + } + break; +#if TARGET_SEGMENTED + case OPnp_fp: + if (!e->Ecount) /* if (far *)e1 */ + { + int segreg; + tym_t tym1; + + e1 = e->E1; + tym1 = tybasic(e1->Ety); + /* BUG: what about pointers to functions? */ + switch (tym1) + { + case TYnptr: segreg = 3<<3; break; + case TYcptr: segreg = 1<<3; break; + default: segreg = 2<<3; break; + } + if (I32 && stackalign == 2) + c = gen1(c,0x66); /* push a word */ + c = gen1(c,0x06 + segreg); /* PUSH SEGREG */ + if (I32 && stackalign == 2) + code_orflag(c,CFopsize); // push a word + c = genadjesp(c,stackalign); + stackpush += stackalign; + ce = params(e1,stackalign); + goto L2; + } + break; +#endif + case OPrelconst: +#if TARGET_SEGMENTED + /* Determine if we can just push the segment register */ + /* Test size of type rather than TYfptr because of (long)(&v) */ + s = e->EV.sp.Vsym; + //if (sytab[s->Sclass] & SCSS && !I32) // if variable is on stack + // needframe = TRUE; // then we need stack frame + if (tysize[tym] == tysize[TYfptr] && + (fl = s->Sfl) != FLfardata && + /* not a function that CS might not be the segment of */ + (!((fl == FLfunc || s->ty() & mTYcs) && + (s->Sclass == SCcomdat || s->Sclass == SCextern || s->Sclass == SCinline || config.wflags & WFthunk)) || + (fl == FLfunc && config.exe == EX_DOSX) + ) + ) + { + stackpush += sz; + c = gen1(c,0x06 + /* PUSH SEGREG */ + (((fl == FLfunc || s->ty() & mTYcs) ? 1 : segfl[fl]) << 3)); + c = genadjesp(c,REGSIZE); + + if (config.target_cpu >= TARGET_80286 && !e->Ecount) + { ce = getoffset(e,STACK); + goto L2; + } + else + { c = cat(c,offsetinreg(e,&retregs)); + unsigned reg = findreg(retregs); + c = genpush(c,reg); // PUSH reg + genadjesp(c,REGSIZE); + } + goto ret; + } + if (config.target_cpu >= TARGET_80286 && !e->Ecount) + { + stackpush += sz; + if (tysize[tym] == tysize[TYfptr]) + { + /* PUSH SEG e */ + code *c1 = gencs(CNIL,0x68,0,FLextern,s); + c1->Iflags = CFseg; + genadjesp(c1,REGSIZE); + c = cat(c,c1); + } + ce = getoffset(e,STACK); + goto L2; + } +#endif + break; /* else must evaluate expression */ + case OPvar: + L1: + if (0 && I32 && sz == 2) + { /* 32 bit code, but pushing 16 bit values anyway */ + ce = loadea(e,&cs,0xFF,6,0,0,0); /* PUSH EA */ + // BUG: 0x66 fails with scheduler + ce = cat(gen1(CNIL,0x66),ce); /* 16 bit override */ + stackpush += sz; + genadjesp(ce,sz); + } + else if (config.flags4 & CFG4speed && + (config.target_cpu >= TARGET_80486 && + config.target_cpu <= TARGET_PentiumMMX) && + sz <= 2 * REGSIZE && + !tyfloating(tym)) + { // Avoid PUSH MEM on the Pentium when optimizing for speed + break; + } + else + { int regsize = REGSIZE; + unsigned flag = 0; + + if (I16 && config.target_cpu >= TARGET_80386 && sz > 2 && + !e->Ecount) + { regsize = 4; + flag |= CFopsize; + } + ce = loadea(e,&cs,0xFF,6,sz - regsize,RMload,0); // PUSH EA+sz-2 + code_orflag(ce,flag); + ce = genadjesp(ce,REGSIZE); + stackpush += sz; + while ((targ_int)(sz -= regsize) > 0) + { ce = cat(ce,loadea(e,&cs,0xFF,6,sz - regsize,RMload,0)); + code_orflag(ce,flag); + ce = genadjesp(ce,REGSIZE); + } + } + L2: + freenode(e); + c = cat(c,ce); + goto ret; + case OPconst: + { + char pushi = 0; + unsigned flag = 0; + int regsize = REGSIZE; + targ_int value; + + if (tycomplex(tym)) + break; + + if (I64 && tyfloating(tym) && sz > 4 && boolres(e)) + // Can't push 64 bit non-zero args directly + break; + + if (I32 && szb == 10) // special case for long double constants + { + assert(sz == 12); + value = ((unsigned short *)&e->EV.Vldouble)[4]; + stackpush += sz; + ce = genadjesp(NULL,sz); + for (int i = 2; i >= 0; i--) + { + if (reghasvalue(allregs, value, ®)) + ce = gen1(ce,0x50 + reg); // PUSH reg + else + ce = genc2(ce,0x68,0,value); // PUSH value + value = ((unsigned *)&e->EV.Vldouble)[i - 1]; + } + goto L2; + } + + assert(I64 || sz <= LNGDBLSIZE); + int i = sz; + if (!I16 && i == 2) + flag = CFopsize; + + if (config.target_cpu >= TARGET_80286) +// && (e->Ecount == 0 || e->Ecount != e->Ecomsub)) + { pushi = 1; + if (I16 && config.target_cpu >= TARGET_80386 && i >= 4) + { regsize = 4; + flag = CFopsize; + } + } + else if (i == REGSIZE) + break; + + stackpush += sz; + ce = genadjesp(NULL,sz); + targ_uns *pi = (targ_uns *) &e->EV.Vdouble; + targ_ushort *ps = (targ_ushort *) pi; + targ_ullong *pl = (targ_ullong *)pi; + i /= regsize; + do + { + if (i) /* be careful not to go negative */ + i--; + targ_size_t value = (regsize == 4) ? pi[i] : ps[i]; + if (regsize == 8) + value = pl[i]; + if (pushi) + { + if (I64 && regsize == 8 && value != (int)value) + { ce = regwithvalue(ce,allregs,value,®,64); + goto Preg; // cannot push imm64 unless it is sign extended 32 bit value + } + if (regsize == REGSIZE && reghasvalue(allregs,value,®)) + goto Preg; + ce = genc2(ce,(szb == 1) ? 0x6A : 0x68,0,value); // PUSH value + } + else + { + ce = regwithvalue(ce,allregs,value,®,0); + Preg: + ce = genpush(ce,reg); // PUSH reg + } + code_orflag(ce,flag); /* operand size */ + } while (i); + goto L2; + } + default: + break; + } + retregs = tybyte(tym) ? BYTEREGS : allregs; + if (tyvector(tym)) + { + retregs = XMMREGS; + c = cat(c,codelem(e,&retregs,FALSE)); + stackpush += sz; + c = genadjesp(c,sz); + c = genc2(c,0x81,grex | modregrm(3,5,SP),sz); // SUB SP,sz + unsigned op = xmmstore(tym); + unsigned r = findreg(retregs); + c = gen2sib(c,op,modregxrm(0,r - XMM0,4),modregrm(0,4,SP)); // MOV [ESP],r + goto ret; + } + else if (tyfloating(tym)) + { if (config.inline8087) + { code *c1,*c2; + unsigned op; + unsigned r; + + retregs = tycomplex(tym) ? mST01 : mST0; + c = cat(c,codelem(e,&retregs,FALSE)); + stackpush += sz; + c = genadjesp(c,sz); + c = genc2(c,0x81,grex | modregrm(3,5,SP),sz); // SUB SP,sz + switch (tym) + { + case TYfloat: + case TYifloat: + case TYcfloat: + op = 0xD9; + r = 3; + break; + + case TYdouble: + case TYidouble: + case TYdouble_alias: + case TYcdouble: + op = 0xDD; + r = 3; + break; + + case TYldouble: + case TYildouble: + case TYcldouble: + op = 0xDB; + r = 7; + break; + + default: + assert(0); + } + if (!I16) + { + c1 = NULL; + c2 = NULL; + if (tycomplex(tym)) + { + // FSTP sz/2[ESP] + c2 = genc1(CNIL,op,(modregrm(0,4,SP) << 8) | modregxrm(2,r,4),FLconst,sz/2); + pop87(); + } + pop87(); + c2 = gen2sib(c2,op,modregrm(0,r,4),modregrm(0,4,SP)); // FSTP [ESP] + } + else + { + retregs = IDXREGS; /* get an index reg */ + c1 = allocreg(&retregs,®,TYoffset); + c1 = genregs(c1,0x89,SP,reg); /* MOV reg,SP */ + pop87(); + c2 = gen2(CNIL,op,modregrm(0,r,regtorm[reg])); // FSTP [reg] + } + if (LARGEDATA) + c2->Iflags |= CFss; /* want to store into stack */ + genfwait(c2); // FWAIT + c = cat3(c,c1,c2); + goto ret; + } + else if (I16 && (tym == TYdouble || tym == TYdouble_alias)) + retregs = mSTACK; + } +#if LONGLONG + else if (I16 && sz == 8) // if long long + retregs = mSTACK; +#endif + c = cat(c,scodelem(e,&retregs,0,TRUE)); + if (retregs != mSTACK) /* if stackpush not already inc'd */ + stackpush += sz; + if (sz <= REGSIZE) + { + c = genpush(c,findreg(retregs)); // PUSH reg + genadjesp(c,REGSIZE); + } + else if (sz == REGSIZE * 2) + { c = genpush(c,findregmsw(retregs)); // PUSH msreg + genpush(c,findreglsw(retregs)); // PUSH lsreg + genadjesp(c,sz); + } +ret: + return cat(cp,c); +} + + +/******************************* + * Get offset portion of e, and store it in an index + * register. Return mask of index register in *pretregs. + */ + +code *offsetinreg( elem *e, regm_t *pretregs) +{ regm_t retregs; + code *c; + unsigned reg; + + retregs = mLSW; /* want only offset */ + if (e->Ecount && e->Ecount != e->Ecomsub) + { unsigned i; + regm_t rm; + + rm = retregs & regcon.cse.mval & ~regcon.cse.mops & ~regcon.mvar; /* possible regs */ + for (i = 0; rm; i++) + { if (mask[i] & rm && regcon.cse.value[i] == e) + { reg = i; + *pretregs = mask[i]; + c = getregs(*pretregs); + goto L3; + } + rm &= ~mask[i]; + } + } + + *pretregs = retregs; + c = allocreg(pretregs,®,TYoffset); + c = cat(c,getoffset(e,reg)); +L3: + cssave(e,*pretregs,FALSE); + freenode(e); + return c; +} + + +/****************************** + * Generate code to load data into registers. + */ + +code *loaddata(elem *e,regm_t *pretregs) +{ unsigned reg,nreg,op,sreg; + tym_t tym; + int sz; + code *c,*ce,cs; + regm_t flags,forregs,regm; + +#ifdef DEBUG + if (debugw) + printf("loaddata(e = %p,*pretregs = %s)\n",e,regm_str(*pretregs)); + //elem_print(e); +#endif + assert(e); + elem_debug(e); + if (*pretregs == 0) + return CNIL; + tym = tybasic(e->Ety); + if (tym == TYstruct) + return cdrelconst(e,pretregs); + if (tyfloating(tym)) + { obj_fltused(); + if (config.inline8087) + { if (*pretregs & mST0) + return load87(e,0,pretregs,NULL,-1); + else if (tycomplex(tym)) + return cload87(e, pretregs); + } + } + sz = tysize[tym]; + cs.Iflags = 0; + cs.Irex = 0; + if (*pretregs == mPSW) + { + regm = allregs; + if (e->Eoper == OPconst) + { /* TRUE: OR SP,SP (SP is never 0) */ + /* FALSE: CMP SP,SP (always equal) */ + c = genregs(CNIL,(boolres(e)) ? 0x09 : 0x39,SP,SP); + if (I64) + code_orrex(c, REX_W); + } + else if (sz <= REGSIZE) + { + if (!I16 && (tym == TYfloat || tym == TYifloat)) + { c = allocreg(®m,®,TYoffset); /* get a register */ + ce = loadea(e,&cs,0x8B,reg,0,0,0); // MOV reg,data + c = cat(c,ce); + ce = gen2(CNIL,0xD1,modregrmx(3,4,reg)); /* SHL reg,1 */ + c = cat(c,ce); + } +#if TARGET_OSX + else if (e->Eoper == OPvar && movOnly(e)) + { c = allocreg(®m,®,TYoffset); /* get a register */ + ce = loadea(e,&cs,0x8B,reg,0,0,0); // MOV reg,data + c = cat(c,ce); + ce = fixresult(e,regm,pretregs); + c = cat(c,ce); + } +#endif + else + { cs.IFL2 = FLconst; + cs.IEV2.Vsize_t = 0; + op = (sz == 1) ? 0x80 : 0x81; + c = loadea(e,&cs,op,7,0,0,0); /* CMP EA,0 */ + + // Convert to TEST instruction if EA is a register + // (to avoid register contention on Pentium) + if ((c->Iop & ~1) == 0x38 && + (c->Irm & modregrm(3,0,0)) == modregrm(3,0,0) + ) + { c->Iop = (c->Iop & 1) | 0x84; + code_newreg(c, c->Irm & 7); + if (c->Irex & REX_B) + //c->Irex = (c->Irex & ~REX_B) | REX_R; + c->Irex |= REX_R; + } + } + } + else if (sz < 8) + { + c = allocreg(®m,®,TYoffset); /* get a register */ + if (I32) // it's a 48 bit pointer + ce = loadea(e,&cs,0x0FB7,reg,REGSIZE,0,0); /* MOVZX reg,data+4 */ + else + { ce = loadea(e,&cs,0x8B,reg,REGSIZE,0,0); /* MOV reg,data+2 */ + if (tym == TYfloat || tym == TYifloat) // dump sign bit + gen2(ce,0xD1,modregrm(3,4,reg)); /* SHL reg,1 */ + } + c = cat(c,ce); + ce = loadea(e,&cs,0x0B,reg,0,regm,0); /* OR reg,data */ + c = cat(c,ce); + } + else if (sz == 8 || (I64 && sz == 2 * REGSIZE && !tyfloating(tym))) + { + c = allocreg(®m,®,TYoffset); /* get a register */ + int i = sz - REGSIZE; + ce = loadea(e,&cs,0x8B,reg,i,0,0); /* MOV reg,data+6 */ + if (tyfloating(tym)) // TYdouble or TYdouble_alias + gen2(ce,0xD1,modregrm(3,4,reg)); // SHL reg,1 + c = cat(c,ce); + + while ((i -= REGSIZE) >= 0) + { + code *c1 = loadea(e,&cs,0x0B,reg,i,regm,0); // OR reg,data+i + if (i == 0) + c1->Iflags |= CFpsw; // need the flags on last OR + c = cat(c,c1); + } + } + else if (sz == tysize[TYldouble]) // TYldouble + return load87(e,0,pretregs,NULL,-1); + else + { +#ifdef DEBUG + elem_print(e); +#endif + assert(0); + } + return c; + } + /* not for flags only */ + flags = *pretregs & mPSW; /* save original */ + forregs = *pretregs & (mBP | ALLREGS | mES | XMMREGS); + if (*pretregs & mSTACK) + forregs |= DOUBLEREGS; + if (e->Eoper == OPconst) + { + targ_size_t value = e->EV.Vint; + if (sz == 8) + value = e->EV.Vullong; + + if (sz == REGSIZE && reghasvalue(forregs,value,®)) + forregs = mask[reg]; + + regm_t save = regcon.immed.mval; + c = allocreg(&forregs,®,tym); /* allocate registers */ + regcon.immed.mval = save; // KLUDGE! + if (sz <= REGSIZE) + { + if (sz == 1) + flags |= 1; + else if (!I16 && sz == SHORTSIZE && + !(mask[reg] & regcon.mvar) && + !(config.flags4 & CFG4speed) + ) + flags |= 2; + if (sz == 8) + flags |= 64; + if (reg >= XMM0) + { /* This comes about because 0, 1, pi, etc., constants don't get stored + * in the data segment, because they are x87 opcodes. + * Not so efficient. We should at least do a PXOR for 0. + */ + unsigned r; + targ_size_t value = e->EV.Vuns; + if (sz == 8) + value = e->EV.Vullong; + ce = regwithvalue(CNIL,ALLREGS,value,&r,flags); + flags = 0; // flags are already set + ce = genfltreg(ce,0x89,r,0); // MOV floatreg,r + if (sz == 8) + code_orrex(ce, REX_W); + assert(sz == 4 || sz == 8); // float or double + unsigned op = xmmload(tym); + ce = genfltreg(ce,op,reg - XMM0,0); // MOVSS/MOVSD XMMreg,floatreg + } + else + { ce = movregconst(CNIL,reg,value,flags); + flags = 0; // flags are already set + } + } + else if (sz < 8) // far pointers, longs for 16 bit targets + { + targ_int msw,lsw; + regm_t mswflags; + + msw = I32 ? e->EV.Vfp.Vseg + : (e->EV.Vulong >> 16); + lsw = e->EV.Vfp.Voff; + mswflags = 0; + if (forregs & mES) + { + ce = movregconst(CNIL,reg,msw,0); // MOV reg,segment + genregs(ce,0x8E,0,reg); // MOV ES,reg + msw = lsw; // MOV reg,offset + } + else + { + sreg = findreglsw(forregs); + ce = movregconst(CNIL,sreg,lsw,0); + reg = findregmsw(forregs); + /* Decide if we need to set flags when we load msw */ + if (flags && (msw && msw|lsw || !(msw|lsw))) + { mswflags = mPSW; + flags = 0; + } + } + ce = movregconst(ce,reg,msw,mswflags); + } + else if (sz == 8) + { + if (I32) + { + targ_long *p = (targ_long *) &e->EV.Vdouble; + if (reg >= XMM0) + { /* This comes about because 0, 1, pi, etc., constants don't get stored + * in the data segment, because they are x87 opcodes. + * Not so efficient. We should at least do a PXOR for 0. + */ + unsigned r; + regm_t rm = ALLREGS; + ce = allocreg(&rm,&r,TYint); // allocate scratch register + ce = movregconst(ce,r,p[0],0); + ce = genfltreg(ce,0x89,r,0); // MOV floatreg,r + ce = movregconst(ce,r,p[1],0); + ce = genfltreg(ce,0x89,r,4); // MOV floatreg+4,r + + unsigned op = xmmload(tym); + ce = genfltreg(ce,op,reg - XMM0,0); // MOVSS/MOVSD XMMreg,floatreg + } + else + { + ce = movregconst(CNIL,findreglsw(forregs),p[0],0); + ce = movregconst(ce,findregmsw(forregs),p[1],0); + } + } + else + { targ_short *p = (targ_short *) &e->EV.Vdouble; + + assert(reg == AX); + ce = movregconst(CNIL,AX,p[3],0); /* MOV AX,p[3] */ + ce = movregconst(ce,DX,p[0],0); + ce = movregconst(ce,CX,p[1],0); + ce = movregconst(ce,BX,p[2],0); + } + } + else if (I64 && sz == 16) + { + ce = movregconst(CNIL,findreglsw(forregs),e->EV.Vcent.lsw,0); + ce = movregconst(ce,findregmsw(forregs),e->EV.Vcent.msw,0); + } + else + assert(0); + c = cat(c,ce); + } + else + { + // See if we can use register that parameter was passed in + if (regcon.params && e->EV.sp.Vsym->Sclass == SCfastpar && + regcon.params & mask[e->EV.sp.Vsym->Spreg] && + !(e->Eoper == OPvar && e->EV.sp.Voffset > 0) && // Must be at the base of that variable + sz <= REGSIZE) // make sure no 'paint' to a larger size happened + { + reg = e->EV.sp.Vsym->Spreg; + forregs = mask[reg]; + mfuncreg &= ~forregs; + regcon.used |= forregs; + return fixresult(e,forregs,pretregs); + } + + c = allocreg(&forregs,®,tym); /* allocate registers */ + + if (sz == 1) + { regm_t nregm; + +#ifdef DEBUG + if (!(forregs & BYTEREGS)) + { elem_print(e); + printf("forregs = x%x\n",forregs); + } +#endif + int op = 0x8A; // byte MOV +#if TARGET_OSX + if (movOnly(e)) + op = 0x8B; +#endif + assert(forregs & BYTEREGS); + if (!I16) + c = cat(c,loadea(e,&cs,op,reg,0,0,0)); // MOV regL,data + else + { nregm = tyuns(tym) ? BYTEREGS : mAX; + if (*pretregs & nregm) + nreg = reg; /* already allocated */ + else + c = cat(c,allocreg(&nregm,&nreg,tym)); + ce = loadea(e,&cs,op,nreg,0,0,0); /* MOV nregL,data */ + c = cat(c,ce); + if (reg != nreg) + { genmovreg(c,reg,nreg); /* MOV reg,nreg */ + cssave(e,mask[nreg],FALSE); + } + } + } + else if (forregs & XMMREGS) + { + // Can't load from registers directly to XMM regs +//printf("test2 %s\n", e->EV.sp.Vsym->Sident); + //e->EV.sp.Vsym->Sflags &= ~GTregcand; + + op = xmmload(tym); + if (e->Eoper == OPvar) + { symbol *s = e->EV.sp.Vsym; + if (s->Sfl == FLreg && !(mask[s->Sreglsw] & XMMREGS)) + { op = LODD; // MOVD/MOVQ + /* getlvalue() will unwind this and unregister s; could use a better solution */ + } + } + ce = loadea(e,&cs,op,reg,0,RMload,0); // MOVSS/MOVSD reg,data + c = cat(c,ce); + } + else if (sz <= REGSIZE) + { + ce = loadea(e,&cs,0x8B,reg,0,RMload,0); // MOV reg,data + c = cat(c,ce); + } + else if (sz <= 2 * REGSIZE && forregs & mES) + { + ce = loadea(e,&cs,0xC4,reg,0,0,mES); /* LES data */ + c = cat(c,ce); + } + else if (sz <= 2 * REGSIZE) + { + if (I32 && sz == 8 && + (*pretregs & (mSTACK | mPSW)) == mSTACK) + { int i; + + assert(0); + /* Note that we allocreg(DOUBLEREGS) needlessly */ + stackchanged = 1; + i = DOUBLESIZE - REGSIZE; + do + { c = cat(c,loadea(e,&cs,0xFF,6,i,0,0)); /* PUSH EA+i */ + c = genadjesp(c,REGSIZE); + stackpush += REGSIZE; + i -= REGSIZE; + } + while (i >= 0); + return c; + } + + reg = findregmsw(forregs); + ce = loadea(e,&cs,0x8B,reg,REGSIZE,forregs,0); /* MOV reg,data+2 */ + if (I32 && sz == REGSIZE + 2) + ce->Iflags |= CFopsize; /* seg is 16 bits */ + c = cat(c,ce); + reg = findreglsw(forregs); + ce = loadea(e,&cs,0x8B,reg,0,forregs,0); + c = cat(c,ce); + } + else if (sz >= 8) + { + code *c1,*c2,*c3; + + assert(!I32); + if ((*pretregs & (mSTACK | mPSW)) == mSTACK) + { int i; + + /* Note that we allocreg(DOUBLEREGS) needlessly */ + stackchanged = 1; + i = sz - REGSIZE; + do + { c = cat(c,loadea(e,&cs,0xFF,6,i,0,0)); /* PUSH EA+i */ + c = genadjesp(c,REGSIZE); + stackpush += REGSIZE; + i -= REGSIZE; + } + while (i >= 0); + return c; + } + else + { + assert(reg == AX); + ce = loadea(e,&cs,0x8B,AX,6,0,0); /* MOV AX,data+6 */ + c1 = loadea(e,&cs,0x8B,BX,4,mAX,0); /* MOV BX,data+4 */ + c2 = loadea(e,&cs,0x8B,CX,2,mAX|mBX,0); /* MOV CX,data+2 */ + c3 = loadea(e,&cs,0x8B,DX,0,mAX|mCX|mCX,0); /* MOV DX,data */ + c = cat6(c,ce,c1,c2,c3,CNIL); + } + } + else + assert(0); + } + /* Flags may already be set */ + *pretregs &= flags | ~mPSW; + c = cat(c,fixresult(e,forregs,pretregs)); + return c; +} + +#endif // SPP diff --git a/backend/cod2.c b/backend/cod2.c new file mode 100644 index 00000000..aebe595c --- /dev/null +++ b/backend/cod2.c @@ -0,0 +1,4997 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include "cc.h" +#include "oper.h" +#include "el.h" +#include "code.h" +#include "global.h" +#include "type.h" +#if SCPP +#include "exh.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +int cdcmp_flag; +extern signed char regtorm[8]; + +/******************************************* + * !=0 if cannot use this EA in anything other than a MOV instruction. + */ + +int movOnly(elem *e) +{ +#if TARGET_OSX + if (I64 && config.flags3 & CFG3pic && e->Eoper == OPvar) + { symbol *s = e->EV.sp.Vsym; + // Fixups for these can only be done with a MOV + if (s->Sclass == SCglobal || s->Sclass == SCextern || + s->Sclass == SCcomdat || s->Sclass == SCcomdef) + return 1; + } +#endif + return 0; +} + +/******************************** + * Return mask of index registers used by addressing mode. + * Index is rm of modregrm field. + */ + +regm_t idxregm(code *c) +{ + static const unsigned char idxsib[8] = { mAX,mCX,mDX,mBX,0,mBP,mSI,mDI }; + static const unsigned char idxrm[8] = {mBX|mSI,mBX|mDI,mSI,mDI,mSI,mDI,0,mBX}; + + unsigned rm = c->Irm; + regm_t idxm = 0; + if ((rm & 0xC0) != 0xC0) /* if register is not the destination */ + { + if (I16) + idxm = idxrm[rm & 7]; + else + { + if ((rm & 7) == 4) /* if sib byte */ + { + unsigned sib = c->Isib; + unsigned idxreg = (sib >> 3) & 7; + if (c->Irex & REX_X) + { idxreg |= 8; + idxm = mask[idxreg]; // scaled index reg + } + else + idxm = idxsib[idxreg]; // scaled index reg + if ((sib & 7) == 5 && (rm & 0xC0) == 0) + ; + else + { unsigned base = sib & 7; + if (c->Irex & REX_B) + idxm |= mask[base | 8]; + else + idxm |= idxsib[base]; + } + } + else + { unsigned base = rm & 7; + if (c->Irex & REX_B) + idxm |= mask[base | 8]; + else + idxm |= idxsib[base]; + } + } + } + return idxm; +} + + +#if TARGET_WINDOS +/*************************** + * Gen code for call to floating point routine. + */ + +code *opdouble(elem *e,regm_t *pretregs,unsigned clib) +{ + regm_t retregs1,retregs2; + code *cl, *cr, *c; + + if (config.inline8087) + return orth87(e,pretregs); + + if (tybasic(e->E1->Ety) == TYfloat) + { + clib += CLIBfadd - CLIBdadd; /* convert to float operation */ + retregs1 = FLOATREGS; + retregs2 = FLOATREGS2; + } + else + { + if (I32) + { retregs1 = DOUBLEREGS_32; + retregs2 = DOUBLEREGS2_32; + } + else + { retregs1 = mSTACK; + retregs2 = DOUBLEREGS_16; + } + } + cl = codelem(e->E1, &retregs1,FALSE); + if (retregs1 & mSTACK) + cgstate.stackclean++; + cr = scodelem(e->E2, &retregs2, retregs1 & ~mSTACK, FALSE); + if (retregs1 & mSTACK) + cgstate.stackclean--; + c = callclib(e, clib, pretregs, 0); + return cat3(cl, cr, c); +} +#endif + +/***************************** + * Handle operators which are more or less orthogonal + * ( + - & | ^ ) + */ + +code *cdorth(elem *e,regm_t *pretregs) +{ tym_t ty1; + regm_t retregs,rretregs,posregs; + unsigned reg,rreg,op1,op2,mode; + int rval; + code *c,*cg,*cl; + targ_size_t i; + elem *e1,*e2; + int numwords; /* # of words to be operated on */ + static int nest; + + //printf("cdorth(e = %p, *pretregs = %s)\n",e,regm_str(*pretregs)); + e1 = e->E1; + e2 = e->E2; + if (*pretregs == 0) /* if don't want result */ + { c = codelem(e1,pretregs,FALSE); /* eval left leaf */ + *pretregs = 0; /* in case they got set */ + return cat(c,codelem(e2,pretregs,FALSE)); + } + + ty1 = tybasic(e1->Ety); + if (tyfloating(ty1)) + { + if (*pretregs & XMMREGS || tyvector(ty1)) + return orthxmm(e,pretregs); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + return orth87(e,pretregs); +#else + return opdouble(e,pretregs,(e->Eoper == OPadd) ? CLIBdadd + : CLIBdsub); +#endif + } + if (tyxmmreg(ty1)) + return orthxmm(e,pretregs); + tym_t ty2 = tybasic(e2->Ety); + int e2oper = e2->Eoper; + tym_t ty = tybasic(e->Ety); + unsigned sz = tysize[ty]; + unsigned byte = (sz == 1); + unsigned char word = (!I16 && sz == SHORTSIZE) ? CFopsize : 0; + unsigned test = FALSE; // assume we destroyed lvalue + code cs; + cs.Iflags = 0; + cs.Irex = 0; + code *cr = CNIL; + + switch (e->Eoper) + { case OPadd: mode = 0; + op1 = 0x03; op2 = 0x13; break; /* ADD, ADC */ + case OPmin: mode = 5; + op1 = 0x2B; op2 = 0x1B; break; /* SUB, SBB */ + case OPor: mode = 1; + op1 = 0x0B; op2 = 0x0B; break; /* OR , OR */ + case OPxor: mode = 6; + op1 = 0x33; op2 = 0x33; break; /* XOR, XOR */ + case OPand: mode = 4; + op1 = 0x23; op2 = 0x23; /* AND, AND */ + if (tyreg(ty1) && + *pretregs == mPSW) /* if flags only */ + { test = TRUE; + op1 = 0x85; /* TEST */ + mode = 0; + } + break; + default: + assert(0); + } + op1 ^= byte; /* if byte operation */ + + /* Compute number of words to operate on. */ + numwords = 1; + if (!I16) + { /* Cannot operate on longs and then do a 'paint' to a far */ + /* pointer, because far pointers are 48 bits and longs are 32. */ + /* Therefore, numwords can never be 2. */ + assert(!(tyfv(ty1) && tyfv(ty2))); + if (sz == 2 * REGSIZE) + { + numwords++; + } + } + else + { /* If ty is a TYfptr, but both operands are long, treat the */ + /* operation as a long. */ +#if TARGET_SEGMENTED + if ((tylong(ty1) || ty1 == TYhptr) && + (tylong(ty2) || ty2 == TYhptr)) + numwords++; +#else + if (tylong(ty1) && tylong(ty2)) + numwords++; +#endif + } + + // Special cases where only flags are set + if (test && tysize[ty1] <= REGSIZE && + (e1->Eoper == OPvar || (e1->Eoper == OPind && !e1->Ecount)) +#if TARGET_OSX + && !movOnly(e1) +#endif + ) + { + // Handle the case of (var & const) + if (e2->Eoper == OPconst && el_signx32(e2)) + { + c = getlvalue(&cs,e1,0); + targ_size_t value = e2->EV.Vpointer; + if (sz == 2) + value &= 0xFFFF; + else if (sz == 4) + value &= 0xFFFFFFFF; + if (reghasvalue(byte ? BYTEREGS : ALLREGS,value,®)) + goto L11; + if (sz == 8 && !I64) + { + assert(value == (int)value); // sign extend imm32 + } + op1 = 0xF7; + cs.IEV2.Vint = value; + cs.IFL2 = FLconst; + goto L10; + } + + // Handle (exp & reg) + if (isregvar(e2,&retregs,®)) + { + c = getlvalue(&cs,e1,0); + L11: + code_newreg(&cs, reg); + if (I64 && byte && reg >= 4) + cs.Irex |= REX; + L10: + cs.Iop = op1 ^ byte; + cs.Iflags |= word | CFpsw; + freenode(e1); + freenode(e2); + return gen(c,&cs); + } + } + + // Look for possible uses of LEA + if (e->Eoper == OPadd && + !(*pretregs & mPSW) && /* flags aren't set by LEA */ + !nest && // could cause infinite recursion if e->Ecount + (sz == REGSIZE || (I64 && sz == 4))) // far pointers aren't handled + { + unsigned rex = (sz == 8) ? REX_W : 0; + + // Handle the case of (e + &var) + int e1oper = e1->Eoper; + if ((e2oper == OPrelconst && (config.target_cpu >= TARGET_Pentium || (!e2->Ecount && stackfl[el_fl(e2)]))) + || // LEA costs too much for simple EAs on older CPUs + (e2oper == OPconst && (e1->Eoper == OPcall || e1->Eoper == OPcallns) && !(*pretregs & mAX)) || + (!I16 && (isscaledindex(e1) || isscaledindex(e2))) || + (!I16 && e1oper == OPvar && e1->EV.sp.Vsym->Sfl == FLreg && (e2oper == OPconst || (e2oper == OPvar && e2->EV.sp.Vsym->Sfl == FLreg))) || + (e2oper == OPconst && e1oper == OPeq && e1->E1->Eoper == OPvar) || + (!I16 && (e2oper == OPrelconst || e2oper == OPconst) && !e1->Ecount && + (e1oper == OPmul || e1oper == OPshl) && + e1->E2->Eoper == OPconst && + ssindex(e1oper,e1->E2->EV.Vuns) + ) || + (!I16 && e1->Ecount) + ) + { + int inc = e->Ecount != 0; + nest += inc; + c = getlvalue(&cs,e,0); + nest -= inc; + unsigned reg; + c = cat(c,allocreg(pretregs,®,ty)); + cs.Iop = 0x8D; + code_newreg(&cs, reg); + c = gen(c,&cs); // LEA reg,EA + if (rex) + code_orrex(c, rex); + return c; + } + + // Handle the case of ((e + c) + e2) + if (!I16 && + e1oper == OPadd && + (e1->E2->Eoper == OPconst && el_signx32(e1->E2) || + e2oper == OPconst && el_signx32(e2)) && + !e1->Ecount + ) + { elem *e11; + elem *ebase; + elem *edisp; + int ss; + int ss2; + unsigned reg1,reg2; + code *c1,*c2,*c3; + + if (e2oper == OPconst && el_signx32(e2)) + { edisp = e2; + ebase = e1->E2; + } + else + { edisp = e1->E2; + ebase = e2; + } + + e11 = e1->E1; + retregs = *pretregs & ALLREGS; + if (!retregs) + retregs = ALLREGS; + ss = 0; + ss2 = 0; + + // Handle the case of (((e * c1) + c2) + e2) + // Handle the case of (((e << c1) + c2) + e2) + if ((e11->Eoper == OPmul || e11->Eoper == OPshl) && + e11->E2->Eoper == OPconst && + !e11->Ecount + ) + { + targ_size_t co1 = el_tolong(e11->E2); + if (e11->Eoper == OPshl) + { + if (co1 > 3) + goto L13; + ss = co1; + } + else + { + ss2 = 1; + switch (co1) + { + case 6: ss = 1; break; + case 12: ss = 1; ss2 = 2; break; + case 24: ss = 1; ss2 = 3; break; + case 10: ss = 2; break; + case 20: ss = 2; ss2 = 2; break; + case 40: ss = 2; ss2 = 3; break; + case 18: ss = 3; break; + case 36: ss = 3; ss2 = 2; break; + case 72: ss = 3; ss2 = 3; break; + default: + ss2 = 0; + goto L13; + } + } + freenode(e11->E2); + freenode(e11); + e11 = e11->E1; + goto L13; + } + else + { + L13: + regm_t regm; + if (e11->Eoper == OPvar && isregvar(e11,®m,®1)) + { + if (tysize[tybasic(e11->Ety)]<= REGSIZE) + retregs = mask[reg1]; // only want the LSW + else + retregs = regm; + c1 = NULL; + freenode(e11); + } + else + c1 = codelem(e11,&retregs,FALSE); + } + rretregs = ALLREGS & ~retregs; + c2 = scodelem(ebase,&rretregs,retregs,TRUE); + { + regm_t sregs = *pretregs & ~rretregs; + if (!sregs) + sregs = ALLREGS & ~rretregs; + c3 = allocreg(&sregs,®,ty); + } + + assert((retregs & (retregs - 1)) == 0); // must be only one register + assert((rretregs & (rretregs - 1)) == 0); // must be only one register + + reg1 = findreg(retregs); + reg2 = findreg(rretregs); + + if (ss2) + { + assert(reg != reg2); + if ((reg1 & 7) == BP) + { static unsigned imm32[4] = {1+1,2+1,4+1,8+1}; + + // IMUL reg,imm32 + c = genc2(CNIL,0x69,modregxrmx(3,reg,reg1),imm32[ss]); + } + else + { // LEA reg,[reg1*ss][reg1] + c = gen2sib(CNIL,0x8D,modregxrm(0,reg,4),modregrm(ss,reg1 & 7,reg1 & 7)); + if (reg1 & 8) + code_orrex(c, REX_X | REX_B); + } + if (rex) + code_orrex(c, rex); + reg1 = reg; + ss = ss2; // use *2 for scale + } + else + c = NULL; + c = cat4(c1,c2,c3,c); + + cs.Iop = 0x8D; // LEA reg,c[reg1*ss][reg2] + cs.Irm = modregrm(2,reg & 7,4); + cs.Isib = modregrm(ss,reg1 & 7,reg2 & 7); + assert(reg2 != BP); + cs.Iflags = CFoff; + cs.Irex = rex; + if (reg & 8) + cs.Irex |= REX_R; + if (reg1 & 8) + cs.Irex |= REX_X; + if (reg2 & 8) + cs.Irex |= REX_B; + cs.IFL1 = FLconst; + cs.IEV1.Vsize_t = edisp->EV.Vuns; + + freenode(edisp); + freenode(e1); + c = gen(c,&cs); + return cat(c,fixresult(e,mask[reg],pretregs)); + } + } + + posregs = (byte) ? BYTEREGS : (mES | ALLREGS | mBP); + retregs = *pretregs & posregs; + if (retregs == 0) /* if no return regs speced */ + /* (like if wanted flags only) */ + retregs = ALLREGS & posregs; // give us some + + if (tysize[ty1] > REGSIZE && numwords == 1) + { /* The only possibilities are (TYfptr + tyword) or (TYfptr - tyword) */ +#if DEBUG + if (tysize[ty2] != REGSIZE) + { printf("e = %p, e->Eoper = ",e); + WROP(e->Eoper); + printf(" e1->Ety = "); + WRTYxx(ty1); + printf(" e2->Ety = "); + WRTYxx(ty2); + printf("\n"); + elem_print(e); + } +#endif + assert(tysize[ty2] == REGSIZE); + +#if TARGET_SEGMENTED + /* Watch out for the case here where you are going to OP reg,EA */ + /* and both the reg and EA use ES! Prevent this by forcing */ + /* reg into the regular registers. */ + if ((e2oper == OPind || + (e2oper == OPvar && el_fl(e2) == FLfardata)) && + !e2->Ecount) + { + retregs = ALLREGS; + } +#endif + + cl = codelem(e1,&retregs,test); + reg = findreglsw(retregs); /* reg is the register with the offset*/ + } +#if TARGET_SEGMENTED + else if (ty1 == TYhptr || ty2 == TYhptr) + { /* Generate code for add/subtract of huge pointers. + No attempt is made to generate very good code. + */ + unsigned mreg,lreg; + unsigned lrreg; + + retregs = (retregs & mLSW) | mDX; + if (ty1 == TYhptr) + { // hptr +- long + rretregs = mLSW & ~(retregs | regcon.mvar); + if (!rretregs) + rretregs = mLSW; + rretregs |= mCX; + cl = codelem(e1,&rretregs,0); + retregs &= ~rretregs; + if (!(retregs & mLSW)) + retregs |= mLSW & ~rretregs; + + cr = scodelem(e2,&retregs,rretregs,TRUE); + } + else + { // long + hptr + cl = codelem(e1,&retregs,0); + rretregs = (mLSW | mCX) & ~retregs; + if (!(rretregs & mLSW)) + rretregs |= mLSW; + cr = scodelem(e2,&rretregs,retregs,TRUE); + } + cg = getregs(rretregs | retregs); + mreg = DX; + lreg = findreglsw(retregs); + c = CNIL; + if (e->Eoper == OPmin) + { // negate retregs + c = gen2(c,0xF7,modregrm(3,3,mreg)); // NEG mreg + gen2(c,0xF7,modregrm(3,3,lreg)); // NEG lreg + code_orflag(c,CFpsw); + genc2(c,0x81,modregrm(3,3,mreg),0); // SBB mreg,0 + } + lrreg = findreglsw(rretregs); + c = genregs(c,0x03,lreg,lrreg); // ADD lreg,lrreg + code_orflag(c,CFpsw); + genmovreg(c,lrreg,CX); // MOV lrreg,CX + genc2(c,0x81,modregrm(3,2,mreg),0); // ADC mreg,0 + genshift(c); // MOV CX,offset __AHSHIFT + gen2(c,0xD3,modregrm(3,4,mreg)); // SHL mreg,CL + genregs(c,0x03,mreg,lrreg); // ADD mreg,MSREG(h) + goto L5; + } +#endif + else + { regm_t regm; + + /* if (tyword + TYfptr) */ + if (tysize[ty1] == REGSIZE && tysize[ty2] > REGSIZE) + { retregs = ~*pretregs & ALLREGS; + + /* if retregs doesn't have any regs in it that aren't reg vars */ + if ((retregs & ~regcon.mvar) == 0) + retregs |= mAX; + } + else if (numwords == 2 && retregs & mES) + retregs = (retregs | mMSW) & ALLREGS; + + // Determine if we should swap operands, because + // mov EAX,x + // add EAX,reg + // is faster than: + // mov EAX,reg + // add EAX,x + else if (e2oper == OPvar && + e1->Eoper == OPvar && + e->Eoper != OPmin && + isregvar(e1,®m,NULL) && + regm != retregs && + tysize[ty1] == tysize[ty2]) + { + elem *es = e1; + e1 = e2; + e2 = es; + } + cl = codelem(e1,&retregs,test); /* eval left leaf */ + reg = findreg(retregs); + } + switch (e2oper) + { + case OPind: /* if addressing mode */ + if (!e2->Ecount) /* if not CSE */ + goto L1; /* try OP reg,EA */ + /* FALL-THROUGH */ + default: /* operator node */ + L2: + rretregs = ALLREGS & ~retregs; + /* Be careful not to do arithmetic on ES */ + if (tysize[ty1] == REGSIZE && tysize[ty2] > REGSIZE && *pretregs != mPSW) + rretregs = *pretregs & (mES | ALLREGS | mBP) & ~retregs; + else if (byte) + rretregs &= BYTEREGS; + + cr = scodelem(e2,&rretregs,retregs,TRUE); /* get rvalue */ + rreg = (tysize[ty2] > REGSIZE) ? findreglsw(rretregs) : findreg(rretregs); + c = CNIL; + if (numwords == 1) /* ADD reg,rreg */ + { + /* reverse operands to avoid moving around the segment value */ + if (tysize[ty2] > REGSIZE) + { c = cat(c,getregs(rretregs)); + c = genregs(c,op1,rreg,reg); + retregs = rretregs; /* reverse operands */ + } + else + { c = genregs(c,op1,reg,rreg); + if (!I16 && *pretregs & mPSW) + c->Iflags |= word; + } + if (I64 && sz == 8) + code_orrex(c, REX_W); + if (I64 && byte && (reg >= 4 || rreg >= 4)) + code_orrex(c, REX); + } + else /* numwords == 2 */ /* ADD lsreg,lsrreg */ + { + reg = findreglsw(retregs); + rreg = findreglsw(rretregs); + c = genregs(c,op1,reg,rreg); + if (e->Eoper == OPadd || e->Eoper == OPmin) + code_orflag(c,CFpsw); + reg = findregmsw(retregs); + rreg = findregmsw(rretregs); + if (!(e2oper == OPu16_32 && // if second operand is 0 + (op2 == 0x0B || op2 == 0x33)) // and OR or XOR + ) + genregs(c,op2,reg,rreg); // ADC msreg,msrreg + } + break; + + case OPrelconst: + if (sz != REGSIZE) + goto L2; + if (segfl[el_fl(e2)] != 3) /* if not in data segment */ + goto L2; + if (evalinregister(e2)) + goto L2; + cs.IEVoffset2 = e2->EV.sp.Voffset; + cs.IEVsym2 = e2->EV.sp.Vsym; + cs.Iflags |= CFoff; + i = 0; /* no INC or DEC opcode */ + rval = 0; + goto L3; + + case OPconst: + if (tyfv(ty2)) + goto L2; + if (numwords == 1) + { + if (!el_signx32(e2)) + goto L2; + i = e2->EV.Vpointer; + if (word) + { + if (!(*pretregs & mPSW) && + config.flags4 & CFG4speed && + (e->Eoper == OPor || e->Eoper == OPxor || test || + (e1->Eoper != OPvar && e1->Eoper != OPind))) + { word = 0; + i &= 0xFFFF; + } + } + rval = reghasvalue(byte ? BYTEREGS : ALLREGS,i,&rreg); + cs.IEV2.Vint = i; + L3: + op1 ^= byte; + cs.Iflags |= word; + if (rval) + { cs.Iop = op1 ^ 2; + mode = rreg; + } + else + cs.Iop = 0x81; + cs.Irm = modregrm(3,mode&7,reg&7); + if (mode & 8) + cs.Irex |= REX_R; + if (reg & 8) + cs.Irex |= REX_B; + if (I64 && sz == 8) + cs.Irex |= REX_W; + if (I64 && byte && (reg >= 4 || (rval && rreg >= 4))) + cs.Irex |= REX; + cs.IFL2 = (e2->Eoper == OPconst) ? FLconst : el_fl(e2); + /* Modify instruction for special cases */ + switch (e->Eoper) + { case OPadd: + { int iop; + + if (i == 1) + iop = 0; /* INC reg */ + else if (i == -1) + iop = 8; /* DEC reg */ + else + break; + cs.Iop = (0x40 | iop | reg) ^ byte; + if ((byte && *pretregs & mPSW) || I64) + { cs.Irm = modregrm(3,0,reg & 7) | iop; + cs.Iop = 0xFF; + } + break; + } + case OPand: + if (test) + cs.Iop = rval ? op1 : 0xF7; // TEST + break; + } + if (*pretregs & mPSW) + cs.Iflags |= CFpsw; + cs.Iop ^= byte; + c = gen(CNIL,&cs); + cs.Iflags &= ~CFpsw; + } + else if (numwords == 2) + { unsigned lsreg; + targ_int msw; + + c = getregs(retregs); + reg = findregmsw(retregs); + lsreg = findreglsw(retregs); + cs.Iop = 0x81; + cs.Irm = modregrm(3,mode,lsreg); + cs.IFL2 = FLconst; + msw = MSREG(e2->EV.Vllong); + cs.IEV2.Vint = e2->EV.Vlong; + switch (e->Eoper) + { case OPadd: + case OPmin: + cs.Iflags |= CFpsw; + break; + } + c = gen(c,&cs); + cs.Iflags &= ~CFpsw; + + cs.Irm = (cs.Irm & modregrm(3,7,0)) | reg; + cs.IEV2.Vint = msw; + if (e->Eoper == OPadd) + cs.Irm |= modregrm(0,2,0); /* ADC */ + c = gen(c,&cs); + } + else + assert(0); + freenode(e2); + break; + + case OPvar: +#if TARGET_OSX + if (movOnly(e2)) + goto L2; +#endif + L1: + if (tyfv(ty2)) + goto L2; + c = loadea(e2,&cs,op1, + ((numwords == 2) ? findreglsw(retregs) : reg), + 0,retregs,retregs); + if (!I16 && word) + { if (*pretregs & mPSW) + code_orflag(c,word); + else + { + code *ce = code_last(c); + ce->Iflags &= ~word; + } + } + else if (numwords == 2) + { + if (e->Eoper == OPadd || e->Eoper == OPmin) + code_orflag(c,CFpsw); + reg = findregmsw(retregs); + if (EOP(e2)) + { getlvalue_msw(&cs); + cs.Iop = op2; + NEWREG(cs.Irm,reg); + c = gen(c,&cs); /* ADC reg,data+2 */ + } + else + c = cat(c,loadea(e2,&cs,op2,reg,REGSIZE,retregs,0)); + } + else if (I64 && sz == 8) + code_orrex(c, REX_W); + freenode(e2); + break; + } + if (sz <= REGSIZE && *pretregs & mPSW) + { + /* If the expression is (_tls_array + ...), then the flags are not set + * since the linker may rewrite these instructions into something else. + */ + if (I64 && e->Eoper == OPadd && e1->Eoper == OPvar) + { + symbol *s = e1->EV.sp.Vsym; + if (s->Sident[0] == '_' && memcmp(s->Sident + 1,"tls_array",10) == 0) + { + goto L7; // don't assume flags are set + } + } + code_orflag(c,CFpsw); + *pretregs &= ~mPSW; /* flags already set */ + L7: ; + } + if (test) + cg = NULL; /* didn't destroy any */ + else + cg = getregs(retregs); /* we will trash these regs */ +L5: + c = cat(c,fixresult(e,retregs,pretregs)); + return cat4(cl,cr,cg,c); +} + + +/***************************** + * Handle multiply, divide, modulo and remquo. + * Note that modulo isn't defined for doubles. + */ + +code *cdmul(elem *e,regm_t *pretregs) +{ unsigned rreg,op,oper,lib,byte; + regm_t resreg,retregs,rretregs; + regm_t keepregs; + tym_t uns; // 1 if unsigned operation, 0 if not + tym_t tyml; + code *c,*cg,*cl,*cr,cs; + elem *e1,*e2; + int sz; + targ_size_t e2factor; + int opunslng; + int pow2; + + if (*pretregs == 0) // if don't want result + { c = codelem(e->E1,pretregs,FALSE); // eval left leaf + *pretregs = 0; // in case they got set + return cat(c,codelem(e->E2,pretregs,FALSE)); + } + + //printf("cdmul(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + keepregs = 0; + cs.Iflags = 0; + cs.Irex = 0; + c = cg = cr = CNIL; // initialize + e2 = e->E2; + e1 = e->E1; + tyml = tybasic(e1->Ety); + sz = tysize[tyml]; + byte = tybyte(e->Ety) != 0; + uns = tyuns(tyml) || tyuns(e2->Ety); + oper = e->Eoper; + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + unsigned grex = rex << 16; + + if (tyfloating(tyml)) + { + if (*pretregs & XMMREGS && oper != OPmod && tyxmmreg(tyml)) + return orthxmm(e,pretregs); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + return orth87(e,pretregs); +#else + return opdouble(e,pretregs,(oper == OPmul) ? CLIBdmul : CLIBddiv); +#endif + } + + if (tyxmmreg(tyml)) + return orthxmm(e,pretregs); + + opunslng = I16 ? OPu16_32 : OPu32_64; + switch (oper) + { + case OPmul: + resreg = mAX; + op = 5 - uns; + lib = CLIBlmul; + break; + + case OPdiv: + resreg = mAX; + op = 7 - uns; + lib = uns ? CLIBuldiv : CLIBldiv; + if (I32) + keepregs |= mSI | mDI; + break; + + case OPmod: + resreg = mDX; + op = 7 - uns; + lib = uns ? CLIBulmod : CLIBlmod; + if (I32) + keepregs |= mSI | mDI; + break; + + case OPremquo: + resreg = mDX | mAX; + op = 7 - uns; + lib = uns ? CLIBuldiv : CLIBldiv; + if (I32) + keepregs |= mSI | mDI; + break; + + default: + assert(0); + } + + if (sz <= REGSIZE) // dedicated regs for mul & div + { retregs = mAX; + /* pick some other regs */ + rretregs = byte ? BYTEREGS & ~mAX + : ALLREGS & ~(mAX|mDX); + } + else + { + assert(sz <= 2 * REGSIZE); + retregs = mDX | mAX; + rretregs = mCX | mBX; // second arg + } + + switch (e2->Eoper) + { + case OPu16_32: + case OPs16_32: + case OPu32_64: + case OPs32_64: + if (sz != 2 * REGSIZE || oper != OPmul || e1->Eoper != e2->Eoper || + e1->Ecount || e2->Ecount) + goto L2; + op = (e2->Eoper == opunslng) ? 4 : 5; + retregs = mAX; + cl = codelem(e1->E1,&retregs,FALSE); /* eval left leaf */ + if (e2->E1->Eoper == OPvar || + (e2->E1->Eoper == OPind && !e2->E1->Ecount) + ) + { + cr = loadea(e2->E1,&cs,0xF7,op,0,mAX,mAX | mDX); + } + else + { + rretregs = ALLREGS & ~mAX; + cr = scodelem(e2->E1,&rretregs,retregs,TRUE); // get rvalue + cg = getregs(mAX | mDX); + rreg = findreg(rretregs); + cg = gen2(cg,0xF7,grex | modregrmx(3,op,rreg)); // OP AX,rreg + } + freenode(e->E1); + freenode(e2); + c = fixresult(e,mAX | mDX,pretregs); + break; + + case OPconst: + e2factor = el_tolong(e2); + + if (oper == OPmul && I32 && sz == REGSIZE * 2) + { targ_int msw,lsw; + regm_t scratch; + unsigned reg; + targ_llong e2factor; + + cl = codelem(e1,&retregs,FALSE); // eval left leaf + /* IMUL EDX,EDX,lsw + IMUL reg,EAX,msw + ADD reg,EDX + MOV EDX,lsw + MUL EDX + ADD EDX,reg + + if (msw == 0) + IMUL reg,EDX,lsw + MOV EDX,lsw + MUL EDX + ADD EDX,reg + */ + scratch = allregs & ~(mAX | mDX); + cr = allocreg(&scratch,®,TYint); + cg = getregs(mDX | mAX); + + e2factor = el_tolong(e2); + lsw = e2factor & ((1LL << (REGSIZE * 8)) - 1); + msw = e2factor >> (REGSIZE * 8); + + if (msw) + { cg = genmulimm(cg,DX,DX,lsw); + cg = genmulimm(cg,reg,AX,msw); + cg = gen2(cg,0x03,modregrm(3,reg,DX)); + } + else + cg = genmulimm(cg,reg,DX,lsw); + + cg = movregconst(cg,DX,lsw,0); // MOV EDX,lsw + cg = cat(cg,getregs(mDX)); + cg = gen2(cg,0xF7,modregrm(3,4,DX)); // MUL EDX + gen2(cg,0x03,modregrm(3,DX,reg)); // ADD EDX,reg + + resreg = mDX | mAX; + freenode(e2); + goto L3; + } + + if (oper != OPmul && e2factor == 10 && + (!I16 && sz == 4) && + config.flags4 & CFG4speed && !uns) + { + /* R1 / 10 + * + * MOV EAX,0x66666667 + * IMUL R1 + * MOV EAX,R1 + * SAR EAX,31 + * SAR EDX,2 + * SUB EDX,EAX + * IMUL EAX,EDX,10 + * SUB R1,EAX + * + * EDX = quotient + * R1 = remainder + */ + regm_t regm; + unsigned reg; + + regm = allregs & ~(mAX | mDX); + cl = codelem(e1,®m,FALSE); // eval left leaf + reg = findreg(regm); + cg = getregs(regm | mDX | mAX); + + cg = movregconst(cg, AX, 0x66666667, 0); // MOV EAX,0x66666667 + cg = gen2(cg,0xF7,modregrmx(3,5,reg)); // IMUL R1 + genmovreg(cg, AX, reg); // MOV EAX,R1 + genc2(cg,0xC1,modregrm(3,7,AX),31); // SAR EAX,31 + genc2(cg,0xC1,modregrm(3,7,DX),2); // SAR EDX,2 + gen2(cg,0x2B,modregrm(3,DX,AX)); // SUB EDX,EAX + + switch (oper) + { case OPdiv: + resreg = mDX; + break; + + case OPmod: + genmulimm(cg,AX,DX,10); // IMUL EAX,EDX,10 + gen2(cg,0x2B,modregxrm(3,reg,AX)); // SUB R1,EAX + resreg = regm; + break; + + case OPremquo: + genmulimm(cg,AX,DX,10); // IMUL EAX,EDX,10 + gen2(cg,0x2B,modregxrm(3,reg,AX)); // SUB R1,EAX + genmovreg(cg, AX, DX); // MOV EAX,EDX + genmovreg(cg, DX, reg); // MOV EDX,R1 + resreg = mDX | mAX; + break; + + default: + assert(0); + } + freenode(e2); + goto L3; + } + + if (sz > REGSIZE || !el_signx32(e2)) + goto L2; + + if (oper == OPmul && config.target_cpu >= TARGET_80286) + { unsigned reg; + int ss; + + freenode(e2); + retregs = byte ? BYTEREGS : ALLREGS; + resreg = *pretregs & (ALLREGS | mBP); + if (!resreg) + resreg = retregs; + + if (!I16) + { // See if we can use an LEA instruction + int ss2 = 0; + int shift; + + switch (e2factor) + { + case 12: ss = 1; ss2 = 2; goto L4; + case 24: ss = 1; ss2 = 3; goto L4; + + case 6: + case 3: ss = 1; goto L4; + + case 20: ss = 2; ss2 = 2; goto L4; + case 40: ss = 2; ss2 = 3; goto L4; + + case 10: + case 5: ss = 2; goto L4; + + case 36: ss = 3; ss2 = 2; goto L4; + case 72: ss = 3; ss2 = 3; goto L4; + + case 18: + case 9: ss = 3; goto L4; + + L4: + { +#if 1 + regm_t regm = byte ? BYTEREGS : ALLREGS; + regm &= ~(mBP | mR13); // don't use EBP + cl = codelem(e->E1,®m,TRUE); + unsigned r = findreg(regm); + + if (ss2) + { // Don't use EBP + resreg &= ~(mBP | mR13); + if (!resreg) + resreg = retregs; + } + cg = allocreg(&resreg,®,tyml); + + c = gen2sib(CNIL,0x8D,grex | modregxrm(0,reg,4), + modregxrmx(ss,r,r)); + assert((r & 7) != BP); + if (ss2) + { + gen2sib(c,0x8D,grex | modregxrm(0,reg,4), + modregxrm(ss2,reg,5)); + code_last(c)->IFL1 = FLconst; + code_last(c)->IEV1.Vint = 0; + } + else if (!(e2factor & 1)) // if even factor + { genregs(c,0x03,reg,reg); // ADD reg,reg + code_orrex(c,rex); + } + cg = cat(cg,c); + goto L3; +#else + + // Don't use EBP + resreg &= ~mBP; + if (!resreg) + resreg = retregs; + + cl = codelem(e->E1,&resreg,FALSE); + reg = findreg(resreg); + cg = getregs(resreg); + c = gen2sib(CNIL,0x8D,modregrm(0,reg,4), + modregrm(ss,reg,reg)); + if (ss2) + { + gen2sib(c,0x8D,modregrm(0,reg,4), + modregrm(ss2,reg,5)); + code_last(c)->IFL1 = FLconst; + code_last(c)->IEV1.Vint = 0; + } + else if (!(e2factor & 1)) // if even factor + genregs(c,0x03,reg,reg); // ADD reg,reg + cg = cat(cg,c); + goto L3; +#endif + } + case 37: + case 74: shift = 2; + goto L5; + case 13: + case 26: shift = 0; + goto L5; + L5: + { + // Don't use EBP + resreg &= ~(mBP | mR13); + if (!resreg) + resreg = retregs; + cl = allocreg(&resreg,®,TYint); + + regm_t sregm = (ALLREGS & ~mR13) & ~resreg; + cl = cat(cl,codelem(e->E1,&sregm,FALSE)); + unsigned sreg = findreg(sregm); + cg = getregs(resreg | sregm); + // LEA reg,[sreg * 4][sreg] + // SHL sreg,shift + // LEA reg,[sreg * 8][reg] + assert((sreg & 7) != BP); + assert((reg & 7) != BP); + c = gen2sib(CNIL,0x8D,grex | modregxrm(0,reg,4), + modregxrmx(2,sreg,sreg)); + if (shift) + genc2(c,0xC1,grex | modregrmx(3,4,sreg),shift); + gen2sib(c,0x8D,grex | modregxrm(0,reg,4), + modregxrmx(3,sreg,reg)); + if (!(e2factor & 1)) // if even factor + { genregs(c,0x03,reg,reg); // ADD reg,reg + code_orrex(c,rex); + } + cg = cat(cg,c); + goto L3; + } + } + } + + cl = scodelem(e->E1,&retregs,0,TRUE); // eval left leaf + reg = findreg(retregs); + cg = allocreg(&resreg,&rreg,e->Ety); + + /* IMUL reg,imm16 */ + cg = genc2(cg,0x69,grex | modregxrmx(3,rreg,reg),e2factor); + goto L3; + } + + // Special code for signed divide or modulo by power of 2 + if ((sz == REGSIZE || (I64 && sz == 4)) && + (oper == OPdiv || oper == OPmod) && !uns && + (pow2 = ispow2(e2factor)) != -1 && + !(config.target_cpu < TARGET_80286 && pow2 != 1 && oper == OPdiv) + ) + { + if (pow2 == 1 && oper == OPdiv && config.target_cpu > TARGET_80386) + { + // test eax,eax + // jns L1 + // add eax,1 + // L1: sar eax,1 + + code *cnop; + + retregs = allregs; + cl = codelem(e->E1,&retregs,FALSE); // eval left leaf + unsigned reg = findreg(retregs); + freenode(e2); + cg = getregs(retregs); + cg = gentstreg(cg,reg); // TEST reg,reg + code_orrex(cg, rex); + cnop = gennop(CNIL); + genjmp(cg,JNS,FLcode,(block *)cnop); // JNS cnop + if (I64) + { + gen2(cg,0xFF,modregrmx(3,0,reg)); // INC reg + code_orrex(cg,rex); + } + else + gen1(cg,0x40 + reg); // INC reg + cg = cat(cg,cnop); + gen2(cg,0xD1,grex | modregrmx(3,7,reg)); // SAR reg,1 + resreg = retregs; + goto L3; + } + cl = codelem(e->E1,&retregs,FALSE); // eval left leaf + freenode(e2); + cg = getregs(mAX | mDX); // trash these regs + cg = gen1(cg,0x99); // CWD + code_orrex(cg, rex); + if (pow2 == 1) + { + if (oper == OPdiv) + { gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + gen2(cg,0xD1,grex | modregrm(3,7,AX)); // SAR AX,1 + } + else // OPmod + { gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + genc2(cg,0x81,grex | modregrm(3,4,AX),1); // AND AX,1 + gen2(cg,0x03,grex | modregrm(3,DX,AX)); // ADD DX,AX + } + } + else + { targ_ulong m; + + m = (1 << pow2) - 1; + if (oper == OPdiv) + { genc2(cg,0x81,grex | modregrm(3,4,DX),m); // AND DX,m + gen2(cg,0x03,grex | modregrm(3,AX,DX)); // ADD AX,DX + // Be careful not to generate this for 8088 + assert(config.target_cpu >= TARGET_80286); + genc2(cg,0xC1,grex | modregrm(3,7,AX),pow2); // SAR AX,pow2 + } + else // OPmod + { gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + genc2(cg,0x81,grex | modregrm(3,4,AX),m); // AND AX,mask + gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + resreg = mAX; + } + } + goto L3; + } + goto L2; + case OPind: + if (!e2->Ecount) /* if not CSE */ + goto L1; /* try OP reg,EA */ + goto L2; + default: /* OPconst and operators */ + L2: + //printf("test2 %p, retregs = %s rretregs = %s resreg = %s\n", e, regm_str(retregs), regm_str(rretregs), regm_str(resreg)); + cl = codelem(e1,&retregs,FALSE); /* eval left leaf */ + cr = scodelem(e2,&rretregs,retregs,TRUE); /* get rvalue */ + if (sz <= REGSIZE) + { cg = getregs(mAX | mDX); /* trash these regs */ + if (op == 7) /* signed divide */ + { cg = gen1(cg,0x99); // CWD + code_orrex(cg,rex); + } + else if (op == 6) /* unsigned divide */ + { + cg = movregconst(cg,DX,0,(sz == 8) ? 64 : 0); // MOV DX,0 + cg = cat(cg,getregs(mDX)); + } + rreg = findreg(rretregs); + cg = gen2(cg,0xF7 ^ byte,grex | modregrmx(3,op,rreg)); // OP AX,rreg + if (I64 && byte && rreg >= 4) + code_orrex(cg, REX); + L3: + c = fixresult(e,resreg,pretregs); + } + else if (sz == 2 * REGSIZE) + { + if (config.target_cpu >= TARGET_PentiumPro && oper == OPmul) + { + /* IMUL ECX,EAX + IMUL EDX,EBX + ADD ECX,EDX + MUL EBX + ADD EDX,ECX + */ + cg = getregs(mAX|mDX|mCX); + cg = gen2(cg,0x0FAF,modregrm(3,CX,AX)); + gen2(cg,0x0FAF,modregrm(3,DX,BX)); + gen2(cg,0x03,modregrm(3,CX,DX)); + gen2(cg,0xF7,modregrm(3,4,BX)); + gen2(cg,0x03,modregrm(3,DX,CX)); + c = fixresult(e,mDX|mAX,pretregs); + } + else + c = callclib(e,lib,pretregs,keepregs); + } + else + assert(0); + break; + case OPvar: + L1: + if (!I16 && sz <= REGSIZE) + { + if (oper == OPmul && sz > 1) /* no byte version */ + { + /* Generate IMUL r32,r/m32 */ + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + cl = codelem(e1,&retregs,FALSE); /* eval left leaf */ + resreg = retregs; + cr = loadea(e2,&cs,0x0FAF,findreg(resreg),0,retregs,retregs); + freenode(e2); + goto L3; + } + } + else + { + if (sz == 2 * REGSIZE) + { int reg; + + if (oper != OPmul || e->E1->Eoper != opunslng || + e1->Ecount) + goto L2; // have to handle it with codelem() + + retregs = ALLREGS & ~(mAX | mDX); + cl = codelem(e1->E1,&retregs,FALSE); // eval left leaf + reg = findreg(retregs); + cl = cat(cl,getregs(mAX)); + cl = genmovreg(cl,AX,reg); // MOV AX,reg + cr = loadea(e2,&cs,0xF7,4,REGSIZE,mAX | mDX | mskl(reg),mAX | mDX); // MUL EA+2 + cg = getregs(retregs); + cg = gen1(cg,0x90 + reg); // XCHG AX,reg + cg = cat(cg,getregs(mAX | mDX)); + if ((cs.Irm & 0xC0) == 0xC0) // if EA is a register + cg = cat(cg,loadea(e2,&cs,0xF7,4,0,mAX | mskl(reg),mAX | mDX)); // MUL EA + else + { getlvalue_lsw(&cs); + gen(cg,&cs); // MUL EA + } + gen2(cg,0x03,modregrm(3,DX,reg)); // ADD DX,reg + + freenode(e1); + c = fixresult(e,mAX | mDX,pretregs); + break; + } + assert(sz <= REGSIZE); + } + + /* loadea() handles CWD or CLR DX for divides */ + cl = codelem(e->E1,&retregs,FALSE); /* eval left leaf */ + cr = loadea(e2,&cs,0xF7 ^ byte,op,0, + (oper == OPmul) ? mAX : mAX | mDX, + mAX | mDX); + freenode(e2); + goto L3; + } + return cat4(cl,cr,cg,c); +} + + +/*************************** + * Handle OPnot and OPbool. + * Generate: + * c: [evaluate e1] + * cfalse: [save reg code] + * clr reg + * jmp cnop + * ctrue: [save reg code] + * clr reg + * inc reg + * cnop: nop + */ + +code *cdnot(elem *e,regm_t *pretregs) +{ unsigned reg; + tym_t forflags; + code *c1,*c,*cfalse,*ctrue,*cnop; + unsigned sz; + regm_t retregs; + elem *e1; + int op; + + e1 = e->E1; + if (*pretregs == 0) + goto L1; + if (*pretregs == mPSW) + { /*assert(e->Eoper != OPnot && e->Eoper != OPbool);*/ /* should've been optimized */ + L1: + return codelem(e1,pretregs,FALSE); /* evaluate e1 for cc */ + } + + op = e->Eoper; + sz = tysize(e1->Ety); + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + unsigned grex = rex << 16; + if (!tyfloating(e1->Ety)) + { + if (sz <= REGSIZE && e1->Eoper == OPvar) + { code cs; + + c = getlvalue(&cs,e1,0); + freenode(e1); + if (!I16 && sz == 2) + cs.Iflags |= CFopsize; + + retregs = *pretregs & (ALLREGS | mBP); + if (config.target_cpu >= TARGET_80486 && + tysize(e->Ety) == 1) + { + if (reghasvalue((sz == 1) ? BYTEREGS : ALLREGS,0,®)) + cs.Iop = 0x39; + else + { cs.Iop = 0x81; + reg = 7; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + } + cs.Iop ^= (sz == 1); + code_newreg(&cs,reg); + c = gen(c,&cs); // CMP e1,0 + + retregs &= BYTEREGS; + if (!retregs) + retregs = BYTEREGS; + c1 = allocreg(&retregs,®,TYint); + + int iop; + if (op == OPbool) + { + iop = 0x0F95; // SETNZ rm8 + } + else + { + iop = 0x0F94; // SETZ rm8 + } + c1 = gen2(c1,iop,grex | modregrmx(3,0,reg)); + if (reg >= 4) + code_orrex(c1, REX); + if (op == OPbool) + *pretregs &= ~mPSW; + goto L4; + } + + if (reghasvalue((sz == 1) ? BYTEREGS : ALLREGS,1,®)) + cs.Iop = 0x39; + else + { cs.Iop = 0x81; + reg = 7; + cs.IFL2 = FLconst; + cs.IEV2.Vint = 1; + } + cs.Iop ^= (sz == 1); + code_newreg(&cs,reg); + c = gen(c,&cs); // CMP e1,1 + + c1 = allocreg(&retregs,®,TYint); + op ^= (OPbool ^ OPnot); // switch operators + goto L2; + } + else if (sz <= REGSIZE && + // NEG bytereg is too expensive + (sz != 1 || config.target_cpu < TARGET_PentiumPro)) + { + retregs = *pretregs & (ALLREGS | mBP); + if (sz == 1 && !(retregs &= BYTEREGS)) + retregs = BYTEREGS; + c = codelem(e->E1,&retregs,FALSE); + reg = findreg(retregs); + c1 = getregs(retregs); + c1 = gen2(c1,0xF7 ^ (sz == 1),grex | modregrmx(3,3,reg)); // NEG reg + code_orflag(c1,CFpsw); + if (!I16 && sz == SHORTSIZE) + code_orflag(c1,CFopsize); + L2: + c1 = genregs(c1,0x19,reg,reg); // SBB reg,reg + code_orrex(c1, rex); + // At this point, reg==0 if e1==0, reg==-1 if e1!=0 + if (op == OPnot) + { + if (I64) + gen2(c1,0xFF,grex | modregrmx(3,0,reg)); // INC reg + else + gen1(c1,0x40 + reg); // INC reg + } + else + gen2(c1,0xF7,grex | modregrmx(3,3,reg)); // NEG reg + if (*pretregs & mPSW) + { code_orflag(c1,CFpsw); + *pretregs &= ~mPSW; // flags are always set anyway + } + L4: + return cat3(c,c1,fixresult(e,retregs,pretregs)); + } + } + cnop = gennop(CNIL); + ctrue = gennop(CNIL); + c = logexp(e->E1,(op == OPnot) ? FALSE : TRUE,FLcode,ctrue); + forflags = *pretregs & mPSW; + if (I64 && sz == 8) + forflags |= 64; + assert(tysize(e->Ety) <= REGSIZE); // result better be int + cfalse = allocreg(pretregs,®,e->Ety); // allocate reg for result + for (c1 = cfalse; c1; c1 = code_next(c1)) + gen(ctrue,c1); // duplicate reg save code + cfalse = movregconst(cfalse,reg,0,forflags); // mov 0 into reg + regcon.immed.mval &= ~mask[reg]; // mark reg as unavail + ctrue = movregconst(ctrue,reg,1,forflags); // mov 1 into reg + regcon.immed.mval &= ~mask[reg]; // mark reg as unavail + genjmp(cfalse,JMP,FLcode,(block *) cnop); // skip over ctrue + c = cat4(c,cfalse,ctrue,cnop); + return c; +} + + +/************************ + * Complement operator + */ + +code *cdcom(elem *e,regm_t *pretregs) +{ unsigned reg,op; + regm_t retregs,possregs; + code *c,*c1,*cg; + tym_t tym; + int sz; + + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + tym = tybasic(e->Ety); + sz = tysize[tym]; + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + possregs = (sz == 1) ? BYTEREGS : allregs; + retregs = *pretregs & possregs; + if (retregs == 0) + retregs = possregs; + c1 = codelem(e->E1,&retregs,FALSE); + cg = getregs(retregs); /* retregs will be destroyed */ +#if 0 + if (sz == 4 * REGSIZE) + { + c = gen2(CNIL,0xF7,modregrm(3,2,AX)); // NOT AX + gen2(c,0xF7,modregrm(3,2,BX)); // NOT BX + gen2(c,0xF7,modregrm(3,2,CX)); // NOT CX + gen2(c,0xF7,modregrm(3,2,DX)); // NOT DX + } + else +#endif + { + reg = (sz <= REGSIZE) ? findreg(retregs) : findregmsw(retregs); + op = (sz == 1) ? 0xF6 : 0xF7; + c = genregs(CNIL,op,2,reg); // NOT reg + code_orrex(c, rex); + if (I64 && sz == 1 && reg >= 4) + code_orrex(c, REX); + if (sz == 2 * REGSIZE) + { reg = findreglsw(retregs); + genregs(c,op,2,reg); // NOT reg+1 + } + } + return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); +} + +/************************ + * Bswap operator + */ + +code *cdbswap(elem *e,regm_t *pretregs) +{ unsigned reg,op; + regm_t retregs; + code *c,*c1,*cg; + tym_t tym; + int sz; + + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + + tym = tybasic(e->Ety); + assert(tysize[tym] == 4); + retregs = *pretregs & allregs; + if (retregs == 0) + retregs = allregs; + c1 = codelem(e->E1,&retregs,FALSE); + cg = getregs(retregs); // retregs will be destroyed + reg = findreg(retregs); + c = gen2(CNIL,0x0FC8 + (reg & 7),0); // BSWAP reg + if (reg & 8) + code_orrex(c, REX_B); + return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); +} + +/************************* + * ?: operator + */ + +code *cdcond(elem *e,regm_t *pretregs) +{ regm_t psw; + code *cc,*c,*c1,*cnop1,*c2,*cnop2; + con_t regconold,regconsave; + unsigned stackpushold,stackpushsave; + int ehindexold,ehindexsave; + unsigned jop; + unsigned op1; + unsigned sz1; + unsigned sz2; + elem *e1; + elem *e2; + elem *e21; + elem *e22; + + /* vars to save state of 8087 */ + int stackusedold,stackusedsave; + NDP _8087old[arraysize(_8087elems)]; + NDP _8087save[arraysize(_8087elems)]; + + _chkstack(); + + //printf("cdcond(e = %p, *pretregs = %s)\n",e,regm_str(*pretregs)); + e1 = e->E1; + e2 = e->E2; + e21 = e2->E1; + e22 = e2->E2; + cc = docommas(&e1); + cgstate.stackclean++; + psw = *pretregs & mPSW; /* save PSW bit */ + op1 = e1->Eoper; + sz1 = tysize(e1->Ety); + unsigned rex = (I64 && sz1 == 8) ? REX_W : 0; + unsigned grex = rex << 16; + jop = jmpopcode(e1); + + if (!OTrel(op1) && e1 == e21 && + sz1 <= REGSIZE && !tyfloating(e1->Ety)) + { // Recognize (e ? e : f) + regm_t retregs; + + cnop1 = gennop(CNIL); + retregs = *pretregs | mPSW; + c = codelem(e1,&retregs,FALSE); + + c = cat(c,cse_flush(1)); // flush CSEs to memory + c = genjmp(c,jop,FLcode,(block *)cnop1); + freenode(e21); + + regconsave = regcon; + stackpushsave = stackpush; + + retregs |= psw; + if (retregs & (mBP | ALLREGS)) + regimmed_set(findreg(retregs),0); + c2 = codelem(e22,&retregs,FALSE); + + andregcon(®consave); + assert(stackpushsave == stackpush); + + *pretregs = retregs; + freenode(e2); + c = cat4(cc,c,c2,cnop1); + goto Lret; + } + + if (OTrel(op1) && sz1 <= REGSIZE && tysize(e2->Ety) <= REGSIZE && + !e1->Ecount && + (jop == JC || jop == JNC) && + (sz2 = tysize(e2->Ety)) <= REGSIZE && + e21->Eoper == OPconst && + e22->Eoper == OPconst + ) + { regm_t retregs; + unsigned reg; + targ_size_t v1,v2; + int opcode; + + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + cdcmp_flag = 1; + c = codelem(e1,&retregs,FALSE); + reg = findreg(retregs); + v1 = e21->EV.Vllong; + v2 = e22->EV.Vllong; + if (jop == JNC) + { v1 = v2; + v2 = e21->EV.Vlong; + } + + opcode = 0x81; + switch (sz2) + { case 1: opcode--; + v1 = (signed char) v1; + v2 = (signed char) v2; + break; + case 2: v1 = (short) v1; + v2 = (short) v2; + break; + case 4: v1 = (int) v1; + v2 = (int) v2; + break; + } + + if (v1 == 0 && v2 == ~(targ_size_t)0) + c = gen2(c,0xF6 + (opcode & 1),grex | modregrmx(3,2,reg)); // NOT reg + else + { + v1 -= v2; + c = genc2(c,opcode,grex | modregrmx(3,4,reg),v1); // AND reg,v1-v2 + if (v2 == 1 && !I64) + gen1(c,0x40 + reg); // INC reg + else if (v2 == -1L && !I64) + gen1(c,0x48 + reg); // DEC reg + else + genc2(c,opcode,grex | modregrmx(3,0,reg),v2); // ADD reg,v2 + } + + freenode(e21); + freenode(e22); + freenode(e2); + + c = cat(c,fixresult(e,retregs,pretregs)); + goto Lret; + } + + if (op1 != OPcond && op1 != OPandand && op1 != OPoror && + op1 != OPnot && op1 != OPbool && + e21->Eoper == OPconst && + sz1 <= REGSIZE && + *pretregs & (mBP | ALLREGS) && + tysize(e21->Ety) <= REGSIZE && !tyfloating(e21->Ety)) + { // Recognize (e ? c : f) + unsigned reg; + regm_t retregs; + + cnop1 = gennop(CNIL); + retregs = mPSW; + jop = jmpopcode(e1); // get jmp condition + c = codelem(e1,&retregs,FALSE); + + // Set the register with e21 without affecting the flags + retregs = *pretregs & (ALLREGS | mBP); + if (retregs & ~regcon.mvar) + retregs &= ~regcon.mvar; // don't disturb register variables + // NOTE: see my email (sign extension bug? possible fix, some questions + c = regwithvalue(c,retregs,e21->EV.Vllong,®,tysize(e21->Ety) == 8 ? 64|8 : 8); + retregs = mask[reg]; + + c = cat(c,cse_flush(1)); // flush CSE's to memory + c = genjmp(c,jop,FLcode,(block *)cnop1); + freenode(e21); + + regconsave = regcon; + stackpushsave = stackpush; + + c2 = codelem(e22,&retregs,FALSE); + + andregcon(®consave); + assert(stackpushsave == stackpush); + + freenode(e2); + c = cat6(cc,c,c2,cnop1,fixresult(e,retregs,pretregs),NULL); + goto Lret; + } + + cnop1 = gennop(CNIL); + cnop2 = gennop(CNIL); /* dummy target addresses */ + c = logexp(e1,FALSE,FLcode,cnop1); /* evaluate condition */ + regconold = regcon; + stackusedold = stackused; + stackpushold = stackpush; + memcpy(_8087old,_8087elems,sizeof(_8087elems)); + c1 = codelem(e21,pretregs,FALSE); + +#if SCPP + if (CPP && e2->Eoper == OPcolon2) + { code cs; + + // This is necessary so that any cleanup code on one branch + // is redone on the other branch. + cs.Iop = ESCAPE | ESCmark2; + cs.Iflags = 0; + cs.Irex = 0; + c1 = cat(gen(CNIL,&cs),c1); + cs.Iop = ESCAPE | ESCrelease2; + c1 = gen(c1,&cs); + } +#endif + + regconsave = regcon; + regcon = regconold; + + stackpushsave = stackpush; + stackpush = stackpushold; + + stackusedsave = stackused; + stackused = stackusedold; + + memcpy(_8087save,_8087elems,sizeof(_8087elems)); + memcpy(_8087elems,_8087old,sizeof(_8087elems)); + + *pretregs |= psw; /* PSW bit may have been trashed */ + c2 = codelem(e22,pretregs,FALSE); /* use same regs as E1 */ + andregcon(®conold); + andregcon(®consave); + assert(stackused == stackusedsave); + assert(stackpush == stackpushsave); + memcpy(_8087elems,_8087save,sizeof(_8087elems)); + freenode(e2); + c = cat(cc,c); + c = cat6(c,c1,genjmp(CNIL,JMP,FLcode,(block *) cnop2),cnop1,c2,cnop2); + if (*pretregs & mST0) + note87(e,0,0); +Lret: + cgstate.stackclean--; + return c; +} + +/********************* + * Comma operator + */ + +code *cdcomma(elem *e,regm_t *pretregs) +{ regm_t retregs; + code *cl,*cr; + + retregs = 0; + cl = codelem(e->E1,&retregs,FALSE); /* ignore value from left leaf */ + cr = codelem(e->E2,pretregs,FALSE); /* do right leaf */ + return cat(cl,cr); +} + + +/********************************* + * Do && and || operators. + * Generate: + * (evaluate e1 and e2, if TRUE goto cnop1) + * cnop3: NOP + * cg: [save reg code] ;if we must preserve reg + * CLR reg ;FALSE result (set Z also) + * JMP cnop2 + * + * cnop1: NOP ;if e1 evaluates to TRUE + * [save reg code] ;preserve reg + * + * MOV reg,1 ;TRUE result + * or + * CLR reg ;if return result in flags + * INC reg + * + * cnop2: NOP ;mark end of code + */ + +code *cdloglog(elem *e,regm_t *pretregs) +{ regm_t retregs; + unsigned reg; + code *c; + code *cl,*cr,*cg,*cnop1,*cnop2,*cnop3; + code *c1; + con_t regconsave; + unsigned stackpushsave; + elem *e2; + unsigned sz = tysize(e->Ety); + + /* We can trip the assert with the following: */ + /* if ( (b<=a) ? (c=a ) */ + /* We'll generate ugly code for it, but it's too obscure a case */ + /* to expend much effort on it. */ + /*assert(*pretregs != mPSW);*/ + + cgstate.stackclean++; + cnop1 = gennop(CNIL); + cnop3 = gennop(CNIL); + e2 = e->E2; + cl = (e->Eoper == OPoror) + ? logexp(e->E1,1,FLcode,cnop1) + : logexp(e->E1,0,FLcode,cnop3); + regconsave = regcon; + stackpushsave = stackpush; + if (*pretregs == 0) /* if don't want result */ + { int noreturn = el_noreturn(e2); + + cr = codelem(e2,pretregs,FALSE); + if (noreturn) + { + regconsave.used |= regcon.used; + regcon = regconsave; + } + else + andregcon(®consave); + assert(stackpush == stackpushsave); + c = cat4(cl,cr,cnop3,cnop1); // eval code, throw away result + goto Lret; + } + cnop2 = gennop(CNIL); + if (tybasic(e2->Ety) == TYbool && + sz == tysize(e2->Ety) && + !(*pretregs & mPSW) && + e2->Eoper == OPcall) + { + cr = codelem(e2,pretregs,FALSE); + + andregcon(®consave); + + // stack depth should not change when evaluating E2 + assert(stackpush == stackpushsave); + + assert(sz <= 4); // result better be int + retregs = *pretregs & allregs; + cnop1 = cat(cnop1,allocreg(&retregs,®,TYint)); // allocate reg for result + cg = genjmp(NULL,JMP,FLcode,(block *) cnop2); // JMP cnop2 + cnop1 = movregconst(cnop1,reg,e->Eoper == OPoror,0); // reg = 1 + regcon.immed.mval &= ~mask[reg]; // mark reg as unavail + *pretregs = retregs; + if (e->Eoper == OPoror) + c = cat6(cl,cr,cnop3,cg,cnop1,cnop2); + else + c = cat6(cl,cr,cg,cnop3,cnop1,cnop2); + + goto Lret; + } + cr = logexp(e2,1,FLcode,cnop1); + andregcon(®consave); + + /* stack depth should not change when evaluating E2 */ + assert(stackpush == stackpushsave); + + assert(sz <= 4); // result better be int + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) retregs = ALLREGS; // if mPSW only + cg = allocreg(&retregs,®,TYint); // allocate reg for result + for (c1 = cg; c1; c1 = code_next(c1)) // for each instruction + gen(cnop1,c1); // duplicate it + cg = movregconst(cg,reg,0,*pretregs & mPSW); // MOV reg,0 + regcon.immed.mval &= ~mask[reg]; // mark reg as unavail + genjmp(cg,JMP,FLcode,(block *) cnop2); // JMP cnop2 + cnop1 = movregconst(cnop1,reg,1,*pretregs & mPSW); // reg = 1 + regcon.immed.mval &= ~mask[reg]; // mark reg as unavail + *pretregs = retregs; + c = cat6(cl,cr,cnop3,cg,cnop1,cnop2); +Lret: + cgstate.stackclean--; + return c; +} + + +/********************* + * Generate code for shift left or shift right (OPshl,OPshr,OPashr,OProl,OPror). + */ + +code *cdshift(elem *e,regm_t *pretregs) +{ unsigned resreg,shiftcnt,byte; + unsigned s1,s2,oper; + tym_t tyml; + int sz; + regm_t retregs,rretregs; + code *cg,*cl,*cr; + code *c; + elem *e1; + elem *e2; + regm_t forccs,forregs; + bool e2isconst; + + e1 = e->E1; + if (*pretregs == 0) // if don't want result + { c = codelem(e1,pretregs,FALSE); // eval left leaf + *pretregs = 0; // in case they got set + return cat(c,codelem(e->E2,pretregs,FALSE)); + } + + tyml = tybasic(e1->Ety); + sz = tysize[tyml]; + assert(!tyfloating(tyml)); + oper = e->Eoper; + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + unsigned grex = rex << 16; + +#if SCPP + // Do this until the rest of the compiler does OPshr/OPashr correctly + if (oper == OPshr) + oper = (tyuns(tyml)) ? OPshr : OPashr; +#endif + + switch (oper) + { case OPshl: + s1 = 4; // SHL + s2 = 2; // RCL + break; + case OPshr: + s1 = 5; // SHR + s2 = 3; // RCR + break; + case OPashr: + s1 = 7; // SAR + s2 = 3; // RCR + break; + case OProl: + s1 = 0; // ROL + break; + case OPror: + s1 = 1; // ROR + break; + default: + assert(0); + } + + unsigned sreg = ~0; // guard against using value without assigning to sreg + c = cg = cr = CNIL; /* initialize */ + e2 = e->E2; + forccs = *pretregs & mPSW; /* if return result in CCs */ + forregs = *pretregs & (ALLREGS | mBP); // mask of possible return regs + e2isconst = FALSE; /* assume for the moment */ + byte = (sz == 1); + switch (e2->Eoper) + { + case OPconst: + e2isconst = TRUE; /* e2 is a constant */ + shiftcnt = e2->EV.Vint; /* get shift count */ + if ((!I16 && sz <= REGSIZE) || + shiftcnt <= 4 || /* if sequence of shifts */ + (sz == 2 && + (shiftcnt == 8 || config.target_cpu >= TARGET_80286)) || + (sz == 2 * REGSIZE && shiftcnt == 8 * REGSIZE) + ) + { retregs = (forregs) ? forregs + : ALLREGS; + if (byte) + { retregs &= BYTEREGS; + if (!retregs) + retregs = BYTEREGS; + } + else if (sz > REGSIZE && sz <= 2 * REGSIZE && + !(retregs & mMSW)) + retregs |= mMSW & ALLREGS; + if (s1 == 7) /* if arithmetic right shift */ + { + if (shiftcnt == 8) + retregs = mAX; + else if (sz == 2 * REGSIZE && shiftcnt == 8 * REGSIZE) + retregs = mDX|mAX; + } + + if (sz == 2 * REGSIZE && shiftcnt == 8 * REGSIZE && + oper == OPshl && + !e1->Ecount && + (e1->Eoper == OPs16_32 || e1->Eoper == OPu16_32 || + e1->Eoper == OPs32_64 || e1->Eoper == OPu32_64) + ) + { // Handle (shtlng)s << 16 + regm_t r; + + r = retregs & mMSW; + cl = codelem(e1->E1,&r,FALSE); // eval left leaf + cl = regwithvalue(cl,retregs & mLSW,0,&resreg,0); + cg = getregs(r); + retregs = r | mask[resreg]; + if (forccs) + { sreg = findreg(r); + cg = gentstreg(cg,sreg); + *pretregs &= ~mPSW; // already set + } + freenode(e1); + freenode(e2); + break; + } + + // See if we should use LEA reg,xxx instead of shift + if (!I16 && shiftcnt >= 1 && shiftcnt <= 3 && + (sz == REGSIZE || (I64 && sz == 4)) && + oper == OPshl && + e1->Eoper == OPvar && + !(*pretregs & mPSW) && + config.flags4 & CFG4speed + ) + { + unsigned reg; + regm_t regm; + + if (isregvar(e1,®m,®) && !(regm & retregs)) + { code cs; + cl = allocreg(&retregs,&resreg,e->Ety); + buildEA(&cs,-1,reg,1 << shiftcnt,0); + cs.Iop = 0x8D; + code_newreg(&cs,resreg); + cs.Iflags = 0; + if (I64 && sz == 8) + cs.Irex |= REX_W; + cg = gen(NULL,&cs); // LEA resreg,[reg * ss] + freenode(e1); + freenode(e2); + break; + } + } + + cl = codelem(e1,&retregs,FALSE); // eval left leaf + //assert((retregs & regcon.mvar) == 0); + cg = getregs(retregs); // trash these regs + + { + if (sz == 2 * REGSIZE) + { resreg = findregmsw(retregs); + sreg = findreglsw(retregs); + } + else + { resreg = findreg(retregs); + sreg = ~0; // an invalid value + } + if (config.target_cpu >= TARGET_80286 && + sz <= REGSIZE) + { + /* SHL resreg,shiftcnt */ + assert(!(sz == 1 && (mask[resreg] & ~BYTEREGS))); + c = genc2(CNIL,0xC1 ^ byte,grex | modregxrmx(3,s1,resreg),shiftcnt); + if (shiftcnt == 1) + c->Iop += 0x10; /* short form of shift */ + if (I64 && sz == 1 && resreg >= 4) + c->Irex |= REX; + // See if we need operand size prefix + if (!I16 && oper != OPshl && sz == 2) + c->Iflags |= CFopsize; + if (forccs) + c->Iflags |= CFpsw; // need flags result + } + else if (shiftcnt == 8) + { if (!(retregs & BYTEREGS) || resreg >= 4) + { + cl = cat(cl,cg); + goto L1; + } + + if (pass != PASSfinal && (!forregs || forregs & (mSI | mDI))) + { + // e1 might get into SI or DI in a later pass, + // so don't put CX into a register + cg = cat(cg, getregs(mCX)); + } + + assert(sz == 2); + switch (oper) + { + case OPshl: + /* MOV regH,regL XOR regL,regL */ + assert(resreg < 4 && !rex); + c = genregs(CNIL,0x8A,resreg+4,resreg); + genregs(c,0x32,resreg,resreg); + break; + + case OPshr: + case OPashr: + /* MOV regL,regH */ + c = genregs(CNIL,0x8A,resreg,resreg+4); + if (oper == OPashr) + gen1(c,0x98); /* CBW */ + else + genregs(c,0x32,resreg+4,resreg+4); /* CLR regH */ + break; + + case OPror: + case OProl: + // XCHG regL,regH + c = genregs(CNIL,0x86,resreg+4,resreg); + break; + + default: + assert(0); + } + if (forccs) + gentstreg(c,resreg); + } + else if (shiftcnt == REGSIZE * 8) // it's an lword + { + if (oper == OPshl) + swap((int *) &resreg,(int *) &sreg); + c = genmovreg(CNIL,sreg,resreg); // MOV sreg,resreg + if (oper == OPashr) + gen1(c,0x99); // CWD + else + movregconst(c,resreg,0,0); // MOV resreg,0 + if (forccs) + { gentstreg(c,sreg); + *pretregs &= mBP | ALLREGS | mES; + } + } + else + { c = CNIL; + if (oper == OPshl && sz == 2 * REGSIZE) + swap((int *) &resreg,(int *) &sreg); + while (shiftcnt--) + { c = gen2(c,0xD1 ^ byte,modregrm(3,s1,resreg)); + if (sz == 2 * REGSIZE) + gen2(c,0xD1,modregrm(3,s2,sreg)); + } + if (forccs) + code_orflag(c,CFpsw); + } + if (sz <= REGSIZE) + *pretregs &= mBP | ALLREGS; // flags already set + } + freenode(e2); + break; + } + /* FALL-THROUGH */ + default: + retregs = forregs & ~mCX; /* CX will be shift count */ + if (sz <= REGSIZE) + { + if (forregs & ~regcon.mvar && !(retregs & ~regcon.mvar)) + retregs = ALLREGS & ~mCX; /* need something */ + else if (!retregs) + retregs = ALLREGS & ~mCX; /* need something */ + if (sz == 1) + { retregs &= mAX|mBX|mDX; + if (!retregs) + retregs = mAX|mBX|mDX; + } + } + else + { + if (!(retregs & mMSW)) + retregs = ALLREGS & ~mCX; + } + cl = codelem(e->E1,&retregs,FALSE); /* eval left leaf */ + + if (sz <= REGSIZE) + resreg = findreg(retregs); + else + { + resreg = findregmsw(retregs); + sreg = findreglsw(retregs); + } + L1: + rretregs = mCX; /* CX is shift count */ + if (sz <= REGSIZE) + { + cr = scodelem(e2,&rretregs,retregs,FALSE); /* get rvalue */ + cg = getregs(retregs); /* trash these regs */ + c = gen2(CNIL,0xD3 ^ byte,grex | modregrmx(3,s1,resreg)); /* Sxx resreg,CX */ + + if (!I16 && sz == 2 && (oper == OProl || oper == OPror)) + c->Iflags |= CFopsize; + + // Note that a shift by CL does not set the flags if + // CL == 0. If e2 is a constant, we know it isn't 0 + // (it would have been optimized out). + if (e2isconst) + *pretregs &= mBP | ALLREGS; // flags already set with result + } + else if (sz == 2 * REGSIZE && + config.target_cpu >= TARGET_80386) + { + unsigned hreg = resreg; + unsigned lreg = sreg; + unsigned rex = I64 ? (REX_W << 16) : 0; + if (e2isconst) + { + cr = NULL; + cg = getregs(retregs); + if (shiftcnt & (REGSIZE * 8)) + { + if (oper == OPshr) + { // SHR hreg,shiftcnt + // MOV lreg,hreg + // XOR hreg,hreg + c = genc2(NULL,0xC1,rex | modregrm(3,s1,hreg),shiftcnt - (REGSIZE * 8)); + c = genmovreg(c,lreg,hreg); + c = movregconst(c,hreg,0,0); + } + else if (oper == OPashr) + { // MOV lreg,hreg + // SAR hreg,31 + // SHRD lreg,hreg,shiftcnt + c = genmovreg(NULL,lreg,hreg); + c = genc2(c,0xC1,rex | modregrm(3,s1,hreg),(REGSIZE * 8) - 1); + c = genc2(c,0x0FAC,rex | modregrm(3,hreg,lreg),shiftcnt - (REGSIZE * 8)); + } + else + { // SHL lreg,shiftcnt + // MOV hreg,lreg + // XOR lreg,lreg + c = genc2(NULL,0xC1,rex | modregrm(3,s1,lreg),shiftcnt - (REGSIZE * 8)); + c = genmovreg(c,hreg,lreg); + c = movregconst(c,lreg,0,0); + } + } + else + { + if (oper == OPshr || oper == OPashr) + { // SHRD lreg,hreg,shiftcnt + // SHR/SAR hreg,shiftcnt + c = genc2(NULL,0x0FAC,rex | modregrm(3,hreg,lreg),shiftcnt); + c = genc2(c,0xC1,rex | modregrm(3,s1,hreg),shiftcnt); + } + else + { // SHLD hreg,lreg,shiftcnt + // SHL lreg,shiftcnt + c = genc2(NULL,0x0FA4,rex | modregrm(3,lreg,hreg),shiftcnt); + c = genc2(c,0xC1,rex | modregrm(3,s1,lreg),shiftcnt); + } + } + freenode(e2); + } + else if (config.target_cpu >= TARGET_80486 && REGSIZE == 2) + { + cr = scodelem(e2,&rretregs,retregs,FALSE); // get rvalue in CX + cg = getregs(retregs); // modify these regs + if (oper == OPshl) + { + /* + SHLD hreg,lreg,CL + SHL lreg,CL + */ + + c = gen2(NULL,0x0FA5,modregrm(3,lreg,hreg)); + gen2(c,0xD3,modregrm(3,4,lreg)); + } + else + { + /* + SHRD lreg,hreg,CL + SAR hreg,CL + + -- or -- + + SHRD lreg,hreg,CL + SHR hreg,CL + */ + c = gen2(NULL,0x0FAD,modregrm(3,hreg,lreg)); + gen2(c,0xD3,modregrm(3,s1,hreg)); + } + } + else + { code *cl1,*cl2; + + cr = scodelem(e2,&rretregs,retregs,FALSE); // get rvalue in CX + cg = getregs(retregs | mCX); // modify these regs + // TEST CL,0x20 + c = genc2(NULL,0xF6,modregrm(3,0,CX),REGSIZE * 8); + if (oper == OPshl) + { + /* TEST CL,20H + JNE L1 + SHLD hreg,lreg,CL + SHL lreg,CL + JMP L2 + L1: AND CL,20H-1 + SHL lreg,CL + MOV hreg,lreg + XOR lreg,lreg + L2: NOP + */ + + cl1 = NULL; + if (REGSIZE == 2) + cl1 = genc2(NULL,0x80,modregrm(3,4,CX),REGSIZE * 8 - 1); + cl1 = gen2(cl1,0xD3,modregrm(3,4,lreg)); + genmovreg(cl1,hreg,lreg); + genregs(cl1,0x31,lreg,lreg); + + genjmp(c,JNE,FLcode,(block *)cl1); + gen2(c,0x0FA5,modregrm(3,lreg,hreg)); + gen2(c,0xD3,modregrm(3,4,lreg)); + } + else + { if (oper == OPashr) + { + /* TEST CL,20H + JNE L1 + SHRD lreg,hreg,CL + SAR hreg,CL + JMP L2 + L1: AND CL,15 + MOV lreg,hreg + SAR hreg,31 + SHRD lreg,hreg,CL + L2: NOP + */ + + cl1 = NULL; + if (REGSIZE == 2) + cl1 = genc2(NULL,0x80,modregrm(3,4,CX),REGSIZE * 8 - 1); + cl1 = genmovreg(cl1,lreg,hreg); + genc2(cl1,0xC1,modregrm(3,s1,hreg),31); + gen2(cl1,0x0FAD,modregrm(3,hreg,lreg)); + } + else + { + /* TEST CL,20H + JNE L1 + SHRD lreg,hreg,CL + SHR hreg,CL + JMP L2 + L1: AND CL,15 + SHR hreg,CL + MOV lreg,hreg + XOR hreg,hreg + L2: NOP + */ + + cl1 = NULL; + if (REGSIZE == 2) + cl1 = genc2(NULL,0x80,modregrm(3,4,CX),REGSIZE * 8 - 1); + cl1 = gen2(cl1,0xD3,modregrm(3,5,hreg)); + genmovreg(cl1,lreg,hreg); + genregs(cl1,0x31,hreg,hreg); + } + genjmp(c,JNE,FLcode,(block *)cl1); + gen2(c,0x0FAD,modregrm(3,hreg,lreg)); + gen2(c,0xD3,modregrm(3,s1,hreg)); + } + cl2 = gennop(NULL); + genjmp(c,JMPS,FLcode,(block *)cl2); + c = cat3(c,cl1,cl2); + } + break; + } + else if (sz == 2 * REGSIZE) + { + c = CNIL; + if (!e2isconst) // if not sure shift count != 0 + c = genc2(c,0xE3,0,6); // JCXZ .+6 + cr = scodelem(e2,&rretregs,retregs,FALSE); + cg = getregs(retregs | mCX); + if (oper == OPshl) + swap((int *) &resreg,(int *) &sreg); + c = gen2(c,0xD1,modregrm(3,s1,resreg)); + code_orflag(c,CFtarg2); + gen2(c,0xD1,modregrm(3,s2,sreg)); + genc2(c,0xE2,0,(targ_uns)-6); // LOOP .-6 + regimmed_set(CX,0); // note that now CX == 0 + } + else + assert(0); + break; + } + c = cat(c,fixresult(e,retregs,pretregs)); + return cat4(cl,cr,cg,c); +} + + +/*************************** + * Perform a 'star' reference (indirection). + */ + +code *cdind(elem *e,regm_t *pretregs) +{ code *c,*ce,cs; + tym_t tym; + regm_t idxregs,retregs; + unsigned reg,nreg,byte; + elem *e1; + unsigned sz; + + //printf("cdind(e = %p, *pretregs = %s)\n",e,regm_str(*pretregs)); + tym = tybasic(e->Ety); + if (tyfloating(tym)) + { + if (config.inline8087) + { + if (*pretregs & mST0) + return cdind87(e, pretregs); + if (tycomplex(tym)) + return cload87(e, pretregs); + if (*pretregs & mPSW) + return cdind87(e, pretregs); + } + } + + e1 = e->E1; + assert(e1); + switch (tym) + { case TYstruct: + case TYarray: + // This case should never happen, why is it here? + tym = TYnptr; // don't confuse allocreg() +#if TARGET_SEGMENTED + if (*pretregs & (mES | mCX) || e->Ety & mTYfar) + tym = TYfptr; +#endif + +#if 0 + c = getlvalue(&cs,e,RMload); // get addressing mode + if (*pretregs == 0) + return c; + idxregs = idxregm(&cs); // mask of index regs used + c = cat(c,fixresult(e,idxregs,pretregs)); + return c; +#endif + break; + } + sz = tysize[tym]; + byte = tybyte(tym) != 0; + + c = getlvalue(&cs,e,RMload); // get addressing mode + //printf("Irex = %02x, Irm = x%02x, Isib = x%02x\n", cs.Irex, cs.Irm, cs.Isib); + /*fprintf(stderr,"cd2 :\n"); WRcodlst(c);*/ + if (*pretregs == 0) + return c; + + idxregs = idxregm(&cs); // mask of index regs used + + if (*pretregs == mPSW) + { + if (!I16 && tym == TYfloat) + { retregs = ALLREGS & ~idxregs; + c = cat(c,allocreg(&retregs,®,TYfloat)); + cs.Iop = 0x8B; + code_newreg(&cs,reg); + ce = gen(CNIL,&cs); // MOV reg,lsw + gen2(ce,0xD1,modregrmx(3,4,reg)); // SHL reg,1 + } + else if (sz <= REGSIZE) + { + cs.Iop = 0x81 ^ byte; + cs.Irm |= modregrm(0,7,0); + cs.IFL2 = FLconst; + cs.IEV2.Vint = 0; + ce = gen(CNIL,&cs); /* CMP [idx],0 */ + } + else if (!I16 && sz == REGSIZE + 2) // if far pointer + { retregs = ALLREGS & ~idxregs; + c = cat(c,allocreg(&retregs,®,TYint)); + cs.Iop = 0x0FB7; + cs.Irm |= modregrm(0,reg,0); + getlvalue_msw(&cs); + ce = gen(CNIL,&cs); /* MOVZX reg,msw */ + goto L4; + } + else if (sz <= 2 * REGSIZE) + { retregs = ALLREGS & ~idxregs; + c = cat(c,allocreg(&retregs,®,TYint)); + cs.Iop = 0x8B; + code_newreg(&cs,reg); + getlvalue_msw(&cs); + ce = gen(CNIL,&cs); /* MOV reg,msw */ + if (I32) + { if (tym == TYdouble || tym == TYdouble_alias) + gen2(ce,0xD1,modregrm(3,4,reg)); // SHL reg,1 + } + else if (tym == TYfloat) + gen2(ce,0xD1,modregrm(3,4,reg)); /* SHL reg,1 */ + L4: cs.Iop = 0x0B; + getlvalue_lsw(&cs); + gen(ce,&cs); /* OR reg,lsw */ + } + else if (!I32 && sz == 8) + { *pretregs |= DOUBLEREGS_16; /* fake it for now */ + goto L1; + } + else + { + debugx(WRTYxx(tym)); + assert(0); + } + c = cat(c,ce); + } + else /* else return result in reg */ + { + L1: retregs = *pretregs; + if (sz == 8 && + (retregs & (mPSW | mSTACK | ALLREGS | mBP)) == mSTACK) + { int i; + + /* Optimizer should not CSE these, as the result is worse code! */ + assert(!e->Ecount); + + cs.Iop = 0xFF; + cs.Irm |= modregrm(0,6,0); + cs.IEVoffset1 += 8 - REGSIZE; + stackchanged = 1; + i = 8 - REGSIZE; + do + { + c = gen(c,&cs); /* PUSH EA+i */ + c = genadjesp(c,REGSIZE); + cs.IEVoffset1 -= REGSIZE; + stackpush += REGSIZE; + i -= REGSIZE; + } + while (i >= 0); + goto L3; + } + if (I16 && sz == 8) + retregs = DOUBLEREGS_16; + + /* Watch out for loading an lptr from an lptr! We must have */ + /* the offset loaded into a different register. */ + /*if (retregs & mES && (cs.Iflags & CFSEG) == CFes) + retregs = ALLREGS;*/ + + { + assert(!byte || retregs & BYTEREGS); + c = cat(c,allocreg(&retregs,®,tym)); /* alloc registers */ + } + if (retregs & XMMREGS) + { + assert(sz == 4 || sz == 8 || sz == 16); // float, double or vector + cs.Iop = xmmload(tym); + reg -= XMM0; + goto L2; + } + else if (sz <= REGSIZE) + { + cs.Iop = 0x8B ^ byte; + L2: code_newreg(&cs,reg); + ce = gen(CNIL,&cs); /* MOV reg,[idx] */ + if (byte && reg >= 4) + code_orrex(ce, REX); + } +#if TARGET_SEGMENTED + else if ((tym == TYfptr || tym == TYhptr) && retregs & mES) + { + cs.Iop = 0xC4; /* LES reg,[idx] */ + goto L2; + } +#endif + else if (sz <= 2 * REGSIZE) + { unsigned lsreg; + + cs.Iop = 0x8B; + /* Be careful not to interfere with index registers */ + if (!I16) + { + /* Can't handle if both result registers are used in */ + /* the addressing mode. */ + if ((retregs & idxregs) == retregs) + { + retregs = mMSW & allregs & ~idxregs; + if (!retregs) + retregs |= mCX; + retregs |= mLSW & ~idxregs; + + // We can run out of registers, so if that's possible, + // give us *one* of the idxregs + if ((retregs & ~regcon.mvar & mLSW) == 0) + { + regm_t x = idxregs & mLSW; + if (x) + retregs |= mask[findreg(x)]; // give us one idxreg + } + else if ((retregs & ~regcon.mvar & mMSW) == 0) + { + regm_t x = idxregs & mMSW; + if (x) + retregs |= mask[findreg(x)]; // give us one idxreg + } + + c = cat(c,allocreg(&retregs,®,tym)); /* alloc registers */ + assert((retregs & idxregs) != retregs); + } + + lsreg = findreglsw(retregs); + if (mask[reg] & idxregs) /* reg is in addr mode */ + { + code_newreg(&cs,lsreg); + ce = gen(CNIL,&cs); /* MOV lsreg,lsw */ + if (sz == REGSIZE + 2) + cs.Iflags |= CFopsize; + lsreg = reg; + getlvalue_msw(&cs); // MOV reg,msw + } + else + { + code_newreg(&cs,reg); + getlvalue_msw(&cs); + ce = gen(CNIL,&cs); // MOV reg,msw + if (sz == REGSIZE + 2) + ce->Iflags |= CFopsize; + getlvalue_lsw(&cs); // MOV lsreg,lsw + } + NEWREG(cs.Irm,lsreg); + gen(ce,&cs); + } + else + { + /* Index registers are always the lsw! */ + cs.Irm |= modregrm(0,reg,0); + getlvalue_msw(&cs); + ce = gen(CNIL,&cs); /* MOV reg,msw */ + lsreg = findreglsw(retregs); + NEWREG(cs.Irm,lsreg); + getlvalue_lsw(&cs); /* MOV lsreg,lsw */ + gen(ce,&cs); + } + } + else if (I16 && sz == 8) + { + assert(reg == AX); + cs.Iop = 0x8B; + cs.IEVoffset1 += 6; + ce = gen(CNIL,&cs); /* MOV AX,EA+6 */ + cs.Irm |= modregrm(0,CX,0); + cs.IEVoffset1 -= 4; + gen(ce,&cs); /* MOV CX,EA+2 */ + NEWREG(cs.Irm,DX); + cs.IEVoffset1 -= 2; + gen(ce,&cs); /* MOV DX,EA */ + cs.IEVoffset1 += 4; + NEWREG(cs.Irm,BX); + gen(ce,&cs); /* MOV BX,EA+4 */ + } + else + assert(0); + c = cat(c,ce); + L3: + c = cat(c,fixresult(e,retregs,pretregs)); + } + /*fprintf(stderr,"cdafter :\n"); WRcodlst(c);*/ + return c; +} + + + +#if !TARGET_SEGMENTED +#define cod2_setES(ty) NULL +#else +/******************************** + * Generate code to load ES with the right segment value, + * do nothing if e is a far pointer. + */ + +STATIC code *cod2_setES(tym_t ty) +{ code *c2; + int push; + + c2 = CNIL; + switch (tybasic(ty)) + { + case TYnptr: + if (!(config.flags3 & CFG3eseqds)) + { push = 0x1E; /* PUSH DS */ + goto L1; + } + break; + case TYcptr: + push = 0x0E; /* PUSH CS */ + goto L1; + case TYsptr: + if ((config.wflags & WFssneds) || !(config.flags3 & CFG3eseqds)) + { push = 0x16; /* PUSH SS */ + L1: + /* Must load ES */ + c2 = getregs(mES); + c2 = gen1(c2,push); + gen1(c2,0x07); /* POP ES */ + } + break; + } + return c2; +} +#endif + +/******************************** + * Generate code for intrinsic strlen(). + */ + +code *cdstrlen( elem *e, regm_t *pretregs) +{ code *c1,*c2,*c3,*c4; + + /* Generate strlen in CX: + LES DI,e1 + CLR AX ;scan for 0 + MOV CX,-1 ;largest possible string + REPNE SCASB + NOT CX + DEC CX + */ + + regm_t retregs = mDI; + tym_t ty1 = e->E1->Ety; + if (!tyreg(ty1)) + retregs |= mES; + c1 = codelem(e->E1,&retregs,FALSE); + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty1); + + unsigned char rex = I64 ? REX_W : 0; + + c3 = getregs_imm(mAX | mCX); + c3 = movregconst(c3,AX,0,1); /* MOV AL,0 */ + c3 = movregconst(c3,CX,-1LL,I64 ? 64 : 0); // MOV CX,-1 + c3 = cat(c3,getregs(mDI|mCX)); + c3 = gen1(c3,0xF2); /* REPNE */ + gen1(c3,0xAE); /* SCASB */ + genregs(c3,0xF7,2,CX); /* NOT CX */ + code_orrex(c3,rex); + if (I64) + c4 = gen2(CNIL,0xFF,(rex << 16) | modregrm(3,1,CX)); // DEC reg + else + c4 = gen1(CNIL,0x48 + CX); // DEC CX + + if (*pretregs & mPSW) + { + c4->Iflags |= CFpsw; + *pretregs &= ~mPSW; + } + return cat6(c1,c2,c3,c4,fixresult(e,mCX,pretregs),CNIL); +} + + +/********************************* + * Generate code for strcmp(s1,s2) intrinsic. + */ + +code *cdstrcmp( elem *e, regm_t *pretregs) +{ code *c1,*c1a,*c2,*c3,*c4; + char need_DS; + int segreg; + + /* + MOV SI,s1 ;get destination pointer (s1) + MOV CX,s1+2 + LES DI,s2 ;get source pointer (s2) + PUSH DS + MOV DS,CX + CLR AX ;scan for 0 + MOV CX,-1 ;largest possible string + REPNE SCASB + NOT CX ;CX = string length of s2 + SUB DI,CX ;point DI back to beginning + REPE CMPSB ;compare string + POP DS + JE L1 ;strings are equal + SBB AX,AX + SBB AX,-1 + L1: + */ + + regm_t retregs1 = mSI; + tym_t ty1 = e->E1->Ety; + if (!tyreg(ty1)) + retregs1 |= mCX; + c1 = codelem(e->E1,&retregs1,FALSE); + + regm_t retregs = mDI; + tym_t ty2 = e->E2->Ety; + if (!tyreg(ty2)) + retregs |= mES; + c1 = cat(c1,scodelem(e->E2,&retregs,retregs1,FALSE)); + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty2); + c3 = getregs_imm(mAX | mCX); + + unsigned char rex = I64 ? REX_W : 0; + + /* Load DS with right value */ + switch (tybasic(ty1)) + { + case TYnptr: + need_DS = FALSE; + break; +#if TARGET_SEGMENTED + case TYsptr: + if (config.wflags & WFssneds) /* if sptr can't use DS segment */ + segreg = SEG_SS; + else + segreg = SEG_DS; + goto L1; + case TYcptr: + segreg = SEG_CS; + L1: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen1(c3,0x06 + (segreg << 3)); /* PUSH segreg */ + gen1(c3,0x1F); /* POP DS */ + need_DS = TRUE; + break; + case TYfptr: + case TYvptr: + case TYhptr: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen2(c3,0x8E,modregrm(3,SEG_DS,CX)); /* MOV DS,CX */ + need_DS = TRUE; + break; +#endif + default: + assert(0); + } + + c3 = movregconst(c3,AX,0,0); /* MOV AX,0 */ + c3 = movregconst(c3,CX,-1LL,I64 ? 64 : 0); // MOV CX,-1 + c3 = cat(c3,getregs(mSI|mDI|mCX)); + c3 = gen1(c3,0xF2); /* REPNE */ + gen1(c3,0xAE); /* SCASB */ + genregs(c3,0xF7,2,CX); /* NOT CX */ + code_orrex(c3,rex); + genregs(c3,0x2B,DI,CX); /* SUB DI,CX */ + code_orrex(c3,rex); + gen1(c3,0xF3); /* REPE */ + gen1(c3,0xA6); /* CMPSB */ + if (need_DS) + gen1(c3,0x1F); /* POP DS */ + c4 = gennop(CNIL); + if (*pretregs != mPSW) /* if not flags only */ + { + genjmp(c3,JE,FLcode,(block *) c4); /* JE L1 */ + c3 = cat(c3,getregs(mAX)); + genregs(c3,0x1B,AX,AX); /* SBB AX,AX */ + code_orrex(c3,rex); + genc2(c3,0x81,(rex << 16) | modregrm(3,3,AX),(targ_uns)-1); // SBB AX,-1 + } + + *pretregs &= ~mPSW; + return cat6(c1,c2,c3,c4,fixresult(e,mAX,pretregs),CNIL); +} + +/********************************* + * Generate code for memcmp(s1,s2,n) intrinsic. + */ + +code *cdmemcmp(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3,*c4; + char need_DS; + int segreg; + + /* + MOV SI,s1 ;get destination pointer (s1) + MOV DX,s1+2 + LES DI,s2 ;get source pointer (s2) + MOV CX,n ;get number of bytes to compare + PUSH DS + MOV DS,DX + XOR AX,AX + REPE CMPSB ;compare string + POP DS + JE L1 ;strings are equal + SBB AX,AX + SBB AX,-1 + L1: + */ + + elem *e1 = e->E1; + assert(e1->Eoper == OPparam); + + // Get s1 into DX:SI + regm_t retregs1 = mSI; + tym_t ty1 = e1->E1->Ety; + if (!tyreg(ty1)) + retregs1 |= mDX; + c1 = codelem(e1->E1,&retregs1,FALSE); + + // Get s2 into ES:DI + regm_t retregs = mDI; + tym_t ty2 = e1->E2->Ety; + if (!tyreg(ty2)) + retregs |= mES; + c1 = cat(c1,scodelem(e1->E2,&retregs,retregs1,FALSE)); + freenode(e1); + + // Get nbytes into CX + regm_t retregs3 = mCX; + c1 = cat(c1,scodelem(e->E2,&retregs3,retregs | retregs1,FALSE)); + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty2); + + /* Load DS with right value */ + c3 = NULL; + switch (tybasic(ty1)) + { + case TYnptr: + need_DS = FALSE; + break; +#if TARGET_SEGMENTED + case TYsptr: + if (config.wflags & WFssneds) /* if sptr can't use DS segment */ + segreg = SEG_SS; + else + segreg = SEG_DS; + goto L1; + case TYcptr: + segreg = SEG_CS; + L1: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen1(c3,0x06 + (segreg << 3)); /* PUSH segreg */ + gen1(c3,0x1F); /* POP DS */ + need_DS = TRUE; + break; + case TYfptr: + case TYvptr: + case TYhptr: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen2(c3,0x8E,modregrm(3,SEG_DS,DX)); /* MOV DS,DX */ + need_DS = TRUE; + break; +#endif + default: + assert(0); + } + +#if 1 + c3 = cat(c3,getregs(mAX)); + c3 = gen2(c3,0x33,modregrm(3,AX,AX)); // XOR AX,AX +#else + if (*pretregs != mPSW) // if not flags only + c3 = regwithvalue(c3,mAX,0,NULL,0); // put 0 in AX +#endif + + c3 = cat(c3,getregs(mCX | mSI | mDI)); + c3 = gen1(c3,0xF3); /* REPE */ + gen1(c3,0xA6); /* CMPSB */ + if (need_DS) + gen1(c3,0x1F); /* POP DS */ + if (*pretregs != mPSW) /* if not flags only */ + { + c4 = gennop(CNIL); + genjmp(c3,JE,FLcode,(block *) c4); /* JE L1 */ + c3 = cat(c3,getregs(mAX)); + genregs(c3,0x1B,AX,AX); /* SBB AX,AX */ + genc2(c3,0x81,modregrm(3,3,AX),(targ_uns)-1); /* SBB AX,-1 */ + c3 = cat(c3,c4); + } + + *pretregs &= ~mPSW; + return cat4(c1,c2,c3,fixresult(e,mAX,pretregs)); +} + +/********************************* + * Generate code for strcpy(s1,s2) intrinsic. + */ + +code *cdstrcpy(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3,*c4; + regm_t retregs; + tym_t ty1,ty2; + char need_DS; + int segreg; + + /* + LES DI,s2 ;ES:DI = s2 + CLR AX ;scan for 0 + MOV CX,-1 ;largest possible string + REPNE SCASB ;find end of s2 + NOT CX ;CX = strlen(s2) + 1 (for EOS) + SUB DI,CX + MOV SI,DI + PUSH DS + PUSH ES + LES DI,s1 + POP DS + MOV AX,DI ;return value is s1 + REP MOVSB + POP DS + */ + + stackchanged = 1; + retregs = mDI; + ty2 = tybasic(e->E2->Ety); + if (!tyreg(ty2)) + retregs |= mES; + unsigned char rex = I64 ? REX_W : 0; + c1 = codelem(e->E2,&retregs,FALSE); + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty2); + c3 = getregs_imm(mAX | mCX); + c3 = movregconst(c3,AX,0,1); /* MOV AL,0 */ + c3 = movregconst(c3,CX,-1,I64?64:0); // MOV CX,-1 + c3 = cat(c3,getregs(mAX|mCX|mSI|mDI)); + c3 = gen1(c3,0xF2); /* REPNE */ + gen1(c3,0xAE); /* SCASB */ + genregs(c3,0xF7,2,CX); /* NOT CX */ + code_orrex(c3,rex); + genregs(c3,0x2B,DI,CX); /* SUB DI,CX */ + code_orrex(c3,rex); + genmovreg(c3,SI,DI); /* MOV SI,DI */ + code_orrex(c3,rex); + + /* Load DS with right value */ + switch (ty2) + { + case TYnptr: + need_DS = FALSE; + break; +#if TARGET_SEGMENTED + case TYsptr: + if (config.wflags & WFssneds) /* if sptr can't use DS segment */ + segreg = SEG_SS; + else + segreg = SEG_DS; + goto L1; + case TYcptr: + segreg = SEG_CS; + L1: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen1(c3,0x06 + (segreg << 3)); /* PUSH segreg */ + genadjesp(c3,REGSIZE * 2); + need_DS = TRUE; + break; + case TYfptr: + case TYvptr: + case TYhptr: + segreg = SEG_ES; + goto L1; + break; +#endif + default: + assert(0); + } + + retregs = mDI; + ty1 = tybasic(e->E1->Ety); + if (!tyreg(ty1)) + retregs |= mES; + c3 = cat(c3,scodelem(e->E1,&retregs,mCX|mSI,FALSE)); + c3 = cat(c3,getregs(mAX|mCX|mSI|mDI)); + + /* Make sure ES contains proper segment value */ + if (ty2 != TYnptr || ty1 != ty2) + c4 = cod2_setES(ty1); + else + c4 = CNIL; /* ES is already same as DS */ + + if (need_DS) + c4 = gen1(c4,0x1F); /* POP DS */ + if (*pretregs) + { c4 = genmovreg(c4,AX,DI); /* MOV AX,DI */ + code_orrex(c4,rex); + } + c4 = gen1(c4,0xF3); /* REP */ + gen1(c4,0xA4); /* MOVSB */ + + if (need_DS) + { gen1(c4,0x1F); /* POP DS */ + genadjesp(c4,-(REGSIZE * 2)); + } + return cat6(c1,c2,c3,c4,fixresult(e,mAX | mES,pretregs),CNIL); +} + +/********************************* + * Generate code for memcpy(s1,s2,n) intrinsic. + * OPmemcpy + * / \ + * s1 OPparam + * / \ + * s2 n + */ + +code *cdmemcpy(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3,*c4; + regm_t retregs1; + regm_t retregs2; + regm_t retregs3; + tym_t ty1,ty2; + char need_DS; + int segreg; + elem *e2; + + /* + MOV SI,s2 + MOV DX,s2+2 + MOV CX,n + LES DI,s1 + PUSH DS + MOV DS,DX + MOV AX,DI ;return value is s1 + REP MOVSB + POP DS + */ + + e2 = e->E2; + assert(e2->Eoper == OPparam); + + // Get s2 into DX:SI + retregs2 = mSI; + ty2 = e2->E1->Ety; + if (!tyreg(ty2)) + retregs2 |= mDX; + c1 = codelem(e2->E1,&retregs2,FALSE); + + // Get nbytes into CX + retregs3 = mCX; + c1 = cat(c1,scodelem(e2->E2,&retregs3,retregs2,FALSE)); + freenode(e2); + + // Get s1 into ES:DI + retregs1 = mDI; + ty1 = e->E1->Ety; + if (!tyreg(ty1)) + retregs1 |= mES; + c1 = cat(c1,scodelem(e->E1,&retregs1,retregs2 | retregs3,FALSE)); + + unsigned char rex = I64 ? REX_W : 0; + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty1); + + /* Load DS with right value */ + c3 = NULL; + switch (tybasic(ty2)) + { + case TYnptr: + need_DS = FALSE; + break; +#if TARGET_SEGMENTED + case TYsptr: + if (config.wflags & WFssneds) /* if sptr can't use DS segment */ + segreg = SEG_SS; + else + segreg = SEG_DS; + goto L1; + case TYcptr: + segreg = SEG_CS; + L1: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen1(c3,0x06 + (segreg << 3)); /* PUSH segreg */ + gen1(c3,0x1F); /* POP DS */ + need_DS = TRUE; + break; + case TYfptr: + case TYvptr: + case TYhptr: + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen2(c3,0x8E,modregrm(3,SEG_DS,DX)); /* MOV DS,DX */ + need_DS = TRUE; + break; +#endif + default: + assert(0); + } + + if (*pretregs) // if need return value + { c3 = cat(c3,getregs(mAX)); + c3 = genmovreg(c3,AX,DI); + code_orrex(c3, rex); + } + + if (0 && I32 && config.flags4 & CFG4speed) + { + /* This is only faster if the memory is dword aligned, if not + * it is significantly slower than just a rep movsb. + */ + /* mov EDX,ECX + * shr ECX,2 + * jz L1 + * repe movsd + * L1: and EDX,3 + * jz L2 + * mov ECX,EDX + * repe movsb + * L2: nop + */ + c3 = cat(c3,getregs(mSI | mDI | mCX | mDX)); + c3 = genmovreg(c3,DX,CX); // MOV EDX,ECX + c3 = genc2(c3,0xC1,modregrm(3,5,CX),2); // SHR ECX,2 + code *cx = genc2(CNIL, 0x81, modregrm(3,4,DX),3); // AND EDX,3 + genjmp(c3, JE, FLcode, (block *)cx); // JZ L1 + gen1(c3,0xF3); // REPE + gen1(c3,0xA5); // MOVSW + c3 = cat(c3,cx); + + code *cnop = gennop(CNIL); + genjmp(c3, JE, FLcode, (block *)cnop); // JZ L2 + genmovreg(c3,CX,DX); // MOV ECX,EDX + gen1(c3,0xF3); // REPE + gen1(c3,0xA4); // MOVSB + c3 = cat(c3, cnop); + } + else + { + c3 = cat(c3,getregs(mSI | mDI | mCX)); + if (!I32 && config.flags4 & CFG4speed) // if speed optimization + { c3 = gen2(c3,0xD1,(rex << 16) | modregrm(3,5,CX)); // SHR CX,1 + gen1(c3,0xF3); // REPE + gen1(c3,0xA5); // MOVSW + gen2(c3,0x11,(rex << 16) | modregrm(3,CX,CX)); // ADC CX,CX + } + c3 = gen1(c3,0xF3); // REPE + gen1(c3,0xA4); // MOVSB + if (need_DS) + gen1(c3,0x1F); // POP DS + } + return cat4(c1,c2,c3,fixresult(e,mES|mAX,pretregs)); +} + + +/********************************* + * Generate code for memset(s,val,n) intrinsic. + * (s OPmemset (n OPparam val)) + */ + +#if 1 +code *cdmemset(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3 = NULL,*c4; + regm_t retregs1; + regm_t retregs2; + regm_t retregs3; + unsigned reg,vreg; + tym_t ty1; + int segreg; + unsigned remainder; + targ_uns numbytes,numwords; + int op; + targ_size_t value; + unsigned m; + + //printf("cdmemset(*pretregs = %s)\n", regm_str(*pretregs)); + elem *e2 = e->E2; + assert(e2->Eoper == OPparam); + + unsigned char rex = I64 ? REX_W : 0; + + if (e2->E2->Eoper == OPconst) + { + value = el_tolong(e2->E2); + value &= 0xFF; + value |= value << 8; + value |= value << 16; + value |= value << 32; + } + else + value = 0xDEADBEEF; // stop annoying false positives that value is not inited + + if (e2->E1->Eoper == OPconst) + { + numbytes = el_tolong(e2->E1); + if (numbytes <= REP_THRESHOLD && + !I16 && // doesn't work for 16 bits + e2->E2->Eoper == OPconst) + { + targ_uns offset = 0; + retregs1 = *pretregs; + if (!retregs1) + retregs1 = ALLREGS; + c1 = codelem(e->E1,&retregs1,FALSE); + reg = findreg(retregs1); + if (e2->E2->Eoper == OPconst) + { + unsigned m = buildModregrm(0,0,reg); + switch (numbytes) + { + case 4: // MOV [reg],imm32 + c3 = genc2(CNIL,0xC7,m,value); + goto fixres; + case 2: // MOV [reg],imm16 + c3 = genc2(CNIL,0xC7,m,value); + c3->Iflags = CFopsize; + goto fixres; + case 1: // MOV [reg],imm8 + c3 = genc2(CNIL,0xC6,m,value); + goto fixres; + } + } + + c1 = regwithvalue(c1, BYTEREGS & ~retregs1, value, &vreg, I64 ? 64 : 0); + freenode(e2->E2); + freenode(e2); + + m = (rex << 16) | buildModregrm(2,vreg,reg); + while (numbytes >= REGSIZE) + { // MOV dword ptr offset[reg],vreg + c2 = gen2(CNIL,0x89,m); + c2->IEVoffset1 = offset; + c2->IFL1 = FLconst; + numbytes -= REGSIZE; + offset += REGSIZE; + c3 = cat(c3,c2); + } + m &= ~(rex << 16); + if (numbytes & 4) + { // MOV dword ptr offset[reg],vreg + c2 = gen2(CNIL,0x89,m); + c2->IEVoffset1 = offset; + c2->IFL1 = FLconst; + offset += 4; + c3 = cat(c3,c2); + } + if (numbytes & 2) + { // MOV word ptr offset[reg],vreg + c2 = gen2(CNIL,0x89,m); + c2->IEVoffset1 = offset; + c2->IFL1 = FLconst; + c2->Iflags = CFopsize; + offset += 2; + c3 = cat(c3,c2); + } + if (numbytes & 1) + { // MOV byte ptr offset[reg],vreg + c2 = gen2(CNIL,0x88,m); + c2->IEVoffset1 = offset; + c2->IFL1 = FLconst; + if (I64 && vreg >= 4) + c2->Irex |= REX; + c3 = cat(c3,c2); + } +fixres: + return cat3(c1,c3,fixresult(e,retregs1,pretregs)); + } + } + + // Get nbytes into CX + retregs2 = mCX; + if (!I16 && e2->E1->Eoper == OPconst && e2->E2->Eoper == OPconst) + { + remainder = numbytes & (4 - 1); + numwords = numbytes / 4; // number of words + op = 0xAB; // moving by words + c1 = getregs(mCX); + c1 = movregconst(c1,CX,numwords,I64?64:0); // # of bytes/words + } + else + { + remainder = 0; + op = 0xAA; // must move by bytes + c1 = codelem(e2->E1,&retregs2,FALSE); + } + + // Get val into AX + + retregs3 = mAX; + if (!I16 && e2->E2->Eoper == OPconst) + { + c1 = regwithvalue(c1, mAX, value, NULL, I64?64:0); + freenode(e2->E2); + } + else + { + c1 = cat(c1,scodelem(e2->E2,&retregs3,retregs2,FALSE)); +#if 0 + if (I32) + { + c1 = gen2(c1,0x8A,modregrm(3,AH,AL)); // MOV AH,AL + c1 = genc2(c1,0xC1,modregrm(3,4,AX),8); // SHL EAX,8 + c1 = gen2(c1,0x8A,modregrm(3,AL,AH)); // MOV AL,AH + c1 = genc2(c1,0xC1,modregrm(3,4,AX),8); // SHL EAX,8 + c1 = gen2(c1,0x8A,modregrm(3,AL,AH)); // MOV AL,AH + } +#endif + } + freenode(e2); + + // Get s into ES:DI + retregs1 = mDI; + ty1 = e->E1->Ety; + if (!tyreg(ty1)) + retregs1 |= mES; + c1 = cat(c1,scodelem(e->E1,&retregs1,retregs2 | retregs3,FALSE)); + reg = DI; //findreg(retregs1); + + // Make sure ES contains proper segment value + c2 = cod2_setES(ty1); + + c3 = NULL; + if (*pretregs) // if need return value + { c3 = getregs(mBX); + c3 = genmovreg(c3,BX,DI); + code_orrex(c3,rex); + } + + c3 = cat(c3,getregs(mDI | mCX)); + if (I16 && config.flags4 & CFG4speed) // if speed optimization + { + c3 = cat(c3,getregs(mAX)); + c3 = gen2(c3,0x8A,modregrm(3,AH,AL)); // MOV AH,AL + gen2(c3,0xD1,modregrm(3,5,CX)); // SHR CX,1 + gen1(c3,0xF3); // REP + gen1(c3,0xAB); // STOSW + gen2(c3,0x11,modregrm(3,CX,CX)); // ADC CX,CX + op = 0xAA; + } + + c3 = gen1(c3,0xF3); // REP + gen1(c3,op); // STOSD + m = buildModregrm(2,AX,reg); + if (remainder & 4) + { + code *ctmp; + ctmp = gen2(CNIL,0x89,m); + ctmp->IFL1 = FLconst; + c3 = cat(c3,ctmp); + } + if (remainder & 2) + { + code *ctmp; + ctmp = gen2(CNIL,0x89,m); + ctmp->Iflags = CFopsize; + ctmp->IEVoffset1 = remainder & 4; + ctmp->IFL1 = FLconst; + c3 = cat(c3,ctmp); + } + if (remainder & 1) + { + code *ctmp; + ctmp = gen2(CNIL,0x88,m); + ctmp->IEVoffset1 = remainder & ~1; + ctmp->IFL1 = FLconst; + c3 = cat(c3,ctmp); + } + regimmed_set(CX,0); + return cat4(c1,c2,c3,fixresult(e,mES|mBX,pretregs)); +} +#else +// BUG: Pat made many improvements in the linux version, I need +// to verify they work for 16 bits and fold them in. -Walter + +code *cdmemset(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3 = NULL,*c4; + regm_t retregs1; + regm_t retregs2; + regm_t retregs3; + tym_t ty1; + elem *e2; + targ_size_t value; + + /* + les DI,s + mov BX,DI ;Return value. + mov CX,n + mov AL,val + mov AH,AL ;Set up a 16 bit pattern. + shr CX,1 + rep stosw + adc CX,CX + rep stosb + */ + + e2 = e->E2; + assert(e2->Eoper == OPparam); + + // Get nbytes into CX + retregs2 = mCX; + c1 = codelem(e2->E1,&retregs2,FALSE); + + // Get val into AX + retregs3 = mAX; + c1 = cat(c1,scodelem(e2->E2,&retregs3,retregs2,FALSE)); + freenode(e2); + + // Get s into ES:DI + retregs1 = mDI; + ty1 = e->E1->Ety; + if (!tyreg(ty1)) + retregs1 |= mES; + c1 = cat(c1,scodelem(e->E1,&retregs1,retregs2 | retregs3,FALSE)); + + /* Make sure ES contains proper segment value */ + c2 = cod2_setES(ty1); + + c3 = NULL; + if (*pretregs) // if need return value + { c3 = getregs(mBX); + c3 = genmovreg(c3,BX,DI); + } + + c3 = cat(c3,getregs(mDI | mCX)); + if (!I32 && config.flags4 & CFG4speed) // if speed optimization + { + c3 = cat(c3,getregs(mAX)); + c3 = gen2(c3,0x8A,modregrm(3,AH,AL)); // MOV AH,AL + gen2(c3,0xD1,modregrm(3,5,CX)); // SHR CX,1 + gen1(c3,0xF3); // REP + gen1(c3,0xAB); // STOSW + gen2(c3,0x11,modregrm(3,CX,CX)); // ADC CX,CX + } + c3 = gen1(c3,0xF3); // REP + gen1(c3,0xAA); // STOSB + regimmed_set(CX,0); + return cat4(c1,c2,c3,fixresult(e,mES|mBX,pretregs)); +} +#endif + +/********************** + * Do structure assignments. + * This should be fixed so that (s1 = s2) is rewritten to (&s1 = &s2). + * Mebbe call cdstreq() for double assignments??? + */ + +code *cdstreq(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3; + code *c1a; + regm_t srcregs,dstregs; /* source & destination reg masks */ + char need_DS = FALSE; + elem *e1 = e->E1,*e2 = e->E2; + int segreg; + + unsigned numbytes = type_size(e->ET); // # of bytes in structure/union + unsigned char rex = I64 ? REX_W : 0; + + //printf("cdstreq(e = %p, *pretregs = x%x)\n", e, *pretregs); + + /* First, load pointer to rvalue into SI */ + srcregs = mSI; /* source is DS:SI */ + c1 = docommas(&e2); + if (e2->Eoper == OPind) /* if (.. = *p) */ + { elem *e21 = e2->E1; + + segreg = SEG_DS; +#if TARGET_SEGMENTED + switch (tybasic(e21->Ety)) + { + case TYsptr: + if (config.wflags & WFssneds) /* if sptr can't use DS segment */ + segreg = SEG_SS; + break; + case TYcptr: + if (!(config.exe & EX_flat)) + segreg = SEG_CS; + break; + case TYfptr: + case TYvptr: + case TYhptr: + srcregs |= mCX; /* get segment also */ + need_DS = TRUE; + break; + } +#endif + c1a = codelem(e21,&srcregs,FALSE); + freenode(e2); + if (segreg != SEG_DS) /* if not DS */ + { c1a = cat(c1a,getregs(mCX)); + c1a = gen2(c1a,0x8C,modregrm(3,segreg,CX)); /* MOV CX,segreg */ + need_DS = TRUE; + } + } + else if (e2->Eoper == OPvar) + { +#if TARGET_SEGMENTED + if (e2->EV.sp.Vsym->ty() & mTYfar) // if e2 is in a far segment + { srcregs |= mCX; /* get segment also */ + need_DS = TRUE; + c1a = cdrelconst(e2,&srcregs); + } + else +#endif + { + c1a = cdrelconst(e2,&srcregs); + segreg = segfl[el_fl(e2)]; + if ((config.wflags & WFssneds) && segreg == SEG_SS || /* if source is on stack */ + segreg == SEG_CS) /* if source is in CS */ + { code *c; + + need_DS = TRUE; /* we need to reload DS */ + // Load CX with segment + srcregs |= mCX; + c = getregs(mCX); + c = gen2(c,0x8C, /* MOV CX,[SS|CS] */ + modregrm(3,segreg,CX)); + c1a = cat(c,c1a); + } + } + freenode(e2); + } + else + { + if (!(config.exe & EX_flat)) + { need_DS = TRUE; + srcregs |= mCX; + } + c1a = codelem(e2,&srcregs,FALSE); + } + c1 = cat(c1,c1a); + + /* now get pointer to lvalue (destination) in ES:DI */ + dstregs = (config.exe & EX_flat) ? mDI : mES|mDI; + if (e1->Eoper == OPind) /* if (*p = ..) */ + { + if (tyreg(e1->E1->Ety)) + dstregs = mDI; + c2 = cod2_setES(e1->E1->Ety); + c2 = cat(c2,scodelem(e1->E1,&dstregs,srcregs,FALSE)); + } + else + c2 = cdrelconst(e1,&dstregs); + freenode(e1); + + c3 = getregs((srcregs | dstregs) & (mLSW | mDI)); + if (need_DS) + { assert(!(config.exe & EX_flat)); + c3 = gen1(c3,0x1E); /* PUSH DS */ + gen2(c3,0x8E,modregrm(3,SEG_DS,CX)); /* MOV DS,CX */ + } + if (numbytes <= REGSIZE * (6 + (REGSIZE == 4))) + { while (numbytes >= REGSIZE) + { + c3 = gen1(c3,0xA5); /* MOVSW */ + code_orrex(c3, rex); + numbytes -= REGSIZE; + } + //if (numbytes) + // printf("cdstreq numbytes %d\n",numbytes); + while (numbytes--) + c3 = gen1(c3,0xA4); /* MOVSB */ + } + else + { +#if 1 + unsigned remainder; + + remainder = numbytes & (REGSIZE - 1); + numbytes /= REGSIZE; // number of words + c3 = cat(c3,getregs_imm(mCX)); + c3 = movregconst(c3,CX,numbytes,0); // # of bytes/words + gen1(c3,0xF3); // REP + if (REGSIZE == 8) + gen1(c3,REX | REX_W); + gen1(c3,0xA5); // REP MOVSD + regimmed_set(CX,0); // note that CX == 0 + for (; remainder; remainder--) + { + gen1(c3, 0xA4); // MOVSB + } +#else + unsigned movs; + + if (numbytes & (REGSIZE - 1)) /* if odd */ + movs = 0xA4; /* MOVSB */ + else + { movs = 0xA5; /* MOVSW */ + numbytes /= REGSIZE; /* # of words */ + } + c3 = cat(c3,getregs_imm(mCX)); + c3 = movregconst(c3,CX,numbytes,0); /* # of bytes/words */ + gen1(c3,0xF3); /* REP */ + gen1(c3,movs); + regimmed_set(CX,0); /* note that CX == 0 */ +#endif + } + if (need_DS) + gen1(c3,0x1F); // POP DS + assert(!(*pretregs & mPSW)); + if (*pretregs) + { /* ES:DI points past what we want */ + regm_t retregs; + + genc2(c3,0x81,(rex << 16) | modregrm(3,5,DI), type_size(e->ET)); // SUB DI,numbytes + retregs = mDI; + if (*pretregs & mMSW && !(config.exe & EX_flat)) + retregs |= mES; + c3 = cat(c3,fixresult(e,retregs,pretregs)); + } + return cat3(c1,c2,c3); +} + + +/********************** + * Get the address of. + * Is also called by cdstreq() to set up pointer to a structure. + */ + +code *cdrelconst(elem *e,regm_t *pretregs) +{ code *c,*c1; + enum SC sclass; + unsigned mreg, /* segment of the address (TYfptrs only) */ + lreg; /* offset of the address */ + tym_t tym; + + //printf("cdrelconst(e = %p)\n", e); + + c = CNIL; + + /* The following should not happen, but cgelem.c is a little stupid. */ + /* Assertion can be tripped by func("string" == 0); and similar */ + /* things. Need to add goals to optelem() to fix this completely. */ + /*assert((*pretregs & mPSW) == 0);*/ + if (*pretregs & mPSW) + { *pretregs &= ~mPSW; + c = gentstreg(c,SP); // SP is never 0 + if (I64) + code_orrex(c, REX_W); + } + if (!*pretregs) + return c; + + assert(e); + tym = tybasic(e->Ety); + switch (tym) + { case TYstruct: + case TYarray: + case TYldouble: + case TYildouble: + case TYcldouble: + tym = TYnptr; // don't confuse allocreg() +#if TARGET_SEGMENTED + if (*pretregs & (mES | mCX) || e->Ety & mTYfar) + { + tym = TYfptr; + } +#endif + break; + case TYifunc: +#if TARGET_SEGMENTED + tym = TYfptr; +#else + assert(0); // what's the right thing to do here? TYptr? +#endif + break; + default: + if (tyfunc(tym)) + tym = +#if TARGET_SEGMENTED + tyfarfunc(tym) ? TYfptr : +#endif + TYnptr; + break; + } + /*assert(tym & typtr);*/ /* don't fail on (int)&a */ + + c = cat(c,allocreg(pretregs,&lreg,tym)); + if (tysize[tym] > REGSIZE) /* fptr could've been cast to long */ + { tym_t ety; + symbol *s; + + //elem_print(e); + assert(TARGET_SEGMENTED); + + if (*pretregs & mES) + { regm_t scratch = (mAX|mBX|mDX|mDI) & ~mask[lreg]; + /* Do not allocate CX or SI here, as cdstreq() needs */ + /* them preserved. cdstreq() should use scodelem()... */ + + c = cat(c,allocreg(&scratch,&mreg,TYint)); + } + else + { mreg = lreg; + lreg = findreglsw(*pretregs); + } + + /* if (get segment of function that isn't necessarily in the */ + /* current segment (i.e. CS doesn't have the right value in it) */ + s = e->EV.sp.Vsym; + if (s->Sfl == FLdatseg) + { assert(0); + goto loadreg; + } + sclass = (enum SC) s->Sclass; + ety = tybasic(s->ty()); + if ((tyfarfunc(ety) || ety == TYifunc) && + (sclass == SCextern || ClassInline(sclass) || config.wflags & WFthunk) +#if TARGET_SEGMENTED + || s->Sfl == FLfardata + || (s->ty() & mTYcs && s->Sseg != cseg && (LARGECODE || s->Sclass == SCcomdat)) +#endif + ) + { /* MOV mreg,seg of symbol */ + c1 = gencs(CNIL,0xB8 + mreg,0,FLextern,s); + c1->Iflags = CFseg; + c = cat(c,c1); + assert(TARGET_SEGMENTED); + } + else + { int fl; + + loadreg: + fl = s->Sfl; +#if TARGET_SEGMENTED + if (s->ty() & mTYcs) + fl = FLcsdata; +#endif + c = gen2(c,0x8C, /* MOV mreg,SEG REGISTER */ + modregrm(3,segfl[fl],mreg)); + } + if (*pretregs & mES) + gen2(c,0x8E,modregrm(3,0,mreg)); /* MOV ES,mreg */ + } + return cat(c,getoffset(e,lreg)); +} + +/********************************* + * Load the offset portion of the address represented by e into + * reg. + */ + +code *getoffset(elem *e,unsigned reg) +{ code cs; + code *c; + + //printf("getoffset(e = %p, reg = %d)\n", e, reg); + cs.Iflags = 0; + unsigned char rex = 0; + cs.Irex = rex; + assert(e->Eoper == OPvar || e->Eoper == OPrelconst); + enum FL fl = el_fl(e); + switch (fl) + { + case FLdatseg: + cs.IEV2._EP.Vpointer = e->EV.Vpointer; + goto L3; + +#if TARGET_SEGMENTED + case FLfardata: + goto L4; +#endif + + case FLtlsdata: +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + { + L5: + if (I64 && config.flags3 & CFG3pic) + { + /* Generate: + * LEA DI,s@TLSGD[RIP] + */ + assert(reg == DI); + code css; + css.Irex = REX | REX_W; + css.Iop = 0x8D; // LEA + css.Irm = modregrm(0,DI,5); + css.Iflags = CFopsize; + css.IFL1 = fl; + css.IEVsym1 = e->EV.sp.Vsym; + css.IEVoffset1 = e->EV.sp.Voffset; + c = gen(NULL, &css); + return c; + } + /* Generate: + * MOV reg,GS:[00000000] + * ADD reg, offset s@TLS_LE + * for locals, and for globals: + * MOV reg,GS:[00000000] + * ADD reg, s@TLS_IE + * note different fixup + */ + int stack = 0; + c = NULL; + if (reg == STACK) + { regm_t retregs = ALLREGS; + + c = allocreg(&retregs,®,TYoffset); + reg = findreg(retregs); + stack = 1; + } + + code css; + css.Irex = rex; + css.Iop = 0x8B; + css.Irm = modregrm(0, 0, BPRM); + code_newreg(&css, reg); + css.Iflags = CFgs; + css.IFL1 = FLconst; + css.IEV1.Vuns = 0; + c = gen(c, &css); // MOV reg,GS:[00000000] + + if (e->EV.sp.Vsym->Sclass == SCstatic || e->EV.sp.Vsym->Sclass == SClocstat) + { // ADD reg, offset s + cs.Irex = rex; + cs.Iop = 0x81; + cs.Irm = modregrm(3,0,reg & 7); + if (reg & 8) + cs.Irex |= REX_B; + cs.Iflags = CFoff; + cs.IFL2 = fl; + cs.IEVsym2 = e->EV.sp.Vsym; + cs.IEVoffset2 = e->EV.sp.Voffset; + } + else + { // ADD reg, s + cs.Irex = rex; + cs.Iop = 0x03; + cs.Irm = modregrm(0,0,BPRM); + code_newreg(&cs, reg); + cs.Iflags = CFoff; + cs.IFL1 = fl; + cs.IEVsym1 = e->EV.sp.Vsym; + cs.IEVoffset1 = e->EV.sp.Voffset; + } + c = gen(c, &cs); // ADD reg, xxxx + + if (stack) + { + c = gen1(c,0x50 + (reg & 7)); // PUSH reg + if (reg & 8) + code_orrex(c, REX_B); + c = genadjesp(c,REGSIZE); + stackchanged = 1; + } + break; + } +#else + goto L4; +#endif + + case FLfunc: + fl = FLextern; /* don't want PC relative addresses */ + goto L4; + + case FLextern: +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (e->EV.sp.Vsym->ty() & mTYthread) + goto L5; +#endif + case FLdata: + case FLudata: +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case FLgot: + case FLgotoff: +#endif +#if TARGET_SEGMENTED + case FLcsdata: +#endif + L4: + cs.IEVsym2 = e->EV.sp.Vsym; + cs.IEVoffset2 = e->EV.sp.Voffset; + L3: + if (reg == STACK) + { stackchanged = 1; + cs.Iop = 0x68; /* PUSH immed16 */ + c = genadjesp(NULL,REGSIZE); + } + else + { cs.Iop = 0xB8 + (reg & 7); // MOV reg,immed16 + if (reg & 8) + cs.Irex |= REX_B; + if (I64) + { cs.Irex |= REX_W; + if (config.flags3 & CFG3pic) + { // LEA reg,immed32[RIP] + cs.Iop = 0x8D; +#if TARGET_OSX + symbol *s = e->EV.sp.Vsym; +// if (fl == FLextern) +// cs.Iop = 0x8B; // MOV reg,[00][RIP] +#endif + cs.Irm = modregrm(0,reg & 7,5); + if (reg & 8) + cs.Irex = (cs.Irex & ~REX_B) | REX_R; + cs.IFL1 = fl; + cs.IEVsym1 = cs.IEVsym2; + cs.IEVoffset1 = cs.IEVoffset2; + } + } + c = NULL; + } + cs.Iflags = CFoff; /* want offset only */ + cs.IFL2 = fl; + c = gen(c,&cs); + break; + +#if 0 && TARGET_LINUX + case FLgot: + case FLgotoff: + { + gotref = 1; + symbol *s = e->EV.sp.Vsym; + // When using 8B (MOV), indicating that rm is used + // rm operands are always placed in IEV1 not IEV2 + cs.IEVsym1 = s; + cs.IEVoffset1 = e->EV.sp.Voffset; + cs.Irm = modregrm(2,reg,BX); // reg,disp32[EBX] + cs.IFL1 = fl; + cs.Iop = (fl == FLgotoff) + ? 0x8D // LEA reg, s[EBX] + : 0x8B; // MOV reg, s[EBX] + cs.Iflags = CFoff; // want offset only + c = gen(NULL,&cs); + break; + } +#endif + + case FLreg: + /* Allow this since the tree optimizer puts & in front of */ + /* register doubles. */ + goto L2; + case FLauto: + case FLtmp: + case FLbprel: + case FLfltreg: + reflocal = TRUE; + goto L2; + case FLpara: + refparam = TRUE; + L2: + if (reg == STACK) + { regm_t retregs = ALLREGS; + + c = allocreg(&retregs,®,TYoffset); + reg = findreg(retregs); + c = cat(c,loadea(e,&cs,0x8D,reg,0,0,0)); /* LEA reg,EA */ + if (I64) + code_orrex(c, REX_W); + c = gen1(c,0x50 + (reg & 7)); // PUSH reg + if (reg & 8) + code_orrex(c, REX_B); + c = genadjesp(c,REGSIZE); + stackchanged = 1; + } + else + { c = loadea(e,&cs,0x8D,reg,0,0,0); /* LEA reg,EA */ + if (I64) + code_orrex(c, REX_W); + } + break; + default: +#ifdef DEBUG + elem_print(e); + debugx(WRFL(fl)); +#endif + assert(0); + } + return c; +} + + +/****************** + * Negate, sqrt operator + */ + +code *cdneg(elem *e,regm_t *pretregs) +{ unsigned byte; + regm_t retregs,possregs; + int reg; + int sz; + tym_t tyml; + code *c,*c1,*cg; + + //printf("cdneg()\n"); + //elem_print(e); + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + tyml = tybasic(e->E1->Ety); + sz = tysize[tyml]; + if (tyfloating(tyml)) + { if (tycomplex(tyml)) + return neg_complex87(e, pretregs); + if (tyxmmreg(tyml) && e->Eoper == OPneg && *pretregs & XMMREGS) + return xmmneg(e,pretregs); + if (config.inline8087 && + ((*pretregs & (ALLREGS | mBP)) == 0 || e->Eoper == OPsqrt || I64)) + return neg87(e,pretregs); + retregs = (I16 && sz == 8) ? DOUBLEREGS_16 : ALLREGS; + c1 = codelem(e->E1,&retregs,FALSE); + c1 = cat(c1,getregs(retregs)); + if (I32) + { reg = (sz == 8) ? findregmsw(retregs) : findreg(retregs); + c1 = genc2(c1,0x81,modregrm(3,6,reg),0x80000000); /* XOR EDX,sign bit */ + } + else + { reg = (sz == 8) ? AX : findregmsw(retregs); + c1 = genc2(c1,0x81,modregrm(3,6,reg),0x8000); /* XOR AX,0x8000 */ + } + return cat(c1,fixresult(e,retregs,pretregs)); + } + + byte = sz == 1; + possregs = (byte) ? BYTEREGS : allregs; + retregs = *pretregs & possregs; + if (retregs == 0) + retregs = possregs; + c1 = codelem(e->E1,&retregs,FALSE); + cg = getregs(retregs); /* retregs will be destroyed */ + if (sz <= REGSIZE) + { + unsigned reg = findreg(retregs); + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + if (I64 && sz == 1 && reg >= 4) + rex |= REX; + c = gen2(CNIL,0xF7 ^ byte,(rex << 16) | modregrmx(3,3,reg)); // NEG reg + if (!I16 && tysize[tyml] == SHORTSIZE && *pretregs & mPSW) + c->Iflags |= CFopsize | CFpsw; + *pretregs &= mBP | ALLREGS; // flags already set + } + else if (sz == 2 * REGSIZE) + { unsigned msreg,lsreg; + + msreg = findregmsw(retregs); + c = gen2(CNIL,0xF7,modregrm(3,3,msreg)); /* NEG msreg */ + lsreg = findreglsw(retregs); + gen2(c,0xF7,modregrm(3,3,lsreg)); /* NEG lsreg */ + genc2(c,0x81,modregrm(3,3,msreg),0); /* SBB msreg,0 */ + } + else + assert(0); + return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); +} + + +/****************** + * Absolute value operator + */ + +code *cdabs( elem *e, regm_t *pretregs) +{ unsigned byte; + regm_t retregs,possregs; + int reg; + tym_t tyml; + code *c,*c1,*cg; + + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + tyml = tybasic(e->E1->Ety); + int sz = tysize[tyml]; + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + if (tyfloating(tyml)) + { if (config.inline8087 && ((*pretregs & (ALLREGS | mBP)) == 0 || I64)) + return neg87(e,pretregs); + retregs = (!I32 && sz == 8) ? DOUBLEREGS_16 : ALLREGS; + c1 = codelem(e->E1,&retregs,FALSE); + /*cg = callclib(e,CLIBdneg,pretregs,0);*/ + c1 = cat(c1,getregs(retregs)); + if (I32) + { reg = (sz == 8) ? findregmsw(retregs) : findreg(retregs); + c1 = genc2(c1,0x81,modregrm(3,4,reg),0x7FFFFFFF); /* AND EDX,~sign bit */ + } + else + { reg = (sz == 8) ? AX : findregmsw(retregs); + c1 = genc2(c1,0x81,modregrm(3,4,reg),0x7FFF); /* AND AX,0x7FFF */ + } + return cat(c1,fixresult(e,retregs,pretregs)); + } + + byte = sz == 1; + assert(byte == 0); + byte = 0; + possregs = (sz <= REGSIZE) ? mAX : allregs; + if (!I16 && sz == REGSIZE) + possregs = allregs; + retregs = *pretregs & possregs; + if (retregs == 0) + retregs = possregs; + c1 = codelem(e->E1,&retregs,FALSE); + cg = getregs(retregs); /* retregs will be destroyed */ + if (sz <= REGSIZE) + { + /* CWD + XOR AX,DX + SUB AX,DX + or: + MOV r,reg + SAR r,63 + XOR reg,r + SUB reg,r + */ + unsigned reg; + unsigned r; + + if (!I16 && sz == REGSIZE) + { regm_t scratch = allregs & ~retregs; + reg = findreg(retregs); + cg = allocreg(&scratch,&r,TYint); + cg = cat(cg,getregs(retregs)); + cg = genmovreg(cg,r,reg); // MOV r,reg + cg = genc2(cg,0xC1,modregrmx(3,7,r),REGSIZE * 8 - 1); // SAR r,31/63 + code_orrex(cg, rex); + } + else + { + reg = AX; + r = DX; + cg = cat(cg,getregs(mDX)); + if (!I16 && sz == SHORTSIZE) + cg = gen1(cg,0x98); // CWDE + cg = gen1(cg,0x99); // CWD + code_orrex(cg, rex); + } + gen2(cg,0x33 ^ byte,(rex << 16) | modregxrmx(3,reg,r)); // XOR reg,r + c = gen2(CNIL,0x2B ^ byte,(rex << 16) | modregxrmx(3,reg,r)); // SUB reg,r + if (!I16 && sz == SHORTSIZE && *pretregs & mPSW) + c->Iflags |= CFopsize | CFpsw; + if (*pretregs & mPSW) + c->Iflags |= CFpsw; + *pretregs &= ~mPSW; // flags already set + } + else if (sz == 2 * REGSIZE) + { unsigned msreg,lsreg; + code *cnop; + + /* tst DX + jns L2 + neg DX + neg AX + sbb DX,0 + L2: + */ + + cnop = gennop(CNIL); + msreg = findregmsw(retregs); + lsreg = findreglsw(retregs); + c = genorreg(CNIL,msreg,msreg); + c = genjmp(c,JNS,FLcode,(block *)cnop); + c = gen2(c,0xF7,modregrm(3,3,msreg)); // NEG msreg + gen2(c,0xF7,modregrm(3,3,lsreg)); // NEG lsreg+1 + genc2(c,0x81,modregrm(3,3,msreg),0); // SBB msreg,0 + c = cat(c,cnop); + } + else + assert(0); + return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); +} + +/************************** + * Post increment and post decrement. + */ + +code *cdpost(elem *e,regm_t *pretregs) +{ code cs,*c1,*c2,*c3,*c5,*c6; + unsigned reg,op,byte; + tym_t tyml; + regm_t retregs,possregs,idxregs; + targ_int n; + elem *e2; + int sz; + int stackpushsave; + + //printf("cdpost(pretregs = %s)\n", regm_str(*pretregs)); + retregs = *pretregs; + op = e->Eoper; /* OPxxxx */ + if (retregs == 0) /* if nothing to return */ + return cdaddass(e,pretregs); + c5 = CNIL; + tyml = tybasic(e->E1->Ety); + sz = tysize[tyml]; + e2 = e->E2; + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + + if (tyfloating(tyml)) + { +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + return post87(e,pretregs); +#else + if (config.inline8087) + return post87(e,pretregs); + assert(sz <= 8); + c1 = getlvalue(&cs,e->E1,DOUBLEREGS); + freenode(e->E1); + idxregs = idxregm(&cs); // mask of index regs used + cs.Iop = 0x8B; /* MOV DOUBLEREGS,EA */ + c2 = fltregs(&cs,tyml); + stackchanged = 1; + stackpushsave = stackpush; + if (sz == 8) + { + if (I32) + { + gen1(c2,0x50 + DX); /* PUSH DOUBLEREGS */ + gen1(c2,0x50 + AX); + stackpush += DOUBLESIZE; + retregs = DOUBLEREGS2_32; + } + else + { + gen1(c2,0x50 + AX); + gen1(c2,0x50 + BX); + gen1(c2,0x50 + CX); + gen1(c2,0x50 + DX); /* PUSH DOUBLEREGS */ + stackpush += DOUBLESIZE + DOUBLESIZE; + + gen1(c2,0x50 + AX); + gen1(c2,0x50 + BX); + gen1(c2,0x50 + CX); + gen1(c2,0x50 + DX); /* PUSH DOUBLEREGS */ + retregs = DOUBLEREGS_16; + } + } + else + { + stackpush += FLOATSIZE; /* so we know something is on */ + if (!I32) + gen1(c2,0x50 + DX); + gen1(c2,0x50 + AX); + retregs = FLOATREGS2; + } + c2 = genadjesp(c2,stackpush - stackpushsave); + + cgstate.stackclean++; + c3 = scodelem(e2,&retregs,idxregs,FALSE); + cgstate.stackclean--; + + code *c4; + if (tyml == TYdouble || tyml == TYdouble_alias) + { + retregs = DOUBLEREGS; + c4 = callclib(e,(op == OPpostinc) ? CLIBdadd : CLIBdsub, + &retregs,idxregs); + } + else /* tyml == TYfloat */ + { + retregs = FLOATREGS; + c4 = callclib(e,(op == OPpostinc) ? CLIBfadd : CLIBfsub, + &retregs,idxregs); + } + cs.Iop = 0x89; /* MOV EA,DOUBLEREGS */ + c5 = fltregs(&cs,tyml); + stackpushsave = stackpush; + if (tyml == TYdouble || tyml == TYdouble_alias) + { if (*pretregs == mSTACK) + retregs = mSTACK; /* leave result on stack */ + else + { + if (I32) + { gen1(c5,0x58 + AX); + gen1(c5,0x58 + DX); + } + else + { gen1(c5,0x58 + DX); + gen1(c5,0x58 + CX); + gen1(c5,0x58 + BX); + gen1(c5,0x58 + AX); + } + stackpush -= DOUBLESIZE; + retregs = DOUBLEREGS; + } + } + else + { gen1(c5,0x58 + AX); + if (!I32) + gen1(c5,0x58 + DX); + stackpush -= FLOATSIZE; + retregs = FLOATREGS; + } + c5 = genadjesp(c5,stackpush - stackpushsave); + c6 = fixresult(e,retregs,pretregs); + return cat6(c1,c2,c3,c4,c5,c6); +#endif + } + + assert(e2->Eoper == OPconst); + byte = (sz == 1); + possregs = byte ? BYTEREGS : allregs; + c1 = getlvalue(&cs,e->E1,0); + freenode(e->E1); + idxregs = idxregm(&cs); // mask of index regs used + if (sz <= REGSIZE && *pretregs == mPSW && (cs.Irm & 0xC0) == 0xC0 && + (!I16 || (idxregs & (mBX | mSI | mDI | mBP)))) + { // Generate: + // TEST reg,reg + // LEA reg,n[reg] // don't affect flags + int rm; + + reg = cs.Irm & 7; + if (cs.Irex & REX_B) + reg |= 8; + cs.Iop = 0x85 ^ byte; + code_newreg(&cs, reg); + cs.Iflags |= CFpsw; + c2 = gen(NULL,&cs); // TEST reg,reg + + // If lvalue is a register variable, we must mark it as modified + c3 = modEA(&cs); + + n = e2->EV.Vint; + if (op == OPpostdec) + n = -n; + rm = reg; + if (I16) + rm = regtorm[reg]; + code *c4 = genc1(NULL,0x8D,(rex << 16) | buildModregrm(2,reg,rm),FLconst,n); // LEA reg,n[reg] + return cat4(c1,c2,c3,c4); + } + else if (sz <= REGSIZE || tyfv(tyml)) + { code cs2; + + cs.Iop = 0x8B ^ byte; + retregs = possregs & ~idxregs & *pretregs; + if (!tyfv(tyml)) + { if (retregs == 0) + retregs = possregs & ~idxregs; + } + else /* tyfv(tyml) */ + { if ((retregs &= mLSW) == 0) + retregs = mLSW & ~idxregs; + /* Can't use LES if the EA uses ES as a seg override */ + if (*pretregs & mES && (cs.Iflags & CFSEG) != CFes) + { cs.Iop = 0xC4; /* LES */ + c1 = cat(c1,getregs(mES)); /* allocate ES */ + } + } + c2 = allocreg(&retregs,®,TYint); + code_newreg(&cs, reg); + if (sz == 1 && I64 && reg >= 4) + cs.Irex |= REX; + c3 = gen(CNIL,&cs); /* MOV reg,EA */ + cs2 = cs; + + /* If lvalue is a register variable, we must mark it as modified */ + c3 = cat(c3,modEA(&cs)); + + cs.Iop = 0x81 ^ byte; + cs.Irm &= ~modregrm(0,7,0); /* reg field = 0 */ + cs.Irex &= ~REX_R; + if (op == OPpostdec) + cs.Irm |= modregrm(0,5,0); /* SUB */ + cs.IFL2 = FLconst; + n = e2->EV.Vint; + cs.IEV2.Vint = n; + if (n == 1) /* can use INC or DEC */ + { cs.Iop |= 0xFE; /* xFE is dec byte, xFF is word */ + if (op == OPpostdec) + NEWREG(cs.Irm,1); // DEC EA + else + NEWREG(cs.Irm,0); // INC EA + } + else if (n == -1) // can use INC or DEC + { cs.Iop |= 0xFE; // xFE is dec byte, xFF is word + if (op == OPpostinc) + NEWREG(cs.Irm,1); // DEC EA + else + NEWREG(cs.Irm,0); // INC EA + } + + // For scheduling purposes, we wish to replace: + // MOV reg,EA + // OP EA + // with: + // MOV reg,EA + // OP reg + // MOV EA,reg + // ~OP reg + if (sz <= REGSIZE && (cs.Irm & 0xC0) != 0xC0 && + config.target_cpu >= TARGET_Pentium && + config.flags4 & CFG4speed) + { + // Replace EA in cs with reg + cs.Irm = (cs.Irm & ~modregrm(3,0,7)) | modregrm(3,0,reg & 7); + if (reg & 8) + { cs.Irex &= ~REX_R; + cs.Irex |= REX_B; + } + else + cs.Irex &= ~REX_B; + if (I64 && sz == 1 && reg >= 4) + cs.Irex |= REX; + gen(c3,&cs); // ADD/SUB reg,const + + // Reverse MOV direction + cs2.Iop ^= 2; + gen(c3,&cs2); // MOV EA,reg + + // Toggle INC <-> DEC, ADD <-> SUB + cs.Irm ^= (n == 1 || n == -1) ? modregrm(0,1,0) : modregrm(0,5,0); + gen(c3,&cs); + + if (*pretregs & mPSW) + { *pretregs &= ~mPSW; // flags already set + code_orflag(c3,CFpsw); + } + } + else + gen(c3,&cs); // ADD/SUB EA,const + + freenode(e2); + if (tyfv(tyml)) + { unsigned preg; + + getlvalue_msw(&cs); + if (*pretregs & mES) + { preg = ES; + /* ES is already loaded if CFes is 0 */ + cs.Iop = ((cs.Iflags & CFSEG) == CFes) ? 0x8E : NOP; + NEWREG(cs.Irm,0); /* MOV ES,EA+2 */ + } + else + { + retregs = *pretregs & mMSW; + if (!retregs) + retregs = mMSW; + c3 = cat(c3,allocreg(&retregs,&preg,TYint)); + cs.Iop = 0x8B; + if (I32) + cs.Iflags |= CFopsize; + NEWREG(cs.Irm,preg); /* MOV preg,EA+2 */ + } + c3 = cat(c3,getregs(mask[preg])); + gen(c3,&cs); + retregs = mask[reg] | mask[preg]; + } + return cat4(c1,c2,c3,fixresult(e,retregs,pretregs)); + } +#if TARGET_SEGMENTED + else if (tyml == TYhptr) + { + unsigned long rvalue; + unsigned lreg; + unsigned rtmp; + regm_t mtmp; + + rvalue = e2->EV.Vlong; + freenode(e2); + + // If h--, convert to h++ + if (e->Eoper == OPpostdec) + rvalue = -rvalue; + + retregs = mLSW & ~idxregs & *pretregs; + if (!retregs) + retregs = mLSW & ~idxregs; + c1 = cat(c1,allocreg(&retregs,&lreg,TYint)); + + // Can't use LES if the EA uses ES as a seg override + if (*pretregs & mES && (cs.Iflags & CFSEG) != CFes) + { cs.Iop = 0xC4; + retregs |= mES; + c1 = cat(c1,getregs(mES|mCX)); // allocate ES + cs.Irm |= modregrm(0,lreg,0); + c2 = gen(CNIL,&cs); // LES lreg,EA + } + else + { cs.Iop = 0x8B; + retregs |= mDX; + c1 = cat(c1,getregs(mDX|mCX)); + cs.Irm |= modregrm(0,lreg,0); + c2 = gen(CNIL,&cs); // MOV lreg,EA + NEWREG(cs.Irm,DX); + getlvalue_msw(&cs); + gen(c2,&cs); // MOV DX,EA+2 + getlvalue_lsw(&cs); + } + + // Allocate temporary register, rtmp + mtmp = ALLREGS & ~mCX & ~idxregs & ~retregs; + c2 = cat(c2,allocreg(&mtmp,&rtmp,TYint)); + + movregconst(c2,rtmp,rvalue >> 16,0); // MOV rtmp,e2+2 + c3 = getregs(mtmp); + cs.Iop = 0x81; + NEWREG(cs.Irm,0); + cs.IFL2 = FLconst; + cs.IEV2.Vint = rvalue; + c3 = gen(c3,&cs); // ADD EA,e2 + code_orflag(c3,CFpsw); + genc2(c3,0x81,modregrm(3,2,rtmp),0); // ADC rtmp,0 + genshift(c3); // MOV CX,offset __AHSHIFT + gen2(c3,0xD3,modregrm(3,4,rtmp)); // SHL rtmp,CL + cs.Iop = 0x01; + NEWREG(cs.Irm,rtmp); // ADD EA+2,rtmp + getlvalue_msw(&cs); + gen(c3,&cs); + return cat4(c1,c2,c3,fixresult(e,retregs,pretregs)); + } +#endif + else if (sz == 2 * REGSIZE) + { unsigned sreg; + + retregs = allregs & ~idxregs & *pretregs; + if ((retregs & mLSW) == 0) + retregs |= mLSW & ~idxregs; + if ((retregs & mMSW) == 0) + retregs |= ALLREGS & mMSW; + assert(retregs & mMSW && retregs & mLSW); + c2 = allocreg(&retregs,®,tyml); + sreg = findreglsw(retregs); + cs.Iop = 0x8B; + cs.Irm |= modregrm(0,sreg,0); + c3 = gen(CNIL,&cs); /* MOV sreg,EA */ + NEWREG(cs.Irm,reg); + getlvalue_msw(&cs); + gen(c3,&cs); /* MOV reg,EA+2 */ + cs.Iop = 0x81; + cs.Irm &= ~modregrm(0,7,0); /* reg field = 0 for ADD */ + if (op == OPpostdec) + cs.Irm |= modregrm(0,5,0); /* SUB */ + getlvalue_lsw(&cs); + cs.IFL2 = FLconst; + cs.IEV2.Vlong = e2->EV.Vlong; + gen(c3,&cs); /* ADD/SUB EA,const */ + code_orflag(c3,CFpsw); + getlvalue_msw(&cs); + cs.IEV2.Vlong = 0; + if (op == OPpostinc) + cs.Irm ^= modregrm(0,2,0); /* ADC */ + else + cs.Irm ^= modregrm(0,6,0); /* SBB */ + cs.IEV2.Vlong = e2->EV.Vullong >> (REGSIZE * 8); + gen(c3,&cs); /* ADC/SBB EA,0 */ + freenode(e2); + return cat4(c1,c2,c3,fixresult(e,retregs,pretregs)); + } + else + { assert(0); + /* NOTREACHED */ + return 0; + } +} + + +code *cderr(elem *e,regm_t *pretregs) +{ +#if DEBUG + elem_print(e); +#endif +//printf("op = %d, %d\n", e->Eoper, OPstring); +//printf("string = %p, len = %d\n", e->EV.ss.Vstring, e->EV.ss.Vstrlen); +//printf("string = '%.*s'\n", e->EV.ss.Vstrlen, e->EV.ss.Vstring); + assert(0); + return 0; +} + +code *cdinfo(elem *e,regm_t *pretregs) +{ + code cs; + code *c; + regm_t retregs; + + switch (e->E1->Eoper) + { +#if MARS + case OPdctor: + c = codelem(e->E2,pretregs,FALSE); + retregs = 0; + c = cat(c,codelem(e->E1,&retregs,FALSE)); + break; +#endif +#if SCPP + case OPdtor: + c = cdcomma(e,pretregs); + break; + case OPctor: + c = codelem(e->E2,pretregs,FALSE); + retregs = 0; + c = cat(c,codelem(e->E1,&retregs,FALSE)); + break; + case OPmark: + if (0 && config.exe == EX_NT) + { unsigned idx; + + idx = except_index_get(); + except_mark(); + c = codelem(e->E2,pretregs,FALSE); + if (config.exe == EX_NT && idx != except_index_get()) + { usednteh |= NTEHcleanup; + c = cat(c,nteh_gensindex(idx - 1)); + } + except_release(); + assert(idx == except_index_get()); + } + else + { +#if 0 + usednteh |= EHcleanup; + if (config.exe == EX_NT) + usednteh |= NTEHcleanup; +#endif + cs.Iop = ESCAPE | ESCmark; + cs.Iflags = 0; + cs.Irex = 0; + c = gen(CNIL,&cs); + c = cat(c,codelem(e->E2,pretregs,FALSE)); + cs.Iop = ESCAPE | ESCrelease; + gen(c,&cs); + } + freenode(e->E1); + break; +#endif + default: + assert(0); + } + return c; +} + +/******************************************* + * D constructor. + */ + +code *cddctor(elem *e,regm_t *pretregs) +{ +#if MARS + /* Generate: + ESCAPE | ESCdctor + MOV sindex[BP],index + */ + usednteh |= EHcleanup; + if (config.exe == EX_NT) + { usednteh |= NTEHcleanup | NTEH_try; + nteh_usevars(); + } + assert(*pretregs == 0); + code cs; + cs.Iop = ESCAPE | ESCdctor; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLctor; + cs.IEV1.Vtor = e; + code *c = gen(CNIL,&cs); + c = cat(c, nteh_gensindex(0)); // the actual index will be patched in later + // by except_fillInEHTable() + return c; +#else + return NULL; +#endif +} + +/******************************************* + * D destructor. + */ + +code *cdddtor(elem *e,regm_t *pretregs) +{ +#if MARS + /* Generate: + ESCAPE | ESCddtor + MOV sindex[BP],index + CALL dtor + JMP L1 + Ldtor: + ... e->E1 ... + RET + L1: NOP + */ + usednteh |= EHcleanup; + if (config.exe == EX_NT) + { usednteh |= NTEHcleanup | NTEH_try; + nteh_usevars(); + } + + code cs; + cs.Iop = ESCAPE | ESCddtor; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLdtor; + cs.IEV1.Vtor = e; + code *cd = gen(CNIL,&cs); + + cd = cat(cd, nteh_gensindex(0)); // the actual index will be patched in later + // by except_fillInEHTable() + + assert(*pretregs == 0); + code *c = codelem(e->E1,pretregs,FALSE); + gen1(c,0xC3); // RET + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic) + { + int nalign = 0; + if (STACKALIGN == 16) + { nalign = STACKALIGN - REGSIZE; + cd = genc2(cd,0x81,modregrm(3,5,SP),nalign); // SUB ESP,nalign + if (I64) + code_orrex(cd, REX_W); + } + calledafunc = 1; + genjmp(cd,0xE8,FLcode,(block *)c); // CALL Ldtor + if (nalign) + { cd = genc2(cd,0x81,modregrm(3,0,SP),nalign); // ADD ESP,nalign + if (I64) + code_orrex(cd, REX_W); + } + } + else +#endif + genjmp(cd,0xE8,FLcode,(block *)c); // CALL Ldtor + + code *cnop = gennop(CNIL); + + genjmp(cd,JMP,FLcode,(block *)cnop); + + return cat4(cd, c, cnop, NULL); +#else + return NULL; +#endif +} + + +/******************************************* + * C++ constructor. + */ + +code *cdctor(elem *e,regm_t *pretregs) +{ +#if SCPP + code cs; + code *c; + +#if 0 + if (config.exe == EX_NT) + { usednteh |= NTEHcleanup; + except_push(NULL,e,NULL); + return nteh_gensindex(except_index_get() - 1); + } +#else + usednteh |= EHcleanup; + if (config.exe == EX_NT) + usednteh |= NTEHcleanup; +#endif + assert(*pretregs == 0); + cs.Iop = ESCAPE | ESCctor; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLctor; + cs.IEV1.Vtor = e; + c = gen(CNIL,&cs); + //except_push(c,e,NULL); + return c; +#else + return NULL; +#endif +} + +code *cddtor(elem *e,regm_t *pretregs) +{ +#if SCPP + code cs; + code *c; + +#if 0 + if (config.exe == EX_NT) + { usednteh |= NTEHcleanup; + except_pop(NULL,e,NULL); + return nteh_gensindex(except_index_get() - 1); + } +#else + usednteh |= EHcleanup; + if (config.exe == EX_NT) + usednteh |= NTEHcleanup; +#endif + assert(*pretregs == 0); + cs.Iop = ESCAPE | ESCdtor; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLdtor; + cs.IEV1.Vtor = e; + c = gen(CNIL,&cs); + //except_pop(c,e,NULL); + return c; +#else + return NULL; +#endif +} + +code *cdmark(elem *e,regm_t *pretregs) +{ + return NULL; +} + +#if !NTEXCEPTIONS +code *cdsetjmp(elem *e,regm_t *pretregs) +{ + assert(0); + return NULL; +} +#endif + +/***************************************** + */ + +code *cdvoid(elem *e,regm_t *pretregs) +{ + assert(*pretregs == 0); + return codelem(e->E1,pretregs,FALSE); +} + +/***************************************** + */ + +code *cdhalt(elem *e,regm_t *pretregs) +{ + assert(*pretregs == 0); + return gen1(NULL, 0xF4); // HLT +} + +/**************************************** + * Check to see if pointer is NULL. + */ + +code *cdnullcheck(elem *e,regm_t *pretregs) +{ regm_t retregs; + regm_t scratch; + unsigned reg; + code *c; + code *cs; + + assert(!I16); + retregs = *pretregs; + if ((retregs & allregs) == 0) + retregs |= allregs; + c = codelem(e->E1,&retregs,FALSE); + scratch = allregs & ~retregs; + cs = allocreg(&scratch,®,TYint); + unsigned rex = I64 ? REX_W : 0; + cs = genc1(cs,0x8B,(rex << 16) | buildModregrm(2,reg,findreg(retregs)),FLconst,0); // MOV reg,0[e] + return cat3(c,cs,fixresult(e,retregs,pretregs)); +} + +#endif // !SPP diff --git a/backend/cod3.c b/backend/cod3.c new file mode 100644 index 00000000..7848ade4 --- /dev/null +++ b/backend/cod3.c @@ -0,0 +1,6458 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include "cc.h" +#include "el.h" +#include "code.h" +#include "oper.h" +#include "global.h" +#include "type.h" +#include "tinfo.h" +#if SCPP +#include "exh.h" +#endif + +#if HYDRATE +#include "parser.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +extern targ_size_t retsize; +STATIC void pinholeopt_unittest(); +STATIC void do8bit (enum FL,union evc *); +STATIC void do16bit (enum FL,union evc *,int); +STATIC void do32bit (enum FL,union evc *,int,targ_size_t = 0); +STATIC void do64bit (enum FL,union evc *,int); + +static int hasframe; /* !=0 if this function has a stack frame */ +static targ_size_t Foff; // BP offset of floating register +static targ_size_t CSoff; // offset of common sub expressions +static targ_size_t NDPoff; // offset of saved 8087 registers +int BPoff; // offset from BP +static int EBPtoESP; // add to EBP offset to get ESP offset +static int AAoff; // offset of alloca temporary + +#if ELFOBJ || MACHOBJ +#define JMPSEG CDATA +#define JMPOFF CDoffset +#else +#define JMPSEG DATA +#define JMPOFF Doffset +#endif + +/************* + * Size in bytes of each instruction. + * 0 means illegal instruction. + * bit M: if there is a modregrm field (EV1 is reserved for modregrm) + * bit T: if there is a second operand (EV2) + * bit E: if second operand is only 8 bits + * bit A: a short version exists for the AX reg + * bit R: a short version exists for regs + * bits 2..0: size of instruction (excluding optional bytes) + */ + +#define M 0x80 +#define T 0x40 +#define E 0x20 +#define A 0x10 +#define R 0x08 +#define W 0 + +static unsigned char inssize[256] = +{ M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 00 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 08 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 10 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 18 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 20 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 28 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 30 */ + M|2,M|2,M|2,M|2, T|E|2,T|3,1,1, /* 38 */ + 1,1,1,1, 1,1,1,1, /* 40 */ + 1,1,1,1, 1,1,1,1, /* 48 */ + 1,1,1,1, 1,1,1,1, /* 50 */ + 1,1,1,1, 1,1,1,1, /* 58 */ + 1,1,M|2,M|2, 1,1,1,1, /* 60 */ + T|3,M|T|4,T|E|2,M|T|E|3, 1,1,1,1, /* 68 */ + T|E|2,T|E|2,T|E|2,T|E|2, T|E|2,T|E|2,T|E|2,T|E|2, /* 70 */ + T|E|2,T|E|2,T|E|2,T|E|2, T|E|2,T|E|2,T|E|2,T|E|2, /* 78 */ + M|T|E|A|3,M|T|A|4,M|T|E|3,M|T|E|3, M|2,M|2,M|2,M|A|R|2, /* 80 */ + M|A|2,M|A|2,M|A|2,M|A|2, M|2,M|2,M|2,M|R|2, /* 88 */ + 1,1,1,1, 1,1,1,1, /* 90 */ + 1,1,T|5,1, 1,1,1,1, /* 98 */ +#if 0 /* cod3_set32() patches this */ + T|5,T|5,T|5,T|5, 1,1,1,1, /* A0 */ +#else + T|3,T|3,T|3,T|3, 1,1,1,1, /* A0 */ +#endif + T|E|2,T|3,1,1, 1,1,1,1, /* A8 */ + T|E|2,T|E|2,T|E|2,T|E|2, T|E|2,T|E|2,T|E|2,T|E|2, /* B0 */ + T|3,T|3,T|3,T|3, T|3,T|3,T|3,T|3, /* B8 */ + M|T|E|3,M|T|E|3,T|3,1, M|2,M|2,M|T|E|R|3,M|T|R|4, /* C0 */ + T|E|4,1,T|3,1, 1,T|E|2,1,1, /* C8 */ + M|2,M|2,M|2,M|2, T|E|2,T|E|2,0,1, /* D0 */ + /* For the floating instructions, allow room for the FWAIT */ + M|2,M|2,M|2,M|2, M|2,M|2,M|2,M|2, /* D8 */ + T|E|2,T|E|2,T|E|2,T|E|2, T|E|2,T|E|2,T|E|2,T|E|2, /* E0 */ + T|3,T|3,T|5,T|E|2, 1,1,1,1, /* E8 */ + 1,0,1,1, 1,1,M|A|2,M|A|2, /* F0 */ + 1,1,1,1, 1,1,M|2,M|R|2 /* F8 */ +}; + +static const unsigned char inssize32[256] = +{ 2,2,2,2, 2,5,1,1, /* 00 */ + 2,2,2,2, 2,5,1,1, /* 08 */ + 2,2,2,2, 2,5,1,1, /* 10 */ + 2,2,2,2, 2,5,1,1, /* 18 */ + 2,2,2,2, 2,5,1,1, /* 20 */ + 2,2,2,2, 2,5,1,1, /* 28 */ + 2,2,2,2, 2,5,1,1, /* 30 */ + 2,2,2,2, 2,5,1,1, /* 38 */ + 1,1,1,1, 1,1,1,1, /* 40 */ + 1,1,1,1, 1,1,1,1, /* 48 */ + 1,1,1,1, 1,1,1,1, /* 50 */ + 1,1,1,1, 1,1,1,1, /* 58 */ + 1,1,2,2, 1,1,1,1, /* 60 */ + 5,6,2,3, 1,1,1,1, /* 68 */ + 2,2,2,2, 2,2,2,2, /* 70 */ + 2,2,2,2, 2,2,2,2, /* 78 */ + 3,6,3,3, 2,2,2,2, /* 80 */ + 2,2,2,2, 2,2,2,2, /* 88 */ + 1,1,1,1, 1,1,1,1, /* 90 */ + 1,1,7,1, 1,1,1,1, /* 98 */ + 5,5,5,5, 1,1,1,1, /* A0 */ + 2,5,1,1, 1,1,1,1, /* A8 */ + 2,2,2,2, 2,2,2,2, /* B0 */ + 5,5,5,5, 5,5,5,5, /* B8 */ + 3,3,3,1, 2,2,3,6, /* C0 */ + 4,1,3,1, 1,2,1,1, /* C8 */ + 2,2,2,2, 2,2,0,1, /* D0 */ + /* For the floating instructions, don't need room for the FWAIT */ + 2,2,2,2, 2,2,2,2, /* D8 */ + + 2,2,2,2, 2,2,2,2, /* E0 */ + 5,5,7,2, 1,1,1,1, /* E8 */ + 1,0,1,1, 1,1,2,2, /* F0 */ + 1,1,1,1, 1,1,2,2 /* F8 */ +}; + +/* For 2 byte opcodes starting with 0x0F */ +static unsigned char inssize2[256] = +{ M|3,M|3,M|3,M|3, 2,2,2,2, // 00 + 2,2,M|3,2, 2,2,2,M|T|E|4, // 08 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 10 + M|3,2,2,2, 2,2,2,2, // 18 + M|3,M|3,M|3,M|3, M|3,2,M|3,2, // 20 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 28 + 2,2,2,2, 2,2,2,2, // 30 + M|4,2,M|T|E|5,2, 2,2,2,2, // 38 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 40 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 48 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 50 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 58 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 60 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 68 + M|T|E|4,M|T|E|4,M|T|E|4,M|T|E|4, M|3,M|3,M|3,2, // 70 + 2,2,2,2, M|3,M|3,M|3,M|3, // 78 + W|T|4,W|T|4,W|T|4,W|T|4, W|T|4,W|T|4,W|T|4,W|T|4, // 80 + W|T|4,W|T|4,W|T|4,W|T|4, W|T|4,W|T|4,W|T|4,W|T|4, // 88 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 90 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // 98 + 2,2,2,M|3, M|T|E|4,M|3,2,2, // A0 + 2,2,2,M|3, M|T|E|4,M|3,M|3,M|3, // A8 + M|E|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // B0 + M|3,2,M|T|E|4,M|3, M|3,M|3,M|3,M|3, // B8 + M|3,M|3,M|T|E|4,M|3, M|T|E|4,M|T|E|4,M|T|E|4,M|3, // C0 + 2,2,2,2, 2,2,2,2, // C8 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // D0 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // D8 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // E0 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // E8 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,M|3, // F0 + M|3,M|3,M|3,M|3, M|3,M|3,M|3,2 // F8 +}; + +/************************************************* + * Allocate register temporaries + */ + +code *REGSAVE::save(code *c, int reg, unsigned *pidx) +{ + unsigned i; + if (reg >= XMM0) + { + alignment = 16; + idx = (idx + 15) & ~15; + i = idx; + idx += 16; + // MOVD idx[RBP],xmm + c = genc1(c,0xF20F11,modregxrm(2, reg - XMM0, BPRM),FLregsave,(targ_uns) i); + } + else + { + if (!alignment) + alignment = REGSIZE; + i = idx; + idx += REGSIZE; + // MOV idx[RBP],reg + c = genc1(c,0x89,modregxrm(2, reg, BPRM),FLregsave,(targ_uns) i); + if (I64) + code_orrex(c, REX_W); + } + reflocal = TRUE; + if (idx > top) + top = idx; // keep high water mark + *pidx = i; + return c; +} + +code *REGSAVE::restore(code *c, int reg, unsigned idx) +{ + if (reg >= XMM0) + { + assert(alignment == 16); + // MOVD xmm,idx[RBP] + c = genc1(c,0xF20F10,modregxrm(2, reg - XMM0, BPRM),FLregsave,(targ_uns) idx); + } + else + { // MOV reg,idx[RBP] + c = genc1(c,0x8B,modregxrm(2, reg, BPRM),FLregsave,(targ_uns) idx); + if (I64) + code_orrex(c, REX_W); + } + return c; +} + +/************************************ + * Size for vex encoded instruction. + */ + +unsigned char vex_inssize(code *c) +{ + assert(c->Iflags & CFvex); + unsigned char ins; + if (c->Iflags & CFvex3) + { + switch (c->Ivex.mmmm) + { + case 0: // no prefix + case 1: // 0F + ins = inssize2[c->Ivex.op] + 2; + break; + case 2: // 0F 38 + ins = inssize2[0x38] + 1; + break; + case 3: // 0F 3A + ins = inssize2[0x3A] + 1; + break; + default: + assert(0); + } + } + else + { + ins = inssize2[c->Ivex.op] + 1; + } + return ins; +} + +/************************************ + * Determine if there is a modregrm byte for code. + */ + +int cod3_EA(code *c) +{ unsigned ins; + + unsigned op1 = c->Iop & 0xFF; + if (op1 == ESCAPE) + ins = 0; + else if ((c->Iop & 0xFFFD00) == 0x0F3800) + ins = inssize2[(c->Iop >> 8) & 0xFF]; + else if ((c->Iop & 0xFF00) == 0x0F00) + ins = inssize2[op1]; + else + ins = inssize[op1]; + return ins & M; +} + +/******************************** + * Fix global variables for 386. + */ + +void cod3_set32() +{ + inssize[0xA0] = T|5; + inssize[0xA1] = T|5; + inssize[0xA2] = T|5; + inssize[0xA3] = T|5; + BPRM = 5; /* [EBP] addressing mode */ + fregsaved = mBP | mBX | mSI | mDI; // saved across function calls + FLOATREGS = FLOATREGS_32; + FLOATREGS2 = FLOATREGS2_32; + DOUBLEREGS = DOUBLEREGS_32; + if (config.flags3 & CFG3eseqds) + fregsaved |= mES; + + for (unsigned i = 0x80; i < 0x90; i++) + inssize2[i] = W|T|6; +} + +/******************************** + * Fix global variables for I64. + */ + +void cod3_set64() +{ + inssize[0xA0] = T|5; // MOV AL,mem + inssize[0xA1] = T|5; // MOV RAX,mem + inssize[0xA2] = T|5; // MOV mem,AL + inssize[0xA3] = T|5; // MOV mem,RAX + BPRM = 5; // [RBP] addressing mode + + fregsaved = mBP | mBX | mR12 | mR13 | mR14 | mR15 | mES; // saved across function calls + FLOATREGS = FLOATREGS_64; + FLOATREGS2 = FLOATREGS2_64; + DOUBLEREGS = DOUBLEREGS_64; + STACKALIGN = 16; + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + ALLREGS = mAX|mBX|mCX|mDX|mSI|mDI| mR8|mR9|mR10|mR11|mR12|mR13|mR14|mR15; + BYTEREGS = ALLREGS; +#endif + + for (unsigned i = 0x80; i < 0x90; i++) + inssize2[i] = W|T|6; +} + +/********************************* + * Word or dword align start of function. + */ + +void cod3_align() +{ + static unsigned char nops[7] = { 0x90,0x90,0x90,0x90,0x90,0x90,0x90 }; + unsigned nbytes; +#if OMFOBJ + if (config.flags4 & CFG4speed) // if optimized for speed + { + // Pick alignment based on CPU target + if (config.target_cpu == TARGET_80486 || + config.target_cpu >= TARGET_PentiumPro) + { // 486 does reads on 16 byte boundaries, so if we are near + // such a boundary, align us to it + + nbytes = -Coffset & 15; + if (nbytes < 8) + { + Coffset += obj_bytes(cseg,Coffset,nbytes,nops); // XCHG AX,AX + } + } + } +#else + nbytes = -Coffset & 3; + //dbg_printf("cod3_align Coffset %x nbytes %d\n",Coffset,nbytes); + obj_bytes(cseg,Coffset,nbytes,nops); +#endif +} + +/***************************** + * Given a type, return a mask of + * registers to hold that type. + * Input: + * tyf function type + */ + +regm_t regmask(tym_t tym, tym_t tyf) +{ + switch (tybasic(tym)) + { + case TYvoid: + case TYstruct: + return 0; + case TYbool: + case TYwchar_t: + case TYchar16: + case TYchar: + case TYschar: + case TYuchar: + case TYshort: + case TYushort: + case TYint: + case TYuint: +#if JHANDLE + case TYjhandle: +#endif + case TYnullptr: + case TYnptr: +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + return mAX; + + case TYfloat: + case TYifloat: + if (I64) + return mXMM0; + if (config.exe & EX_flat) + return mST0; + case TYlong: + case TYulong: + case TYdchar: + if (!I16) + return mAX; +#if TARGET_SEGMENTED + case TYfptr: + case TYhptr: +#endif + return mDX | mAX; + + case TYcent: + case TYucent: + assert(I64); + return mDX | mAX; + +#if TARGET_SEGMENTED + case TYvptr: + return mDX | mBX; +#endif + + case TYdouble: + case TYdouble_alias: + case TYidouble: + if (I64) + return mXMM0; + if (config.exe & EX_flat) + return mST0; + return DOUBLEREGS; + + case TYllong: + case TYullong: + return I64 ? mAX : (I32 ? mDX | mAX : DOUBLEREGS); + + case TYldouble: + case TYildouble: + return mST0; + + case TYcfloat: +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (I32 && tybasic(tyf) == TYnfunc) + return mDX | mAX; +#endif + case TYcdouble: + if (I64) + return mXMM0 | mXMM1; + case TYcldouble: + return mST01; + + // SIMD vector types + case TYfloat4: + case TYdouble2: + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: + if (!config.fpxmmregs) + { printf("SIMD operations not supported on this platform\n"); + exit(1); + } + return mXMM0; + + default: +#if DEBUG + WRTYxx(tym); +#endif + assert(0); + return 0; + } +} + +/******************************* + * Generate block exit code + */ +void outblkexitcode(block *bl, code*& c, int& anyspill, const char* sflsave, symbol** retsym, const regm_t mfuncregsave) +{ + elem *e = bl->Belem; + block *nextb; + block *bs1,*bs2; + regm_t retregs = 0; + bool jcond; + + switch (bl->BC) /* block exit condition */ + { + case BCiftrue: + jcond = TRUE; + bs1 = list_block(bl->Bsucc); + bs2 = list_block(list_next(bl->Bsucc)); + if (bs1 == bl->Bnext) + { // Swap bs1 and bs2 + block *btmp; + + jcond ^= 1; + btmp = bs1; + bs1 = bs2; + bs2 = btmp; + } + c = cat(c,logexp(e,jcond,FLblock,(code *) bs1)); + nextb = bs2; + bl->Bcode = NULL; + L2: + if (nextb != bl->Bnext) + { if (configv.addlinenumbers && bl->Bsrcpos.Slinnum && + !(funcsym_p->ty() & mTYnaked)) + cgen_linnum(&c,bl->Bsrcpos); + assert(!(bl->Bflags & BFLepilog)); + c = cat(c,genjmp(CNIL,JMP,FLblock,nextb)); + } + bl->Bcode = cat(bl->Bcode,c); + break; + case BCjmptab: + case BCifthen: + case BCswitch: + assert(!(bl->Bflags & BFLepilog)); + doswitch(bl); /* hide messy details */ + bl->Bcode = cat(c,bl->Bcode); + break; +#if MARS + case BCjcatch: + // Mark all registers as destroyed. This will prevent + // register assignments to variables used in catch blocks. + c = cat(c,getregs((I32 | I64) ? allregs : (ALLREGS | mES))); +#if 0 && TARGET_LINUX + if (config.flags3 & CFG3pic && !(allregs & mBX)) + { + c = cat(c, cod3_load_got()); + } +#endif + goto case_goto; +#endif +#if SCPP + case BCcatch: + // Mark all registers as destroyed. This will prevent + // register assignments to variables used in catch blocks. + c = cat(c,getregs(allregs | mES)); +#if 0 && TARGET_LINUX + if (config.flags3 & CFG3pic && !(allregs & mBX)) + { + c = cat(c, cod3_load_got()); + } +#endif + goto case_goto; + + case BCtry: + usednteh |= EHtry; + if (config.flags2 & CFG2seh) + usednteh |= NTEHtry; + goto case_goto; +#endif + case BCgoto: + nextb = list_block(bl->Bsucc); + if ((funcsym_p->Sfunc->Fflags3 & Fnteh || + (MARS /*&& config.flags2 & CFG2seh*/)) && + bl->Btry != nextb->Btry && + nextb->BC != BC_finally) + { int toindex; + int fromindex; + + bl->Bcode = NULL; + c = gencodelem(c,e,&retregs,TRUE); + toindex = nextb->Btry ? nextb->Btry->Bscope_index : -1; + assert(bl->Btry); + fromindex = bl->Btry->Bscope_index; +#if MARS + if (toindex + 1 == fromindex) + { // Simply call __finally + if (bl->Btry && + list_block(list_next(bl->Btry->Bsucc))->BC == BCjcatch) + { + goto L2; + } + } +#endif + if (config.flags2 & CFG2seh) + c = cat(c,nteh_unwind(0,toindex)); +#if MARS && (TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS) + else if (toindex + 1 <= fromindex) + { + //c = cat(c, linux_unwind(0, toindex)); + block *bt; + + //printf("B%d: fromindex = %d, toindex = %d\n", bl->Bdfoidx, fromindex, toindex); + bt = bl; + while ((bt = bt->Btry) != NULL && bt->Bscope_index != toindex) + { block *bf; + + //printf("\tbt->Bscope_index = %d, bt->Blast_index = %d\n", bt->Bscope_index, bt->Blast_index); + bf = list_block(list_next(bt->Bsucc)); + // Only look at try-finally blocks + if (bf->BC == BCjcatch) + continue; + + if (bf == nextb) + continue; + //printf("\tbf = B%d, nextb = B%d\n", bf->Bdfoidx, nextb->Bdfoidx); + if (nextb->BC == BCgoto && + !nextb->Belem && + bf == list_block(nextb->Bsucc)) + continue; + + // call __finally + code *cs; + code *cr; + int nalign = 0; + + gensaverestore(retregs,&cs,&cr); + if (STACKALIGN == 16) + { int npush = (numbitsset(retregs) + 1) * REGSIZE; + if (npush & (STACKALIGN - 1)) + { nalign = STACKALIGN - (npush & (STACKALIGN - 1)); + cs = genc2(cs,0x81,modregrm(3,5,SP),nalign); // SUB ESP,nalign + if (I64) + code_orrex(cs, REX_W); + } + } + cs = genc(cs,0xE8,0,0,0,FLblock,(long)list_block(bf->Bsucc)); + if (nalign) + { cs = genc2(cs,0x81,modregrm(3,0,SP),nalign); // ADD ESP,nalign + if (I64) + code_orrex(cs, REX_W); + } + c = cat3(c,cs,cr); + } + } +#endif + goto L2; + } + case_goto: + c = gencodelem(c,e,&retregs,TRUE); + if (anyspill) + { // Add in the epilog code + code *cstore = NULL; + code *cload = NULL; + + for (int i = 0; i < anyspill; i++) + { symbol *s = globsym.tab[i]; + + if (s->Sflags & SFLspill && + vec_testbit(dfoidx,s->Srange)) + { + s->Sfl = sflsave[i]; // undo block register assignments + cgreg_spillreg_epilog(bl,s,&cstore,&cload); + } + } + c = cat3(c,cstore,cload); + } + + L3: + bl->Bcode = NULL; + nextb = list_block(bl->Bsucc); + goto L2; + + case BC_try: + if (config.flags2 & CFG2seh) + { usednteh |= NTEH_try; + nteh_usevars(); + } + else + usednteh |= EHtry; + goto case_goto; + + case BC_finally: + // Mark all registers as destroyed. This will prevent + // register assignments to variables used in finally blocks. + assert(!getregs(allregs)); + assert(!e); + assert(!bl->Bcode); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic) + { + int nalign = 0; + if (STACKALIGN == 16) + { nalign = STACKALIGN - REGSIZE; + c = genc2(c,0x81,modregrm(3,5,SP),nalign); // SUB ESP,nalign + if (I64) + code_orrex(c, REX_W); + } + // CALL bl->Bsucc + c = genc(c,0xE8,0,0,0,FLblock,(long)list_block(bl->Bsucc)); + if (nalign) + { c = genc2(c,0x81,modregrm(3,0,SP),nalign); // ADD ESP,nalign + if (I64) + code_orrex(c, REX_W); + } + // JMP list_next(bl->Bsucc) + nextb = list_block(list_next(bl->Bsucc)); + goto L2; + } + else +#endif + { + // Generate a PUSH of the address of the successor to the + // corresponding BC_ret + //assert(list_block(list_next(bl->Bsucc))->BC == BC_ret); + // PUSH &succ + c = genc(c,0x68,0,0,0,FLblock,(long)list_block(list_next(bl->Bsucc))); + nextb = list_block(bl->Bsucc); + goto L2; + } + + case BC_ret: + c = gencodelem(c,e,&retregs,TRUE); + bl->Bcode = gen1(c,0xC3); // RET + break; + +#if NTEXCEPTIONS + case BC_except: + assert(!e); + usednteh |= NTEH_except; + c = cat(c,nteh_setsp(0x8B)); + getregs(allregs); + goto L3; + + case BC_filter: + c = cat(c,nteh_filter(bl)); + // Mark all registers as destroyed. This will prevent + // register assignments to variables used in filter blocks. + getregs(allregs); + retregs = regmask(e->Ety, TYnfunc); + c = gencodelem(c,e,&retregs,TRUE); + bl->Bcode = gen1(c,0xC3); // RET + break; +#endif + + case BCretexp: + retregs = regmask(e->Ety, funcsym_p->ty()); + + // For the final load into the return regs, don't set regcon.used, + // so that the optimizer can potentially use retregs for register + // variable assignments. + + if (config.flags4 & CFG4optimized) + { regm_t usedsave; + + c = cat(c,docommas(&e)); + usedsave = regcon.used; + if (EOP(e)) + c = gencodelem(c,e,&retregs,TRUE); + else + { + if (e->Eoper == OPconst) + regcon.mvar = 0; + c = gencodelem(c,e,&retregs,TRUE); + regcon.used = usedsave; + if (e->Eoper == OPvar) + { symbol *s = e->EV.sp.Vsym; + + if (s->Sfl == FLreg && s->Sregm != mAX) + *retsym = s; + } + } + } + else + { + case BCret: + case BCexit: + c = gencodelem(c,e,&retregs,TRUE); + } + bl->Bcode = c; + if (retregs == mST0) + { assert(stackused == 1); + pop87(); // account for return value + } + else if (retregs == mST01) + { assert(stackused == 2); + pop87(); + pop87(); // account for return value + } + if (bl->BC == BCexit && config.flags4 & CFG4optimized) + mfuncreg = mfuncregsave; + if (MARS || usednteh & NTEH_try) + { block *bt; + + bt = bl; + while ((bt = bt->Btry) != NULL) + { block *bf; + + bf = list_block(list_next(bt->Bsucc)); +#if MARS + // Only look at try-finally blocks + if (bf->BC == BCjcatch) + { + continue; + } +#endif + if (config.flags2 & CFG2seh) + { + if (bt->Bscope_index == 0) + { + // call __finally + code *cs; + code *cr; + + c = cat(c,nteh_gensindex(-1)); + gensaverestore(retregs,&cs,&cr); + cs = genc(cs,0xE8,0,0,0,FLblock,(long)list_block(bf->Bsucc)); + bl->Bcode = cat3(c,cs,cr); + } + else + bl->Bcode = cat(c,nteh_unwind(retregs,~0)); + break; + } + else + { + // call __finally + code *cs; + code *cr; + int nalign = 0; + + gensaverestore(retregs,&cs,&cr); + if (STACKALIGN == 16) + { int npush = (numbitsset(retregs) + 1) * REGSIZE; + if (npush & (STACKALIGN - 1)) + { nalign = STACKALIGN - (npush & (STACKALIGN - 1)); + cs = genc2(cs,0x81,modregrm(3,5,SP),nalign); // SUB ESP,nalign + if (I64) + code_orrex(cs, REX_W); + } + } + // CALL bf->Bsucc + cs = genc(cs,0xE8,0,0,0,FLblock,(long)list_block(bf->Bsucc)); + if (nalign) + { cs = genc2(cs,0x81,modregrm(3,0,SP),nalign); // ADD ESP,nalign + if (I64) + code_orrex(cs, REX_W); + } + bl->Bcode = c = cat3(c,cs,cr); + } + } + } + break; + +#if SCPP || MARS + case BCasm: + assert(!e); + // Mark destroyed registers + assert(!c); + c = cat(c,getregs(iasm_regs(bl))); + if (bl->Bsucc) + { nextb = list_block(bl->Bsucc); + if (!bl->Bnext) + goto L2; + if (nextb != bl->Bnext && + bl->Bnext && + !(bl->Bnext->BC == BCgoto && + !bl->Bnext->Belem && + nextb == list_block(bl->Bnext->Bsucc))) + { code *cl; + + // See if already have JMP at end of block + cl = code_last(bl->Bcode); + if (!cl || cl->Iop != JMP) + goto L2; // add JMP at end of block + } + } + break; +#endif + default: +#ifdef DEBUG + printf("bl->BC = %d\n",bl->BC); +#endif + assert(0); + } +} + +/******************************* + * Generate code for blocks ending in a switch statement. + * Take BCswitch and decide on + * BCifthen use if - then code + * BCjmptab index into jump table + * BCswitch search table for match + */ + +void doswitch(block *b) +{ code *cc,*c,*ce; + regm_t retregs; + unsigned ncases,n,reg,reg2,rm; + targ_llong vmax,vmin,val; + targ_llong *p; + list_t bl; + elem *e; + + tym_t tys; + int sz; + unsigned char dword; + unsigned char mswsame; +#if LONGLONG + targ_ulong msw; +#else + unsigned msw; +#endif + + e = b->Belem; + elem_debug(e); + cc = docommas(&e); + cgstate.stackclean++; + tys = tybasic(e->Ety); + sz = tysize[tys]; + dword = (sz == 2 * REGSIZE); + mswsame = 1; // assume all msw's are the same + p = b->BS.Bswitch; /* pointer to case data */ + assert(p); + ncases = *p++; /* number of cases */ + + vmax = MINLL; // smallest possible llong + vmin = MAXLL; // largest possible llong + for (n = 0; n < ncases; n++) // find max and min case values + { val = *p++; + if (val > vmax) vmax = val; + if (val < vmin) vmin = val; + if (REGSIZE == 2) + { + unsigned short ms = (val >> 16) & 0xFFFF; + if (n == 0) + msw = ms; + else if (msw != ms) + mswsame = 0; + } + else // REGSIZE == 4 + { + targ_ulong ms = (val >> 32) & 0xFFFFFFFF; + if (n == 0) + msw = ms; + else if (msw != ms) + mswsame = 0; + } + } + p -= ncases; + //dbg_printf("vmax = x%lx, vmin = x%lx, vmax-vmin = x%lx\n",vmax,vmin,vmax - vmin); + + if (I64) + { // For now, just generate basic if-then sequence to get us running + retregs = ALLREGS; + b->BC = BCifthen; + c = scodelem(e,&retregs,0,TRUE); + assert(!dword); // 128 bit switches not supported + reg = findreg(retregs); // reg that result is in + bl = b->Bsucc; + for (n = 0; n < ncases; n++) + { code *cx; + val = *p; + if (sz == 4) + cx = genc2(CNIL,0x81,modregrmx(3,7,reg),val); // CMP reg,val + else if (sz == 8) + { + if (val == (int)val) // if val is a 64 bit value sign-extended from 32 bits + { + cx = genc2(CNIL,0x81,modregrmx(3,7,reg),val); // CMP reg,value32 + cx->Irex |= REX_W; // 64 bit operand + } + else + { unsigned sreg; + // MOV sreg,value64 + cx = regwithvalue(CNIL, ALLREGS & ~mask[reg], val, &sreg, 64); + cx = genregs(cx,0x3B,reg,sreg); // CMP reg,sreg + code_orrex(cx, REX_W); + } + } + else + assert(0); + bl = list_next(bl); + genjmp(cx,JE,FLblock,list_block(bl)); // JE caseaddr + c = cat(c,cx); + p++; + } + if (list_block(b->Bsucc) != b->Bnext) /* if default is not next block */ + c = cat(c,genjmp(CNIL,JMP,FLblock,list_block(b->Bsucc))); + ce = NULL; + } + // Need to do research on MACHOBJ to see about better methods + else if (MACHOBJ || ncases <= 3) + { // generate if-then sequence + retregs = ALLREGS; + L1: + b->BC = BCifthen; + c = scodelem(e,&retregs,0,TRUE); + if (dword) + { reg = findreglsw(retregs); + reg2 = findregmsw(retregs); + } + else + reg = findreg(retregs); /* reg that result is in */ + bl = b->Bsucc; + if (dword && mswsame) + { /* CMP reg2,MSW */ + c = genc2(c,0x81,modregrm(3,7,reg2),msw); + genjmp(c,JNE,FLblock,list_block(b->Bsucc)); /* JNE default */ + } + for (n = 0; n < ncases; n++) + { code *cnext = CNIL; + /* CMP reg,casevalue */ + c = cat(c,ce = genc2(CNIL,0x81,modregrm(3,7,reg),(targ_int)*p)); + if (dword && !mswsame) + { + cnext = gennop(CNIL); + genjmp(ce,JNE,FLcode,(block *) cnext); + genc2(ce,0x81,modregrm(3,7,reg2),MSREG(*p)); + } + bl = list_next(bl); + /* JE caseaddr */ + genjmp(ce,JE,FLblock,list_block(bl)); + c = cat(c,cnext); + p++; + } + if (list_block(b->Bsucc) != b->Bnext) /* if default is not next block */ + c = cat(c,genjmp(CNIL,JMP,FLblock,list_block(b->Bsucc))); + ce = NULL; + } +#if TARGET_WINDOS // try and find relocation to support this + else if ((targ_ullong)(vmax - vmin) <= ncases * 2) // then use jump table + { int modify; + + b->BC = BCjmptab; + retregs = IDXREGS; + if (dword) + retregs |= mMSW; + modify = (vmin || !I32); + c = scodelem(e,&retregs,0,!modify); + reg = findreg(retregs & IDXREGS); /* reg that result is in */ + if (dword) + reg2 = findregmsw(retregs); + if (modify) + { + assert(!(retregs & regcon.mvar)); + c = cat(c,getregs(retregs)); + } + if (vmin) /* if there is a minimum */ + { + c = genc2(c,0x81,modregrm(3,5,reg),vmin); /* SUB reg,vmin */ + if (dword) + { genc2(c,0x81,modregrm(3,3,reg2),MSREG(vmin)); // SBB reg2,vmin + genjmp(c,JNE,FLblock,list_block(b->Bsucc)); /* JNE default */ + } + } + else if (dword) + { c = gentstreg(c,reg2); // TEST reg2,reg2 + genjmp(c,JNE,FLblock,list_block(b->Bsucc)); /* JNE default */ + } + if (vmax - vmin != REGMASK) /* if there is a maximum */ + { /* CMP reg,vmax-vmin */ + c = genc2(c,0x81,modregrm(3,7,reg),vmax-vmin); + genjmp(c,JA,FLblock,list_block(b->Bsucc)); /* JA default */ + } + if (!I32) + c = gen2(c,0xD1,modregrm(3,4,reg)); /* SHL reg,1 */ + if (I32) + { + ce = genc1(CNIL,0xFF,modregrm(0,4,4),FLswitch,0); /* JMP [CS:]disp[idxreg*4] */ + ce->Isib = modregrm(2,reg,5); + } + else + { rm = getaddrmode(retregs) | modregrm(0,4,0); + ce = genc1(CNIL,0xFF,rm,FLswitch,0); /* JMP [CS:]disp[idxreg] */ + } + int flags = (config.flags & CFGromable) ? CFcs : 0; // table is in code seg + ce->Iflags |= flags; // segment override + ce->IEV1.Vswitch = b; + b->Btablesize = (int) (vmax - vmin + 1) * tysize[TYnptr]; + } +#endif + else /* else use switch table (BCswitch) */ + { targ_size_t disp; + int mod; + code *esw; + code *ct; + + retregs = mAX; /* SCASW requires AX */ + if (dword) + retregs |= mDX; + else if (ncases <= 6 || config.flags4 & CFG4speed) + goto L1; + c = scodelem(e,&retregs,0,TRUE); + if (dword && mswsame) + { /* CMP DX,MSW */ + c = genc2(c,0x81,modregrm(3,7,DX),msw); + genjmp(c,JNE,FLblock,list_block(b->Bsucc)); /* JNE default */ + } + ce = getregs(mCX|mDI); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic) + { // Add in GOT + code *cx; + code *cgot; + + ce = cat(ce, getregs(mDX)); + cx = genc2(NULL,CALL,0,0); // CALL L1 + gen1(cx, 0x58 + DI); // L1: POP EDI + + // ADD EDI,_GLOBAL_OFFSET_TABLE_+3 + symbol *gotsym = elfobj_getGOTsym(); + cgot = gencs(CNIL,0x81,modregrm(3,0,DI),FLextern,gotsym); + cgot->Iflags = CFoff; + cgot->IEVoffset2 = 3; + + makeitextern(gotsym); + + genmovreg(cgot, DX, DI); // MOV EDX, EDI + // ADD EDI,offset of switch table + esw = gencs(CNIL,0x81,modregrm(3,0,DI),FLswitch,NULL); + esw->IEV2.Vswitch = b; + esw = cat3(cx, cgot, esw); + } + else +#endif + { + // MOV DI,offset of switch table + esw = gencs(CNIL,0xC7,modregrm(3,0,DI),FLswitch,NULL); + esw->IEV2.Vswitch = b; + } + ce = cat(ce,esw); + movregconst(ce,CX,ncases,0); /* MOV CX,ncases */ + + /* The switch table will be accessed through ES:DI. + * Therefore, load ES with proper segment value. + */ + if (config.flags3 & CFG3eseqds) + { assert(!(config.flags & CFGromable)); + ce = cat(ce,getregs(mCX)); // allocate CX + } + else + { + ce = cat(ce,getregs(mES|mCX)); // allocate ES and CX + gen1(ce,(config.flags & CFGromable) ? 0x0E : 0x1E); // PUSH CS/DS + gen1(ce,0x07); // POP ES + } + + disp = (ncases - 1) * intsize; /* displacement to jump table */ + if (dword && !mswsame) + { code *cloop; + + /* Build the following: + L1: SCASW + JNE L2 + CMP DX,[CS:]disp[DI] + L2: LOOPNE L1 + */ + + mod = (disp > 127) ? 2 : 1; /* displacement size */ + cloop = genc2(CNIL,0xE0,0,-7 - mod - + ((config.flags & CFGromable) ? 1 : 0)); /* LOOPNE scasw */ + ce = gen1(ce,0xAF); /* SCASW */ + code_orflag(ce,CFtarg2); // target of jump + genjmp(ce,JNE,FLcode,(block *) cloop); /* JNE loop */ + /* CMP DX,[CS:]disp[DI] */ + ct = genc1(CNIL,0x39,modregrm(mod,DX,5),FLconst,disp); + int flags = (config.flags & CFGromable) ? CFcs : 0; // table is in code seg + ct->Iflags |= flags; // possible seg override + ce = cat3(ce,ct,cloop); + disp += ncases * intsize; /* skip over msw table */ + } + else + { + ce = gen1(ce,0xF2); /* REPNE */ + gen1(ce,0xAF); /* SCASW */ + } + genjmp(ce,JNE,FLblock,list_block(b->Bsucc)); /* JNE default */ + mod = (disp > 127) ? 2 : 1; /* 1 or 2 byte displacement */ + if (config.flags & CFGromable) + gen1(ce,SEGCS); /* table is in code segment */ +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic) + { // ADD EDX,(ncases-1)*2[EDI] + ct = genc1(CNIL,0x03,modregrm(mod,DX,7),FLconst,disp); + // JMP EDX + gen2(ct,0xFF,modregrm(3,4,DX)); + } + else +#endif + { // JMP (ncases-1)*2[DI] + ct = genc1(CNIL,0xFF,modregrm(mod,4,(I32 ? 7 : 5)),FLconst,disp); + int flags = (config.flags & CFGromable) ? CFcs : 0; // table is in code seg + ct->Iflags |= flags; + } + ce = cat(ce,ct); + b->Btablesize = disp + intsize + ncases * tysize[TYnptr]; + } + b->Bcode = cat3(cc,c,ce); + //assert(b->Bcode); + cgstate.stackclean--; +} + +/****************************** + * Output data block for a jump table (BCjmptab). + * The 'holes' in the table get filled with the + * default label. + */ + +void outjmptab(block *b) +{ + unsigned ncases,n; + targ_llong u,vmin,vmax,val,*p; + targ_size_t alignbytes,def,targ,*poffset; + int jmpseg; + + poffset = (config.flags & CFGromable) ? &Coffset : &JMPOFF; + p = b->BS.Bswitch; /* pointer to case data */ + ncases = *p++; /* number of cases */ + vmax = MINLL; // smallest possible llong + vmin = MAXLL; // largest possible llong + for (n = 0; n < ncases; n++) /* find min case value */ + { val = p[n]; + if (val > vmax) vmax = val; + if (val < vmin) vmin = val; + } + jmpseg = (config.flags & CFGromable) ? cseg : JMPSEG; + + /* Any alignment bytes necessary */ + alignbytes = align(0,*poffset) - *poffset; + obj_lidata(jmpseg,*poffset,alignbytes); + + def = list_block(b->Bsucc)->Boffset; /* default address */ + assert(vmin <= vmax); + for (u = vmin; ; u++) + { targ = def; /* default */ + for (n = 0; n < ncases; n++) + { if (p[n] == u) + { targ = list_block(list_nth(b->Bsucc,n + 1))->Boffset; + break; + } + } + reftocodseg(jmpseg,*poffset,targ); + *poffset += tysize[TYnptr]; + if (u == vmax) /* for case that (vmax == ~0) */ + break; + } +} + +/****************************** + * Output data block for a switch table. + * Two consecutive tables, the first is the case value table, the + * second is the address table. + */ + +void outswitab(block *b) +{ unsigned ncases,n; + targ_llong *p; + targ_size_t val; + targ_size_t alignbytes,*poffset; + int seg; /* target segment for table */ + list_t bl; + unsigned sz; + targ_size_t offset; + + //printf("outswitab()\n"); + p = b->BS.Bswitch; /* pointer to case data */ + ncases = *p++; /* number of cases */ + + if (config.flags & CFGromable) + { poffset = &Coffset; + assert(cseg == CODE); + seg = cseg; + } + else + { + poffset = &JMPOFF; + seg = JMPSEG; + } + offset = *poffset; + alignbytes = align(0,*poffset) - *poffset; + obj_lidata(seg,*poffset,alignbytes); /* any alignment bytes necessary */ + assert(*poffset == offset + alignbytes); + + sz = intsize; + for (n = 0; n < ncases; n++) /* send out value table */ + { + //printf("\tcase %d, offset = x%x\n", n, *poffset); +#if OMFOBJ + *poffset += +#endif + obj_bytes(seg,*poffset,sz,p); + p++; + } + offset += alignbytes + sz * ncases; + assert(*poffset == offset); + + if (b->Btablesize == ncases * (REGSIZE * 2 + tysize[TYnptr])) + { + /* Send out MSW table */ + p -= ncases; + for (n = 0; n < ncases; n++) + { val = MSREG(*p); + p++; +#if OMFOBJ + *poffset += +#endif + obj_bytes(seg,*poffset,REGSIZE,&val); + } + offset += REGSIZE * ncases; + assert(*poffset == offset); + } + + bl = b->Bsucc; + for (n = 0; n < ncases; n++) /* send out address table */ + { bl = list_next(bl); + reftocodseg(seg,*poffset,list_block(bl)->Boffset); + *poffset += tysize[TYnptr]; + } + assert(*poffset == offset + ncases * tysize[TYnptr]); +} + +/***************************** + * Return a jump opcode relevant to the elem for a JMP TRUE. + */ + +int jmpopcode(elem *e) +{ tym_t tym; + int zero,i,jp,op; + static const char jops[][2][6] = + { /* <= > < >= == != <=0 >0 <0 >=0 ==0 !=0 */ + { {JLE,JG ,JL ,JGE,JE ,JNE},{JLE,JG ,JS ,JNS,JE ,JNE} }, /* signed */ + { {JBE,JA ,JB ,JAE,JE ,JNE},{JE ,JNE,JB ,JAE,JE ,JNE} }, /* unsigned */ +#if 0 + { {JLE,JG ,JL ,JGE,JE ,JNE},{JLE,JG ,JL ,JGE,JE ,JNE} }, /* real */ + { {JBE,JA ,JB ,JAE,JE ,JNE},{JBE,JA ,JB ,JAE,JE ,JNE} }, /* 8087 */ + { {JA ,JBE,JAE,JB ,JE ,JNE},{JBE,JA ,JB ,JAE,JE ,JNE} }, /* 8087 R */ +#endif + }; + +#define XP (JP << 8) +#define XNP (JNP << 8) + static const unsigned jfops[1][26] = + /* le gt lt ge eqeq ne unord lg leg ule ul uge */ + { + { XNP|JBE,JA,XNP|JB,JAE,XNP|JE, XP|JNE,JP, JNE,JNP, JBE,JC,XP|JAE, + + /* ug ue ngt nge nlt nle ord nlg nleg nule nul nuge nug nue */ + XP|JA,JE,JBE,JB, XP|JAE,XP|JA, JNP,JE, JP, JA, JNC,XNP|JB, XNP|JBE,JNE }, /* 8087 */ + }; + + assert(e); + while (e->Eoper == OPcomma || + /* The !EOP(e->E1) is to line up with the case in cdeq() where */ + /* we decide if mPSW is passed on when evaluating E2 or not. */ + (e->Eoper == OPeq && !EOP(e->E1))) + e = e->E2; /* right operand determines it */ + + op = e->Eoper; + if (e->Ecount != e->Ecomsub) // comsubs just get Z bit set + return JNE; + if (!OTrel(op)) // not relational operator + { + tym_t tymx = tybasic(e->Ety); + if (tyfloating(tymx) && config.inline8087 && + (tymx == TYldouble || tymx == TYildouble || tymx == TYcldouble || + tymx == TYcdouble || tymx == TYcfloat || + op == OPind)) + { + return XP|JNE; + } + return (op >= OPbt && op <= OPbts) ? JC : JNE; + } + + if (e->E2->Eoper == OPconst) + zero = !boolres(e->E2); + else + zero = 0; + + tym = e->E1->Ety; + if (tyfloating(tym)) +#if 1 + { i = 0; + if (config.inline8087) + { i = 1; + +#if 1 +#define NOSAHF (I64 || config.fpxmmregs) + if (rel_exception(op) || config.flags4 & CFG4fastfloat) + { + if (zero) + { + if (NOSAHF) + op = swaprel(op); + } + else if (NOSAHF) + op = swaprel(op); + else if (cmporder87(e->E2)) + op = swaprel(op); + else + ; + } + else + { + if (zero && config.target_cpu < TARGET_80386) + ; + else + op = swaprel(op); + } +#else + if (zero && !rel_exception(op) && config.target_cpu >= TARGET_80386) + op = swaprel(op); + else if (!zero && + (cmporder87(e->E2) || !(rel_exception(op) || config.flags4 & CFG4fastfloat))) + /* compare is reversed */ + op = swaprel(op); +#endif + } + jp = jfops[0][op - OPle]; + goto L1; + } +#else + i = (config.inline8087) ? (3 + cmporder87(e->E2)) : 2; +#endif + else if (tyuns(tym) || tyuns(e->E2->Ety)) + i = 1; + else if (tyintegral(tym) || typtr(tym)) + i = 0; + else + { +#if DEBUG + elem_print(e); + WRTYxx(tym); +#endif + assert(0); + } + + jp = jops[i][zero][op - OPle]; /* table starts with OPle */ +L1: +#if DEBUG + if ((jp & 0xF0) != 0x70) + WROP(op), + printf("i %d zero %d op x%x jp x%x\n",i,zero,op,jp); +#endif + assert((jp & 0xF0) == 0x70); + return jp; +} + +/********************************** + * Append code to *pc which validates pointer described by + * addressing mode in *pcs. Modify addressing mode in *pcs. + * Input: + * keepmsk mask of registers we must not destroy or use + * if (keepmsk & RMstore), this will be only a store operation + * into the lvalue + */ + +void cod3_ptrchk(code **pc,code *pcs,regm_t keepmsk) +{ code *c; + code *cs2; + unsigned char rm,sib; + unsigned reg; + unsigned flagsave; + unsigned opsave; + regm_t idxregs; + regm_t tosave; + regm_t used; + int i; + + assert(!I64); + if (!I16 && pcs->Iflags & (CFes | CFss | CFcs | CFds | CFfs | CFgs)) + return; // not designed to deal with 48 bit far pointers + + c = *pc; + + rm = pcs->Irm; + assert(!(rm & 0x40)); // no disp8 or reg addressing modes + + // If the addressing mode is already a register + reg = rm & 7; + if (I16) + { static const unsigned char imode[8] = { BP,BP,BP,BP,SI,DI,BP,BX }; + + reg = imode[reg]; // convert [SI] to SI, etc. + } + idxregs = mask[reg]; + if ((rm & 0x80 && (pcs->IFL1 != FLoffset || pcs->IEV1.Vuns)) || + !(idxregs & ALLREGS) + ) + { + // Load the offset into a register, so we can push the address + idxregs = (I16 ? IDXREGS : ALLREGS) & ~keepmsk; // only these can be index regs + assert(idxregs); + c = cat(c,allocreg(&idxregs,®,TYoffset)); + + opsave = pcs->Iop; + flagsave = pcs->Iflags; + pcs->Iop = 0x8D; + pcs->Irm |= modregrm(0,reg,0); + pcs->Iflags &= ~(CFopsize | CFss | CFes | CFcs); // no prefix bytes needed + c = gen(c,pcs); // LEA reg,EA + + pcs->Iflags = flagsave; + pcs->Iop = opsave; + } + + // registers destroyed by the function call + //used = (mBP | ALLREGS | mES) & ~fregsaved; + used = 0; // much less code generated this way + + cs2 = CNIL; + tosave = used & (keepmsk | idxregs); + for (i = 0; tosave; i++) + { regm_t mi = mask[i]; + + assert(i < REGMAX); + if (mi & tosave) /* i = register to save */ + { + int push,pop; + + stackchanged = 1; + if (i == ES) + { push = 0x06; + pop = 0x07; + } + else + { push = 0x50 + i; + pop = push | 8; + } + c = gen1(c,push); // PUSH i + cs2 = cat(gen1(CNIL,pop),cs2); // POP i + tosave &= ~mi; + } + } + + // For 16 bit models, push a far pointer + if (I16) + { int segreg; + + switch (pcs->Iflags & (CFes | CFss | CFcs | CFds | CFfs | CFgs)) + { case CFes: segreg = 0x06; break; + case CFss: segreg = 0x16; break; + case CFcs: segreg = 0x0E; break; + case 0: segreg = 0x1E; break; // DS + default: + assert(0); + } + + // See if we should default to SS: + // (Happens when BP is part of the addressing mode) + if (segreg == 0x1E && (rm & 0xC0) != 0xC0 && + rm & 2 && (rm & 7) != 7) + { segreg = 0x16; + if (config.wflags & WFssneds) + pcs->Iflags |= CFss; // because BP won't be there anymore + } + c = gen1(c,segreg); // PUSH segreg + } + + c = gen1(c,0x50 + reg); // PUSH reg + + // Rewrite the addressing mode in *pcs so it is just 0[reg] + setaddrmode(pcs, idxregs); + pcs->IFL1 = FLoffset; + pcs->IEV1.Vuns = 0; + + // Call the validation function + { + makeitextern(rtlsym[RTLSYM_PTRCHK]); + + used &= ~(keepmsk | idxregs); // regs destroyed by this exercise + c = cat(c,getregs(used)); + // CALL __ptrchk + gencs(c,(LARGECODE) ? 0x9A : CALL,0,FLfunc,rtlsym[RTLSYM_PTRCHK]); + } + + *pc = cat(c,cs2); +} + + + +/*********************************** + * Determine if BP can be used as a general purpose register. + * Note parallels between this routine and prolog(). + * Returns: + * 0 can't be used, needed for frame + * mBP can be used + */ + +regm_t cod3_useBP() +{ + tym_t tym; + tym_t tyf; + + // Note that DOSX memory model cannot use EBP as a general purpose + // register, as SS != DS. + if (!(config.exe & EX_flat) || config.flags & (CFGalwaysframe | CFGnoebp)) + goto Lcant; + + if (anyiasm) + goto Lcant; + + tyf = funcsym_p->ty(); + if (tyf & mTYnaked) // if no prolog/epilog for function + goto Lcant; + + if (funcsym_p->Sfunc->Fflags3 & Ffakeeh) + { + goto Lcant; // need consistent stack frame + } + + tym = tybasic(tyf); + if (tym == TYifunc) + goto Lcant; + + stackoffsets(0); + localsize = Aoffset; // an estimate only +// if (localsize) + { + if (!(config.flags4 & CFG4speed) || + config.target_cpu < TARGET_Pentium || + tyfarfunc(tym) || + config.flags & CFGstack || + localsize >= 0x100 || // arbitrary value < 0x1000 + (usednteh & ~NTEHjmonitor) || + usedalloca + ) + goto Lcant; + } +Lcan: + return mBP; + +Lcant: + return 0; +} + +/*************************************** + * Gen code for OPframeptr + */ + +code *cdframeptr(elem *e, regm_t *pretregs) +{ + unsigned reg; + code cs; + + regm_t retregs = *pretregs & allregs; + if (!retregs) + retregs = allregs; + code *cg = allocreg(&retregs, ®, TYint); + + cs.Iop = ESCAPE | ESCframeptr; + cs.Iflags = 0; + cs.Irex = 0; + cs.Irm = reg; + cg = gen(cg,&cs); + + return cat(cg,fixresult(e,retregs,pretregs)); +} + +/*************************************** + * Gen code for load of _GLOBAL_OFFSET_TABLE_. + * This value gets cached in the local variable 'localgot'. + */ + +code *cdgot(elem *e, regm_t *pretregs) +{ +#if TARGET_OSX + regm_t retregs; + unsigned reg; + code *c; + + retregs = *pretregs & allregs; + if (!retregs) + retregs = allregs; + c = allocreg(&retregs, ®, TYnptr); + + c = genc(c,CALL,0,0,0,FLgot,0); // CALL L1 + gen1(c, 0x58 + reg); // L1: POP reg + + return cat(c,fixresult(e,retregs,pretregs)); +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + regm_t retregs; + unsigned reg; + code *c; + code *cgot; + + retregs = *pretregs & allregs; + if (!retregs) + retregs = allregs; + c = allocreg(&retregs, ®, TYnptr); + + c = genc2(c,CALL,0,0); // CALL L1 + gen1(c, 0x58 + reg); // L1: POP reg + + // ADD reg,_GLOBAL_OFFSET_TABLE_+3 + symbol *gotsym = elfobj_getGOTsym(); + cgot = gencs(CNIL,0x81,modregrm(3,0,reg),FLextern,gotsym); + /* Because the 2:3 offset from L1: is hardcoded, + * this sequence of instructions must not + * have any instructions in between, + * so set CFvolatile to prevent the scheduler from rearranging it. + */ + cgot->Iflags = CFoff | CFvolatile; + cgot->IEVoffset2 = (reg == AX) ? 2 : 3; + + makeitextern(gotsym); + return cat3(c,cgot,fixresult(e,retregs,pretregs)); +#else + assert(0); + return NULL; +#endif +} + +/************************************************** + * Load contents of localgot into EBX. + */ + +code *load_localgot() +{ +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic && I32) + { + if (localgot) + { + localgot->Sflags &= ~GTregcand; // because this hack doesn't work with reg allocator + elem *e = el_var(localgot); + regm_t retregs = mBX; + code *c = codelem(e,&retregs,FALSE); + el_free(e); + return c; + } + else + { + elem *e = el_long(TYnptr, 0); + e->Eoper = OPgot; + regm_t retregs = mBX; + code *c = codelem(e,&retregs,FALSE); + el_free(e); + return c; + } + } +#endif + return NULL; +} + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +/***************************** + * Returns: + * # of bytes stored + */ + +#define ONS_OHD 4 // max # of extra bytes added by obj_namestring() + +STATIC int obj_namestring(char *p,const char *name) +{ unsigned len; + + len = strlen(name); + if (len > 255) + { + short *ps = (short *)p; + p[0] = 0xFF; + p[1] = 0; + ps[1] = len; + memcpy(p + 4,name,len); + len += ONS_OHD; + } + else + { p[0] = len; + memcpy(p + 1,name,len); + len++; + } + return len; +} +#endif + +code *genregs(code *c,unsigned op,unsigned dstreg,unsigned srcreg) +{ return gen2(c,op,modregxrmx(3,dstreg,srcreg)); } + +code *gentstreg(code *c,unsigned t) +{ + c = gen2(c,0x85,modregxrmx(3,t,t)); // TEST t,t + code_orflag(c,CFpsw); + return c; +} + +code *genpush(code *c, unsigned reg) +{ + c = gen1(c, 0x50 + (reg & 7)); + if (reg & 8) + code_orrex(c, REX_B); + return c; +} + +code *genpop(code *c, unsigned reg) +{ + c = gen1(c, 0x58 + (reg & 7)); + if (reg & 8) + code_orrex(c, REX_B); + return c; +} + +/************************** + * Generate a MOV to save a register to a stack slot + */ +code *gensavereg(unsigned& reg, targ_uns slot) +{ + // MOV i[BP],reg + unsigned op = 0x89; // normal mov + if (reg == ES) + { reg = 0; // the real reg number + op = 0x8C; // segment reg mov + } + code *c = genc1(NULL,op,modregxrm(2, reg, BPRM),FLcs,slot); + if (I64) + code_orrex(c, REX_W); + + return c; +} + +/************************** + * Generate a MOV to,from register instruction. + * Smart enough to dump redundant register moves, and segment + * register moves. + */ + +code *genmovreg(code *c,unsigned to,unsigned from) +{ +#if DEBUG + if (to > ES || from > ES) + printf("genmovreg(c = %p, to = %d, from = %d)\n",c,to,from); +#endif + assert(to <= ES && from <= ES); + if (to != from) + { + if (to == ES) + c = genregs(c,0x8E,0,from); + else if (from == ES) + c = genregs(c,0x8C,0,to); + else + c = genregs(c,0x89,from,to); + if (I64) + code_orrex(c, REX_W); + } + return c; +} + +/*************************************** + * Generate immediate multiply instruction for r1=r2*imm. + * Optimize it into LEA's if we can. + */ + +code *genmulimm(code *c,unsigned r1,unsigned r2,targ_int imm) +{ code cs; + + // These optimizations should probably be put into pinholeopt() + switch (imm) + { case 1: + c = genmovreg(c,r1,r2); + break; + case 5: + cs.Iop = LEA; + cs.Iflags = 0; + cs.Irex = 0; + buildEA(&cs,r2,r2,4,0); + cs.orReg(r1); + c = gen(c,&cs); + break; + default: + c = genc2(c,0x69,modregxrmx(3,r1,r2),imm); // IMUL r1,r2,imm + break; + } + return c; +} + +/****************************** + * Load CX with the value of _AHSHIFT. + */ + +code *genshift(code *c) +{ +#if SCPP && TX86 + code *c1; + + // Set up ahshift to trick ourselves into giving the right fixup, + // which must be seg-relative, external frame, external target. + c1 = gencs(CNIL,0xC7,modregrm(3,0,CX),FLfunc,rtlsym[RTLSYM_AHSHIFT]); + c1->Iflags |= CFoff; + return cat(c,c1); +#else + assert(0); + return 0; +#endif +} + +/****************************** + * Move constant value into reg. + * Take advantage of existing values in registers. + * If flags & mPSW + * set flags based on result + * Else if flags & 8 + * do not disturb flags + * Else + * don't care about flags + * If flags & 1 then byte move + * If flags & 2 then short move (for I32 and I64) + * If flags & 4 then don't disturb unused portion of register + * If flags & 16 then reg is a byte register AL..BH + * If flags & 64 (0x40) then 64 bit move (I64 only) + * Returns: + * code (if any) generated + */ + +code *movregconst(code *c,unsigned reg,targ_size_t value,regm_t flags) +{ unsigned r; + regm_t mreg; + + //printf("movregconst(reg=%s, value= %lld (%llx), flags=%x)\n", regm_str(mask[reg]), value, value, flags); +#define genclrreg(a,r) genregs(a,0x31,r,r) + + regm_t regm = regcon.immed.mval & mask[reg]; + targ_size_t regv = regcon.immed.value[reg]; + + if (flags & 1) // 8 bits + { + value &= 0xFF; + regm &= BYTEREGS; + + // If we already have the right value in the right register + if (regm && (regv & 0xFF) == value) + goto L2; + + if (flags & 16 && reg & 4 && // if an H byte register + regcon.immed.mval & mask[reg & 3] && + (((regv = regcon.immed.value[reg & 3]) >> 8) & 0xFF) == value) + goto L2; + + /* Avoid byte register loads on Pentium Pro and Pentium II + * to avoid dependency stalls. + */ + if (config.flags4 & CFG4speed && + config.target_cpu >= TARGET_PentiumPro && !(flags & 4)) + goto L3; + + // See if another register has the right value + r = 0; + for (mreg = (regcon.immed.mval & BYTEREGS); mreg; mreg >>= 1) + { + if (mreg & 1) + { + if ((regcon.immed.value[r] & 0xFF) == value) + { c = genregs(c,0x8A,reg,r); // MOV regL,rL + if (I64 && reg >= 4 || r >= 4) + code_orrex(c, REX); + goto L2; + } + if (!(I64 && reg >= 4) && + r < 4 && ((regcon.immed.value[r] >> 8) & 0xFF) == value) + { c = genregs(c,0x8A,reg,r | 4); // MOV regL,rH + goto L2; + } + } + r++; + } + + if (value == 0 && !(flags & 8)) + { + if (!(flags & 4) && // if we can set the whole register + !(flags & 16 && reg & 4)) // and reg is not an H register + { c = genregs(c,0x31,reg,reg); // XOR reg,reg + regimmed_set(reg,value); + regv = 0; + } + else + c = genregs(c,0x30,reg,reg); // XOR regL,regL + flags &= ~mPSW; // flags already set by XOR + } + else + { c = genc2(c,0xC6,modregrmx(3,0,reg),value); /* MOV regL,value */ + if (reg >= 4 && I64) + { + code_orrex(c, REX); + } + } + L2: + if (flags & mPSW) + genregs(c,0x84,reg,reg); // TEST regL,regL + + if (regm) + // Set just the 'L' part of the register value + regimmed_set(reg,(regv & ~(targ_size_t)0xFF) | value); + else if (flags & 16 && reg & 4 && regcon.immed.mval & mask[reg & 3]) + // Set just the 'H' part of the register value + regimmed_set((reg & 3),(regv & ~(targ_size_t)0xFF00) | (value << 8)); + return c; + } +L3: + if (I16) + value = (targ_short) value; /* sign-extend MSW */ + else if (I32) + value = (targ_int) value; + + if (!I16 && flags & 2) // load 16 bit value + { + value &= 0xFFFF; + if (value == 0) + goto L1; + else + { + if (flags & mPSW) + goto L1; + code *c1 = genc2(CNIL,0xC7,modregrmx(3,0,reg),value); // MOV reg,value + c1->Iflags |= CFopsize; // yes, even for I64 + c = cat(c,c1); + if (regm) + // High bits of register are not affected by 16 bit load + regimmed_set(reg,(regv & ~(targ_size_t)0xFFFF) | value); + } + return c; + } +L1: + + /* If we already have the right value in the right register */ + if (regm && (regv & 0xFFFFFFFF) == (value & 0xFFFFFFFF) && !(flags & 64)) + { if (flags & mPSW) + c = gentstreg(c,reg); + } + else if (flags & 64 && regm && regv == value) + { // Look at the full 64 bits + if (flags & mPSW) + { + c = gentstreg(c,reg); + code_orrex(c, REX_W); + } + } + else + { + if (flags & mPSW) + { + switch (value) + { case 0: + c = genclrreg(c,reg); + if (flags & 64) + code_orrex(c, REX_W); + break; + case 1: + if (I64) + goto L4; + c = genclrreg(c,reg); + goto inc; + case -1: + if (I64) + goto L4; + c = genclrreg(c,reg); + goto dec; + default: + L4: + if (flags & 64) + { + c = genc2(c,0xC7,(REX_W << 16) | modregrmx(3,0,reg),value); // MOV reg,value64 + gentstreg(c,reg); + code_orrex(c, REX_W); + } + else + { c = genc2(c,0xC7,modregrmx(3,0,reg),value); /* MOV reg,value */ + gentstreg(c,reg); + } + break; + } + } + else + { + /* Look for single byte conversion */ + if (regcon.immed.mval & mAX) + { + if (I32) + { if (reg == AX && value == (targ_short) regv) + { c = gen1(c,0x98); /* CWDE */ + goto done; + } + if (reg == DX && + value == (regcon.immed.value[AX] & 0x80000000 ? 0xFFFFFFFF : 0) && + !(config.flags4 & CFG4speed && config.target_cpu >= TARGET_Pentium) + ) + { c = gen1(c,0x99); /* CDQ */ + goto done; + } + } + else if (I16) + { + if (reg == AX && + (targ_short) value == (signed char) regv) + { c = gen1(c,0x98); /* CBW */ + goto done; + } + + if (reg == DX && + (targ_short) value == (regcon.immed.value[AX] & 0x8000 ? (targ_short) 0xFFFF : (targ_short) 0) && + !(config.flags4 & CFG4speed && config.target_cpu >= TARGET_Pentium) + ) + { c = gen1(c,0x99); /* CWD */ + goto done; + } + } + } + if (value == 0 && !(flags & 8) && config.target_cpu >= TARGET_80486) + { c = genclrreg(c,reg); // CLR reg + if (flags & 64) + code_orrex(c, REX_W); + goto done; + } + + if (!I64 && regm && !(flags & 8)) + { if (regv + 1 == value || + /* Catch case of (0xFFFF+1 == 0) for 16 bit compiles */ + (I16 && (targ_short)(regv + 1) == (targ_short)value)) + { + inc: + c = gen1(c,0x40 + reg); /* INC reg */ + goto done; + } + if (regv - 1 == value) + { + dec: + c = gen1(c,0x48 + reg); /* DEC reg */ + goto done; + } + } + + /* See if another register has the right value */ + r = 0; + for (mreg = regcon.immed.mval; mreg; mreg >>= 1) + { +#ifdef DEBUG + assert(!I16 || regcon.immed.value[r] == (targ_short)regcon.immed.value[r]); +#endif + if (mreg & 1 && regcon.immed.value[r] == value) + { c = genmovreg(c,reg,r); + if (flags & 64) + code_orrex(c, REX_W); + goto done; + } + r++; + } + + if (value == 0 && !(flags & 8)) + { c = genclrreg(c,reg); // CLR reg + if (flags & 64) + code_orrex(c, REX_W); + } + else + { /* See if we can just load a byte */ + if (regm & BYTEREGS && + !(config.flags4 & CFG4speed && config.target_cpu >= TARGET_PentiumPro) + ) + { + if ((regv & ~(targ_size_t)0xFF) == (value & ~(targ_size_t)0xFF)) + { c = movregconst(c,reg,value,(flags & 8) |4|1); // load regL + return c; + } + if (regm & (mAX|mBX|mCX|mDX) && + (regv & ~(targ_size_t)0xFF00) == (value & ~(targ_size_t)0xFF00) && + !I64) + { c = movregconst(c,4|reg,value >> 8,(flags & 8) |4|1|16); // load regH + return c; + } + } + if (flags & 64) + c = genc2(c,0xC7,(REX_W << 16) | modregrmx(3,0,reg),value); // MOV reg,value64 + else + c = genc2(c,0xC7,modregrmx(3,0,reg),value); // MOV reg,value + } + } + done: + regimmed_set(reg,value); + } + return c; +} + +/************************** + * Generate a jump instruction. + */ + +code *genjmp(code *c,unsigned op,unsigned fltarg,block *targ) +{ code cs; + code *cj; + code *cnop; + + cs.Iop = op & 0xFF; + cs.Iflags = 0; + cs.Irex = 0; + if (op != JMP && op != 0xE8) // if not already long branch + cs.Iflags = CFjmp16; /* assume long branch for op = 0x7x */ + cs.IFL2 = fltarg; /* FLblock (or FLcode) */ + cs.IEV2.Vblock = targ; /* target block (or code) */ + if (fltarg == FLcode) + ((code *)targ)->Iflags |= CFtarg; + + if (config.flags4 & CFG4fastfloat) // if fast floating point + return gen(c,&cs); + + cj = gen(CNIL,&cs); + switch (op & 0xFF00) /* look at second jump opcode */ + { + /* The JP and JNP come from floating point comparisons */ + case JP << 8: + cs.Iop = JP; + gen(cj,&cs); + break; + case JNP << 8: + /* Do a JP around the jump instruction */ + cnop = gennop(CNIL); + c = genjmp(c,JP,FLcode,(block *) cnop); + cat(cj,cnop); + break; + case 1 << 8: /* toggled no jump */ + case 0 << 8: + break; + default: +#ifdef DEBUG + printf("jop = x%x\n",op); +#endif + assert(0); + } + return cat(c,cj); +} + +/******************************* + * Generate code for a function start. + * Input: + * Coffset address of start of code + * Output: + * Coffset adjusted for size of code generated + * EBPtoESP + * hasframe + * BPoff + */ + +code *prolog() +{ + SYMIDX si; + unsigned reg; + char enter; + unsigned Foffset; + unsigned xlocalsize; // amount to subtract from ESP to make room for locals + unsigned pushallocreg; + char guessneedframe; + regm_t namedargs = 0; + + //printf("cod3.prolog(), needframe = %d, Aalign = %d\n", needframe, Aalign); + debugx(debugw && printf("funcstart()\n")); + regcon.immed.mval = 0; /* no values in registers yet */ + EBPtoESP = -REGSIZE; + hasframe = 0; + char pushds = 0; + BPoff = 0; + code *c = CNIL; + int pushalloc = 0; + tym_t tyf = funcsym_p->ty(); + tym_t tym = tybasic(tyf); + unsigned farfunc = tyfarfunc(tym); + pushallocreg = (tyf == TYmfunc) ? CX : AX; + if (config.flags & CFGalwaysframe || funcsym_p->Sfunc->Fflags3 & Ffakeeh) + needframe = 1; + +Lagain: + guessneedframe = needframe; +// if (needframe && config.exe & (EX_LINUX | EX_FREEBSD | EX_SOLARIS) && !(usednteh & ~NTEHjmonitor)) +// usednteh |= NTEHpassthru; + + /* Compute BP offsets for variables on stack. + * The organization is: + * Poff parameters + * seg of return addr (if far function) + * IP of return addr + * BP-> caller's BP + * DS (if Windows prolog/epilog) + * exception handling context symbol + * Aoff autos and regs + * regsave.off any saved registers + * Foff floating register + * AAoff alloca temporary + * CSoff common subs + * NDPoff any 8087 saved registers + * Toff temporaries + * monitor context record + * any saved registers + */ + + if (tym == TYifunc) + Poff = 26; + else if (I64) + Poff = 16; + else if (I32) + Poff = farfunc ? 12 : 8; + else + Poff = farfunc ? 6 : 4; + + Aoff = 0; +#if NTEXCEPTIONS == 2 + Aoff -= nteh_contextsym_size(); +#if MARS + if (funcsym_p->Sfunc->Fflags3 & Ffakeeh && nteh_contextsym_size() == 0) + Aoff -= 5 * 4; +#endif +#endif + Aoff = -align(0,-Aoff + Aoffset); + + regsave.off = Aoff - align(0,regsave.top); + Foffset = floatreg ? (config.fpxmmregs ? 16 : DOUBLESIZE) : 0; + Foff = regsave.off - align(0,Foffset); + assert(usedalloca != 1); + AAoff = usedalloca ? (Foff - REGSIZE) : Foff; + CSoff = AAoff - align(0,cstop * REGSIZE); + NDPoff = CSoff - align(0,NDP::savetop * NDPSAVESIZE); + Toff = NDPoff - align(0,Toffset); + + if (Foffset > Aalign) + Aalign = Foffset; + if (Aalign > REGSIZE) + { + // Adjust Aoff so that it is Aalign byte aligned, assuming that + // before function parameters were pushed the stack was + // Aalign byte aligned + targ_size_t psize = (Poffset + (REGSIZE - 1)) & ~(REGSIZE - 1); + int sz = psize + -Aoff + Poff + (needframe ? 0 : REGSIZE); + if (sz & (Aalign - 1)) + { int adj = Aalign - (sz & (Aalign - 1)); + Aoff -= adj; + regsave.off -= adj; + Foff -= adj; + AAoff -= adj; + CSoff -= adj; + NDPoff -= adj; + Toff -= adj; + } + } + + localsize = -Toff; + + regm_t topush = fregsaved & ~mfuncreg; // mask of registers that need saving + int npush = 0; // number of registers that need saving + for (regm_t x = topush; x; x >>= 1) + npush += x & 1; + + // Keep the stack aligned by 8 for any subsequent function calls + if (!I16 && calledafunc && + (STACKALIGN == 16 || config.flags4 & CFG4stackalign)) + { + //printf("npush = %d Poff = x%x needframe = %d localsize = x%x\n", npush, Poff, needframe, localsize); + + int sz = Poff + (needframe ? 0 : -REGSIZE) + localsize + npush * REGSIZE; + if (STACKALIGN == 16) + { + if (sz & (8|4)) + localsize += STACKALIGN - (sz & (8|4)); + } + else if (sz & 4) + localsize += 4; + } + + //printf("Foff x%02x Aoff x%02x Toff x%02x NDPoff x%02x CSoff x%02x Poff x%02x localsize x%02x\n", + //(int)Foff,(int)Aoff,(int)Toff,(int)NDPoff,(int)CSoff,(int)Poff,(int)localsize); + + xlocalsize = localsize; + + if (tyf & mTYnaked) // if no prolog/epilog for function + { + hasframe = 1; + return NULL; + } + + if (tym == TYifunc) + { static unsigned char ops2[] = { 0x60,0x1E,0x06,0 }; + static unsigned char ops0[] = { 0x50,0x51,0x52,0x53, + 0x54,0x55,0x56,0x57, + 0x1E,0x06,0 }; + + unsigned char *p; + + p = (config.target_cpu >= TARGET_80286) ? ops2 : ops0; + do + c = gen1(c,*p); + while (*++p); + c = genregs(c,0x8B,BP,SP); // MOV BP,SP + if (localsize) + c = genc2(c,0x81,modregrm(3,5,SP),localsize); // SUB SP,localsize + tyf |= mTYloadds; + hasframe = 1; + goto Lcont; + } + + /* Determine if we need BP set up */ + if (config.flags & CFGalwaysframe) + needframe = 1; + else + { + if (localsize) + { + if (I16 || + !(config.flags4 & CFG4speed) || + config.target_cpu < TARGET_Pentium || + farfunc || + config.flags & CFGstack || + xlocalsize >= 0x1000 || + (usednteh & ~NTEHjmonitor) || + anyiasm || + usedalloca + ) + needframe = 1; + } + if (refparam && (anyiasm || I16)) + needframe = 1; + } + + if (needframe) + { assert(mfuncreg & mBP); // shouldn't have used mBP + + if (!guessneedframe) // if guessed wrong + goto Lagain; + } + + if (I16 && config.wflags & WFwindows && farfunc) + { int wflags; + int segreg; + +#if SCPP + // alloca() can't be because the 'special' parameter won't be at + // a known offset from BP. + if (usedalloca == 1) + synerr(EM_alloca_win); // alloca() can't be in Windows functions +#endif + + wflags = config.wflags; + if (wflags & WFreduced && !(tyf & mTYexport)) + { // reduced prolog/epilog for non-exported functions + wflags &= ~(WFdgroup | WFds | WFss); + } + + c = getregs(mAX); + assert(!c); /* should not have any value in AX */ + + switch (wflags & (WFdgroup | WFds | WFss)) + { case WFdgroup: // MOV AX,DGROUP + if (wflags & WFreduced) + tyf &= ~mTYloadds; // remove redundancy + c = genc(c,0xC7,modregrm(3,0,AX),0,0,FLdatseg,(targ_uns) 0); + c->Iflags ^= CFseg | CFoff; // turn off CFoff, on CFseg + break; + case WFss: + segreg = 2; // SS + goto Lmovax; + case WFds: + segreg = 3; // DS + Lmovax: + c = gen2(c,0x8C,modregrm(3,segreg,AX)); // MOV AX,segreg + if (wflags & WFds) + gen1(c,0x90); // NOP + break; + case 0: + break; + default: +#ifdef DEBUG + printf("config.wflags = x%x\n",config.wflags); +#endif + assert(0); + } + if (wflags & WFincbp) + c = gen1(c,0x40 + BP); // INC BP + c = gen1(c,0x50 + BP); // PUSH BP + genregs(c,0x8B,BP,SP); // MOV BP,SP + if (wflags & (WFsaveds | WFds | WFss | WFdgroup)) + { gen1(c,0x1E); // PUSH DS + pushds = TRUE; + BPoff = -REGSIZE; + } + if (wflags & (WFds | WFss | WFdgroup)) + gen2(c,0x8E,modregrm(3,3,AX)); // MOV DS,AX + + enter = FALSE; /* don't use ENTER instruction */ + hasframe = 1; /* we have a stack frame */ + } + else + if (needframe) // if variables or parameters + { + if (config.wflags & WFincbp && farfunc) + c = gen1(c,0x40 + BP); /* INC BP */ + if (config.target_cpu < TARGET_80286 || + config.exe & (EX_LINUX | EX_LINUX64 | EX_OSX | EX_OSX64 | EX_FREEBSD | EX_FREEBSD64 | EX_SOLARIS | EX_SOLARIS64) || + !localsize || + config.flags & CFGstack || + (xlocalsize >= 0x1000 && config.exe & EX_flat) || + localsize >= 0x10000 || +#if NTEXCEPTIONS == 2 + (usednteh & ~NTEHjmonitor && (config.flags2 & CFG2seh)) || +#endif + (config.target_cpu >= TARGET_80386 && + config.flags4 & CFG4speed) + ) + { + c = gen1(c,0x50 + BP); // PUSH BP + genregs(c,0x8B,BP,SP); // MOV BP,SP + if (I64) + code_orrex(c, REX_W); // MOV RBP,RSP +#if ELFOBJ || MACHOBJ + if (config.fulltypes) + // Don't reorder instructions, as dwarf CFA relies on it + code_orflag(c, CFvolatile); +#endif + enter = FALSE; /* do not use ENTER instruction */ +#if NTEXCEPTIONS == 2 + if (usednteh & ~NTEHjmonitor && (config.flags2 & CFG2seh)) + { + code *ce = nteh_prolog(); + c = cat(c,ce); + int sz = nteh_contextsym_size(); + assert(sz != 0); // should be 5*4, not 0 + xlocalsize -= sz; // sz is already subtracted from ESP + // by nteh_prolog() + } +#endif +#if ELFOBJ || MACHOBJ + if (config.fulltypes) + { int off = I64 ? 16 : 8; + dwarf_CFA_set_loc(1); // address after PUSH EBP + dwarf_CFA_set_reg_offset(SP, off); // CFA is now 8[ESP] + dwarf_CFA_offset(BP, -off); // EBP is at 0[ESP] + dwarf_CFA_set_loc(3); // address after MOV EBP,ESP + // Yes, I know the parameter is 8 when we mean 0! + // But this gets the cfa register set to EBP correctly + dwarf_CFA_set_reg_offset(BP, off); // CFA is now 0[EBP] + } +#endif + } + else + enter = TRUE; + hasframe = 1; + } + + if (config.flags & CFGstack) /* if stack overflow check */ + goto Ladjstack; + + if (needframe) /* if variables or parameters */ + { + if (xlocalsize) /* if any stack offset */ + { + Ladjstack: +#if !TARGET_LINUX // seems that Linux doesn't need to fault in stack pages + if ((config.flags & CFGstack && !(I32 && xlocalsize < 0x1000)) // if stack overflow check +#if TARGET_WINDOS + || (xlocalsize >= 0x1000 && config.exe & EX_flat) +#endif + ) + { + if (I16) + { + // BUG: Won't work if parameter is passed in AX + c = movregconst(c,AX,xlocalsize,FALSE); // MOV AX,localsize + makeitextern(rtlsym[RTLSYM_CHKSTK]); + // CALL _chkstk + gencs(c,(LARGECODE) ? 0x9A : CALL,0,FLfunc,rtlsym[RTLSYM_CHKSTK]); + useregs((ALLREGS | mBP | mES) & ~rtlsym[RTLSYM_CHKSTK]->Sregsaved); + } + else + { + /* Watch out for 64 bit code where EDX is passed as a register parameter + */ + int reg = I64 ? R11 : DX; // scratch register + + /* MOV EDX, xlocalsize/0x1000 + * L1: SUB ESP, 0x1000 + * TEST [ESP],ESP + * DEC EDX + * JNE L1 + * SUB ESP, xlocalsize % 0x1000 + */ + c = movregconst(c, reg, xlocalsize / 0x1000, FALSE); + code *csub = genc2(NULL,0x81,modregrm(3,5,SP),0x1000); + if (I64) + code_orrex(csub, REX_W); + code_orflag(csub, CFtarg2); + gen2sib(csub, 0x85, modregrm(0,SP,4),modregrm(0,4,SP)); + if (I64) + { gen2(csub, 0xFF, (REX_W << 16) | modregrmx(3,0,R11)); // DEC R11 + genc2(csub,JNE,0,(targ_uns)-14); + } + else + { gen1(csub, 0x48 + DX); // DEC EDX + genc2(csub,JNE,0,(targ_uns)-12); + } + regimmed_set(reg,0); // reg is now 0 + genc2(csub,0x81,modregrm(3,5,SP),xlocalsize & 0xFFF); + if (I64) + code_orrex(csub, REX_W); + c = cat(c,csub); + useregs(mask[reg]); + } + } + else +#endif + { + if (enter) + { // ENTER xlocalsize,0 + c = genc(c,0xC8,0,FLconst,xlocalsize,FLconst,(targ_uns) 0); +#if ELFOBJ || MACHOBJ + assert(!config.fulltypes); // didn't emit Dwarf data +#endif + } + else if (xlocalsize == REGSIZE && config.flags4 & CFG4optimized) + { c = gen1(c,0x50 + pushallocreg); // PUSH AX + // Do this to prevent an -x[EBP] to be moved in + // front of the push. + code_orflag(c,CFvolatile); + pushalloc = 1; + } + else + { // SUB SP,xlocalsize + c = genc2(c,0x81,modregrm(3,5,SP),xlocalsize); + if (I64) + code_orrex(c, REX_W); + } + } + + if (usedalloca) + { + // Set up magic parameter for alloca() + // MOV -REGSIZE[BP],localsize - BPoff + //c = genc(c,0xC7,modregrm(2,0,BPRM),FLconst,-REGSIZE,FLconst,localsize - BPoff); + c = genc(c,0xC7,modregrm(2,0,BPRM), + FLconst,AAoff + BPoff, + FLconst,localsize - BPoff); + if (I64) + code_orrex(c, REX_W); + } + } + else + assert(usedalloca == 0); + } + else if (xlocalsize) + { + assert(I32); + + if (xlocalsize == REGSIZE) + { c = gen1(c,0x50 + pushallocreg); // PUSH AX + pushalloc = 1; + } + else if (xlocalsize == 2 * REGSIZE) + { c = gen1(c,0x50 + pushallocreg); // PUSH AX + gen1(c,0x50 + pushallocreg); // PUSH AX + pushalloc = 1; + } + else + { // SUB ESP,xlocalsize + c = genc2(c,0x81,modregrm(3,5,SP),xlocalsize); + if (I64) + code_orrex(c, REX_W); + } + BPoff += REGSIZE; + } + else + assert((localsize | usedalloca) == 0 || (usednteh & NTEHjmonitor)); + EBPtoESP += xlocalsize; + + /* The idea is to generate trace for all functions if -Nc is not thrown. + * If -Nc is thrown, generate trace only for global COMDATs, because those + * are relevant to the FUNCTIONS statement in the linker .DEF file. + * This same logic should be in epilog(). + */ + if (config.flags & CFGtrace && + (!(config.flags4 & CFG4allcomdat) || + funcsym_p->Sclass == SCcomdat || + funcsym_p->Sclass == SCglobal || + (config.flags2 & CFG2comdat && SymInline(funcsym_p)) + ) + ) + { + if (STACKALIGN == 16 && npush) + { /* This could be avoided by moving the function call to after the + * registers are saved. But I don't remember why the call is here + * and not there. + */ + c = genc2(c,0x81,modregrm(3,5,SP),npush * REGSIZE); // SUB ESP,npush * REGSIZE + if (I64) + code_orrex(c, REX_W); + } + + symbol *s = rtlsym[farfunc ? RTLSYM_TRACE_PRO_F : RTLSYM_TRACE_PRO_N]; + makeitextern(s); + c = gencs(c,I16 ? 0x9A : CALL,0,FLfunc,s); // CALL _trace + if (!I16) + code_orflag(c,CFoff | CFselfrel); + /* Embedding the function name inline after the call works, but it + * makes disassembling the code annoying. + */ +#if ELFOBJ || MACHOBJ + size_t len = strlen(funcsym_p->Sident); + char *buffer = (char *)malloc(len + 4); + assert(buffer); + if (len <= 254) + { buffer[0] = len; + memcpy(buffer + 1, funcsym_p->Sident, len); + len++; + } + else + { buffer[0] = 0xFF; + buffer[1] = 0; + buffer[2] = len & 0xFF; + buffer[3] = len >> 8; + memcpy(buffer + 4, funcsym_p->Sident, len); + len += 4; + } + genasm(c, buffer, len); // append func name + free(buffer); +#else + char name[IDMAX+IDOHD+1]; + size_t len = obj_mangle(funcsym_p,name); + assert(len < sizeof(name)); + genasm(c,name,len); // append func name +#endif + if (STACKALIGN == 16 && npush) + { + c = genc2(c,0x81,modregrm(3,0,SP),npush * REGSIZE); // ADD ESP,npush * REGSIZE + if (I64) + code_orrex(c, REX_W); + } + useregs((ALLREGS | mBP | mES) & ~s->Sregsaved); + } + +#if MARS + if (usednteh & NTEHjmonitor) + { Symbol *sthis; + + for (si = 0; 1; si++) + { assert(si < globsym.top); + sthis = globsym.tab[si]; + if (strcmp(sthis->Sident,"this") == 0) + break; + } + c = cat(c,nteh_monitor_prolog(sthis)); + EBPtoESP += 3 * 4; + } +#endif + + while (topush) /* while registers to push */ + { reg = findreg(topush); + topush &= ~mask[reg]; + c = gen1(c,0x50 + (reg & 7)); + if (reg & 8) + code_orrex(c, REX_B); + EBPtoESP += REGSIZE; +#if ELFOBJ || MACHOBJ + if (config.fulltypes) + { // Emit debug_frame data giving location of saved register + // relative to 0[EBP] + pinholeopt(c, NULL); + dwarf_CFA_set_loc(calcblksize(c)); // address after PUSH reg + dwarf_CFA_offset(reg, -EBPtoESP - REGSIZE); + } +#endif + } + +Lcont: + + /* Determine if we need to reload DS */ + if (tyf & mTYloadds) + { code *c1; + + if (!pushds) // if not already pushed + c = gen1(c,0x1E); // PUSH DS + c1 = genc(CNIL,0xC7,modregrm(3,0,AX),0,0,FLdatseg,(targ_uns) 0); /* MOV AX,DGROUP */ + c1->Iflags ^= CFseg | CFoff; /* turn off CFoff, on CFseg */ + c = cat(c,c1); + gen2(c,0x8E,modregrm(3,3,AX)); /* MOV DS,AX */ + useregs(mAX); + } + + if (tym == TYifunc) + c = gen1(c,0xFC); // CLD + +#if NTEXCEPTIONS == 2 + if (usednteh & NTEH_except) + c = cat(c,nteh_setsp(0x89)); // MOV __context[EBP].esp,ESP +#endif + + // Load register parameters off of the stack. Do not use + // assignaddr(), as it will replace the stack reference with + // the register! + for (si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + code *c2; + unsigned sz = type_size(s->Stype); + + if ((s->Sclass == SCregpar || s->Sclass == SCparameter) && + s->Sfl == FLreg && + (refparam +#if MARS + // This variable has been reference by a nested function + || s->Stype->Tty & mTYvolatile +#endif + )) + { + /* MOV reg,param[BP] */ + //assert(refparam); + if (mask[s->Sreglsw] & XMMREGS) + { + unsigned op = xmmload(s->Stype->Tty); // MOVSS/D xreg,mem + unsigned xreg = s->Sreglsw - XMM0; + code *c2 = genc1(CNIL,op,modregxrm(2,xreg,BPRM),FLconst,Poff + s->Soffset); + if (!hasframe) + { // Convert to ESP relative address rather than EBP + c2->Irm = modregxrm(2,xreg,4); + c2->Isib = modregrm(0,4,SP); + c2->IEVpointer1 += EBPtoESP; + } + c = cat(c,c2); + } + else + { + code *c2 = genc1(CNIL,0x8B ^ (sz == 1), + modregxrm(2,s->Sreglsw,BPRM),FLconst,Poff + s->Soffset); + if (!I16 && sz == SHORTSIZE) + c2->Iflags |= CFopsize; // operand size + if (I64 && sz >= REGSIZE) + c2->Irex |= REX_W; + if (!hasframe) + { /* Convert to ESP relative address rather than EBP */ + assert(!I16); + c2->Irm = modregxrm(2,s->Sreglsw,4); + c2->Isib = modregrm(0,4,SP); + c2->IEVpointer1 += EBPtoESP; + } + if (sz > REGSIZE) + { + code *c3 = genc1(CNIL,0x8B, + modregxrm(2,s->Sregmsw,BPRM),FLconst,Poff + s->Soffset + REGSIZE); + if (I64) + c3->Irex |= REX_W; + if (!hasframe) + { /* Convert to ESP relative address rather than EBP */ + assert(!I16); + c3->Irm = modregxrm(2,s->Sregmsw,4); + c3->Isib = modregrm(0,4,SP); + c3->IEVpointer1 += EBPtoESP; + } + c2 = cat(c2,c3); + } + c = cat(c,c2); + } + } + else if (s->Sclass == SCfastpar) + { // Argument is passed in a register + unsigned preg = s->Spreg; + + namedargs |= mask[preg]; + + if (s->Sfl == FLreg) + { // MOV reg,preg + if (mask[preg] & XMMREGS) + { + unsigned op = xmmload(s->Stype->Tty); // MOVSS/D xreg,preg + unsigned xreg = s->Sreglsw - XMM0; + c = gen2(c,op,modregxrmx(3,xreg,preg - XMM0)); + } + else + { + c = genmovreg(c,s->Sreglsw,preg); + if (I64 && sz == 8) + code_orrex(c, REX_W); + } + } + else if (s->Sflags & SFLdead || + (!anyiasm && !(s->Sflags & SFLread) && s->Sflags & SFLunambig && +#if MARS + // This variable has been reference by a nested function + !(s->Stype->Tty & mTYvolatile) && +#endif + (config.flags4 & CFG4optimized || !config.fulltypes))) + { + // Ignore it, as it is never referenced + ; + } + else + { + targ_size_t offset = Aoff + BPoff + s->Soffset; + int op = 0x89; // MOV x[EBP],preg + if (preg >= XMM0 && preg <= XMM15) + { + op = xmmstore(s->Stype->Tty); + } + if (hasframe) + { + if (!(pushalloc && preg == pushallocreg)) + { + // MOV x[EBP],preg + c2 = genc1(CNIL,op, + modregxrm(2,preg,BPRM),FLconst, offset); + if (preg >= XMM0 && preg <= XMM15) + { + } + else + { +//printf("%s Aoff = %d, BPoff = %d, Soffset = %d, sz = %d\n", s->Sident, (int)Aoff, (int)BPoff, (int)s->Soffset, (int)sz); +// if (offset & 2) +// c2->Iflags |= CFopsize; + if (I64 && sz == 8) + code_orrex(c2, REX_W); + } + c = cat(c, c2); + } + } + else + { + offset += EBPtoESP; + if (!(pushalloc && preg == pushallocreg)) + { + // MOV offset[ESP],preg + // BUG: byte size? + c2 = genc1(CNIL,op, + (modregrm(0,4,SP) << 8) | + modregxrm(2,preg,4),FLconst,offset); + if (preg >= XMM0 && preg <= XMM15) + { + } + else + { + if (I64 && sz == 8) + c2->Irex |= REX_W; +// if (offset & 2) +// c2->Iflags |= CFopsize; + } + c = cat(c,c2); + } + } + } + } + } + + /* Load arguments passed in registers into the varargs save area + * so they can be accessed by va_arg(). + */ + if (I64 && variadic(funcsym_p->Stype)) + { + /* Look for __va_argsave + */ + symbol *sv = NULL; + for (SYMIDX si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + if (s->Sident[0] == '_' && strcmp(s->Sident, "__va_argsave") == 0) + { sv = s; + break; + } + } + + if (sv && !(sv->Sflags & SFLdead)) + { + /* Generate code to move any arguments passed in registers into + * the stack variable __va_argsave, + * so we can reference it via pointers through va_arg(). + * struct __va_argsave_t { + * size_t[6] regs; + * real[8] fpregs; + * uint offset_regs; + * uint offset_fpregs; + * void* stack_args; + * void* reg_args; + * } + * The MOVAPS instructions seg fault if data is not aligned on + * 16 bytes, so this gives us a nice check to ensure no mistakes. + MOV voff+0*8[RBP],EDI + MOV voff+1*8[RBP],ESI + MOV voff+2*8[RBP],RDX + MOV voff+3*8[RBP],RCX + MOV voff+4*8[RBP],R8 + MOV voff+5*8[RBP],R9 + MOVZX EAX,AL // AL = 0..8, # of XMM registers used + SHL EAX,2 // 4 bytes for each MOVAPS + LEA RDX,offset L2[RIP] + SUB RDX,RAX + LEA RAX,voff+6*8+0x7F[RBP] + JMP EDX + MOVAPS -0x0F[RAX],XMM7 // only save XMM registers if actually used + MOVAPS -0x1F[RAX],XMM6 + MOVAPS -0x2F[RAX],XMM5 + MOVAPS -0x3F[RAX],XMM4 + MOVAPS -0x4F[RAX],XMM3 + MOVAPS -0x5F[RAX],XMM2 + MOVAPS -0x6F[RAX],XMM1 + MOVAPS -0x7F[RAX],XMM0 + L2: + MOV 1[RAX],offset_regs // set __va_argsave.offset_regs + MOV 5[RAX],offset_fpregs // set __va_argsave.offset_fpregs + LEA RDX, Poff+Poffset[RBP] + MOV 9[RAX],RDX // set __va_argsave.stack_args + SUB RAX,6*8+0x7F // point to start of __va_argsave + MOV 6*8+8*16+4+4+8[RAX],RAX // set __va_argsave.reg_args + */ + targ_size_t voff = Aoff + BPoff + sv->Soffset; // EBP offset of start of sv + const int vregnum = 6; + const unsigned vsize = vregnum * 8 + 8 * 16; + code *cv = CNIL; + + static unsigned char regs[vregnum] = { DI,SI,DX,CX,R8,R9 }; + + if (!hasframe) + voff += EBPtoESP; + for (int i = 0; i < vregnum; i++) + { + unsigned r = regs[i]; + if (!(mask[r] & namedargs)) // named args are already dealt with + { unsigned ea = (REX_W << 16) | modregxrm(2,r,BPRM); + if (!hasframe) + ea = (REX_W << 16) | (modregrm(0,4,SP) << 8) | modregxrm(2,r,4); + cv = genc1(cv,0x89,ea,FLconst,voff + i*8); + } + } + + cv = genregs(cv,0x0FB6,AX,AX); // MOVZX EAX,AL + genc2(cv,0xC1,modregrm(3,4,AX),2); // SHL EAX,2 + int raxoff = voff+6*8+0x7F; + unsigned L2offset = (raxoff < -0x7F) ? 0x2C : 0x29; + if (!hasframe) + L2offset += 1; // +1 for sib byte + // LEA RDX,offset L2[RIP] + genc1(cv,0x8D,(REX_W << 16) | modregrm(0,DX,5),FLconst,L2offset); + genregs(cv,0x29,AX,DX); // SUB RDX,RAX + code_orrex(cv, REX_W); + // LEA RAX,voff+vsize-6*8-16+0x7F[RBP] + unsigned ea = (REX_W << 16) | modregrm(2,AX,BPRM); + if (!hasframe) + // add sib byte for [RSP] addressing + ea = (REX_W << 16) | (modregrm(0,4,SP) << 8) | modregxrm(2,AX,4); + genc1(cv,0x8D,ea,FLconst,raxoff); + gen2(cv,0xFF,modregrm(3,4,DX)); // JMP EDX + for (int i = 0; i < 8; i++) + { + // MOVAPS -15-16*i[RAX],XMM7-i + genc1(cv,0x0F29,modregrm(0,XMM7-i,0),FLconst,-15-16*i); + } + + /* Compute offset_regs and offset_fpregs + */ + unsigned offset_regs = 0; + unsigned offset_fpregs = vregnum * 8; + for (int i = AX; i <= XMM7; i++) + { regm_t m = mask[i]; + if (m & namedargs) + { + if (m & (mDI|mSI|mDX|mCX|mR8|mR9)) + offset_regs += 8; + else if (m & XMMREGS) + offset_fpregs += 16; + namedargs &= ~m; + if (!namedargs) + break; + } + } + // MOV 1[RAX],offset_regs + genc(cv,0xC7,modregrm(2,0,AX),FLconst,1,FLconst,offset_regs); + + // MOV 5[RAX],offset_fpregs + genc(cv,0xC7,modregrm(2,0,AX),FLconst,5,FLconst,offset_fpregs); + + // LEA RDX, Poff+Poffset[RBP] + ea = modregrm(2,DX,BPRM); + if (!hasframe) + ea = (modregrm(0,4,SP) << 8) | modregrm(2,DX,4); + Poffset = (Poffset + (REGSIZE - 1)) & ~(REGSIZE - 1); + genc1(cv,0x8D,(REX_W << 16) | ea,FLconst,Poff + Poffset); + + // MOV 9[RAX],RDX + genc1(cv,0x89,(REX_W << 16) | modregrm(2,DX,AX),FLconst,9); + + // SUB RAX,6*8+0x7F // point to start of __va_argsave + genc2(cv,0x2D,0,6*8+0x7F); + code_orrex(cv, REX_W); + + // MOV 6*8+8*16+4+4+8[RAX],RAX // set __va_argsave.reg_args + genc1(cv,0x89,(REX_W << 16) | modregrm(2,AX,AX),FLconst,6*8+8*16+4+4+8); + + pinholeopt(cv, NULL); + useregs(mDX|mAX); + c = cat(c,cv); + } + } + +#if 0 && TARGET_LINUX + if (gotref) + { // position independent reference + c = cat(c, cod3_load_got()); + } +#endif + + return c; +} + +/******************************* + * Generate and return function epilog. + * Output: + * retsize Size of function epilog + */ + +static targ_size_t spoff; + +void epilog(block *b) +{ code *c; + code *cr; + code *ce; + code *cpopds; + unsigned reg; + unsigned regx; // register that's not a return reg + regm_t topop,regm; + tym_t tyf,tym; + int op; + char farfunc; + targ_size_t xlocalsize = localsize; + + c = CNIL; + ce = b->Bcode; + tyf = funcsym_p->ty(); + tym = tybasic(tyf); + farfunc = tyfarfunc(tym); + if (!(b->Bflags & BFLepilog)) // if no epilog code + goto Lret; // just generate RET + regx = (b->BC == BCret) ? AX : CX; + + spoff = 0; + retsize = 0; + + if (tyf & mTYnaked) // if no prolog/epilog + return; + + if (tym == TYifunc) + { static unsigned char ops2[] = { 0x07,0x1F,0x61,0xCF,0 }; + static unsigned char ops0[] = { 0x07,0x1F,0x5F,0x5E, + 0x5D,0x5B,0x5B,0x5A, + 0x59,0x58,0xCF,0 }; + unsigned char *p; + + c = genregs(c,0x8B,SP,BP); // MOV SP,BP + p = (config.target_cpu >= TARGET_80286) ? ops2 : ops0; + do + gen1(c,*p); + while (*++p); + goto Lopt; + } + + if (config.flags & CFGtrace && + (!(config.flags4 & CFG4allcomdat) || + funcsym_p->Sclass == SCcomdat || + funcsym_p->Sclass == SCglobal || + (config.flags2 & CFG2comdat && SymInline(funcsym_p)) + ) + ) + { + symbol *s = rtlsym[farfunc ? RTLSYM_TRACE_EPI_F : RTLSYM_TRACE_EPI_N]; + makeitextern(s); + c = gencs(c,I16 ? 0x9A : CALL,0,FLfunc,s); // CALLF _trace + if (!I16) + code_orflag(c,CFoff | CFselfrel); + useregs((ALLREGS | mBP | mES) & ~s->Sregsaved); + } + + if (usednteh & ~NTEHjmonitor && (config.exe == EX_NT || MARS)) + c = cat(c,nteh_epilog()); + + cpopds = CNIL; + if (tyf & mTYloadds) + { cpopds = gen1(cpopds,0x1F); // POP DS + c = cat(c,cpopds); + spoff += intsize; + } + + /* Pop all the general purpose registers saved on the stack + * by the prolog code. Remember to do them in the reverse + * order they were pushed. + */ + reg = I64 ? R15 : DI; + regm = 1 << reg; + topop = fregsaved & ~mfuncreg; +#ifdef DEBUG + if (topop & ~0xFFFF) + printf("fregsaved = x%x, mfuncreg = x%x\n",fregsaved,mfuncreg); +#endif + assert(!(topop & ~0xFFFF)); + while (topop) + { if (topop & regm) + { c = gen1(c,0x58 + (reg & 7)); // POP reg + if (reg & 8) + code_orrex(c, REX_B); + topop &= ~regm; + spoff += REGSIZE; + } + regm >>= 1; + reg--; + } + +#if MARS + if (usednteh & NTEHjmonitor) + { + regm_t retregs = 0; + if (b->BC == BCretexp) + retregs = regmask(b->Belem->Ety, tym); + code *cn = nteh_monitor_epilog(retregs); + c = cat(c,cn); + xlocalsize += 8; + } +#endif + + if (config.wflags & WFwindows && farfunc) + { + int wflags = config.wflags; + if (wflags & WFreduced && !(tyf & mTYexport)) + { // reduced prolog/epilog for non-exported functions + wflags &= ~(WFdgroup | WFds | WFss); + if (!(wflags & WFsaveds)) + goto L4; + } + + if (localsize | usedalloca) + { + c = genc1(c,0x8D,modregrm(1,SP,6),FLconst,(targ_uns)-2); /* LEA SP,-2[BP] */ + } + if (wflags & (WFsaveds | WFds | WFss | WFdgroup)) + { if (cpopds) + cpopds->Iop = NOP; // don't need previous one + c = gen1(c,0x1F); // POP DS + } + c = gen1(c,0x58 + BP); // POP BP + if (config.wflags & WFincbp) + gen1(c,0x48 + BP); // DEC BP + assert(hasframe); + } + else + { + if (needframe || (xlocalsize && hasframe)) + { + L4: + assert(hasframe); + if (xlocalsize | usedalloca) + { if (config.target_cpu >= TARGET_80286 && + !(config.target_cpu >= TARGET_80386 && + config.flags4 & CFG4speed) + ) + c = gen1(c,0xC9); // LEAVE + else if (0 && xlocalsize == REGSIZE && !usedalloca && I32) + { // This doesn't work - I should figure out why + mfuncreg &= ~mask[regx]; + c = gen1(c,0x58 + regx); // POP regx + c = gen1(c,0x58 + BP); // POP BP + } + else + { c = genregs(c,0x8B,SP,BP); // MOV SP,BP + if (I64) + code_orrex(c, REX_W); // MOV RSP,RBP + c = gen1(c,0x58 + BP); // POP BP + } + } + else + c = gen1(c,0x58 + BP); // POP BP + if (config.wflags & WFincbp && farfunc) + gen1(c,0x48 + BP); // DEC BP + } + else if (xlocalsize == REGSIZE && (!I16 || b->BC == BCret)) + { mfuncreg &= ~mask[regx]; + c = gen1(c,0x58 + regx); // POP regx + } + else if (xlocalsize) + { + c = genc2(c,0x81,modregrm(3,0,SP),xlocalsize); // ADD SP,xlocalsize + if (I64) + code_orrex(c, REX_W); + } + } + if (b->BC == BCret || b->BC == BCretexp) + { +Lret: + op = tyfarfunc(tym) ? 0xCA : 0xC2; + if (tym == TYhfunc) + { + c = genc2(c,0xC2,0,4); // RET 4 + } + else if (!typfunc(tym) || // if caller cleans the stack + Poffset == 0) // or nothing pushed on the stack anyway + { op++; // to a regular RET + c = gen1(c,op); + } + else + { // Stack is always aligned on register size boundary + Poffset = (Poffset + (REGSIZE - 1)) & ~(REGSIZE - 1); + c = genc2(c,op,0,Poffset); // RET Poffset + } + } + +Lopt: + // If last instruction in ce is ADD SP,imm, and first instruction + // in c sets SP, we can dump the ADD. + cr = code_last(ce); + if (cr && c && !I64) + { + if (cr->Iop == 0x81 && cr->Irm == modregrm(3,0,SP)) // if ADD SP,imm + { + if ( + c->Iop == 0xC9 || // LEAVE + (c->Iop == 0x8B && c->Irm == modregrm(3,SP,BP)) || // MOV SP,BP + (c->Iop == 0x8D && c->Irm == modregrm(1,SP,6)) // LEA SP,-imm[BP] + ) + cr->Iop = NOP; + else if (c->Iop == 0x58 + BP) // if POP BP + { cr->Iop = 0x8B; + cr->Irm = modregrm(3,SP,BP); // MOV SP,BP + } + } +#if 0 // These optimizations don't work if the called function + // cleans off the stack. + else if (c->Iop == 0xC3 && cr->Iop == CALL) // CALL near + { cr->Iop = 0xE9; // JMP near + c->Iop = NOP; + } + else if (c->Iop == 0xCB && cr->Iop == 0x9A) // CALL far + { cr->Iop = 0xEA; // JMP far + c->Iop = NOP; + } +#endif + } + + retsize += calcblksize(c); // compute size of function epilog + b->Bcode = cat(ce,c); +} + +/******************************* + * Return offset of SP from BP. + */ + +targ_size_t cod3_spoff() +{ + return spoff + localsize; +} + +/********************************** + * Load value of _GLOBAL_OFFSET_TABLE_ into EBX + */ + +code *cod3_load_got() +{ +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + code *c; + code *cgot; + + c = genc2(NULL,CALL,0,0); // CALL L1 + gen1(c, 0x58 + BX); // L1: POP EBX + + // ADD EBX,_GLOBAL_OFFSET_TABLE_+3 + symbol *gotsym = elfobj_getGOTsym(); + cgot = gencs(CNIL,0x81,0xC3,FLextern,gotsym); + cgot->Iflags = CFoff; + cgot->IEVoffset2 = 3; + + makeitextern(gotsym); + return cat(c,cgot); +#else + assert(0); + return NULL; +#endif +} + +code* gen_spill_reg(Symbol* s, bool toreg) +{ + code *c; + code cs; + regm_t keepmsk = toreg ? RMload : RMstore; + int sz = type_size(s->Stype); + + elem* e = el_var(s); // so we can trick getlvalue() into working for us + + if (mask[s->Sreglsw] & XMMREGS) + { // Convert to save/restore of XMM register + if (toreg) + cs.Iop = xmmload(s->Stype->Tty); // MOVSS/D xreg,mem + else + cs.Iop = xmmstore(s->Stype->Tty); // MOVSS/D mem,xreg + c = getlvalue(&cs,e,keepmsk); + cs.orReg(s->Sreglsw - XMM0); + c = gen(c,&cs); + } + else + { + cs.Iop = toreg ? 0x8B : 0x89; // MOV reg,mem[ESP] : MOV mem[ESP],reg + cs.Iop ^= (sz == 1); + c = getlvalue(&cs,e,keepmsk); + cs.orReg(s->Sreglsw); + if (I64 && sz == 1 && s->Sreglsw >= 4) + cs.Irex |= REX; + c = gen(c,&cs); + if (sz > REGSIZE) + { + cs.setReg(s->Sregmsw); + getlvalue_msw(&cs); + c = gen(c,&cs); + } + } + + el_free(e); + + return c; +} + +/**************************** + * Generate code for, and output a thunk. + * Input: + * thisty Type of this pointer + * p ESP parameter offset to this pointer + * d offset to add to 'this' pointer + * d2 offset from 'this' to vptr + * i offset into vtbl[] + */ + +void cod3_thunk(symbol *sthunk,symbol *sfunc,unsigned p,tym_t thisty, + targ_size_t d,int i,targ_size_t d2) +{ code *c,*c1; + targ_size_t thunkoffset; + tym_t thunkty; + + cod3_align(); + + /* Skip over return address */ + thunkty = tybasic(sthunk->ty()); +#if TARGET_SEGMENTED + if (tyfarfunc(thunkty)) + p += I32 ? 8 : tysize[TYfptr]; /* far function */ + else +#endif + p += tysize[TYnptr]; + + if (!I16) + { + /* + Generate: + ADD p[ESP],d + For direct call: + JMP sfunc + For virtual call: + MOV EAX, p[ESP] EAX = this + MOV EAX, d2[EAX] EAX = this->vptr + JMP i[EAX] jump to virtual function + */ + unsigned reg = 0; + if ((targ_ptrdiff_t)d < 0) + { + d = -d; + reg = 5; // switch from ADD to SUB + } + if (thunkty == TYmfunc) + { // ADD ECX,d + c = CNIL; + if (d) + c = genc2(c,0x81,modregrm(3,reg,CX),d); + } + else if (thunkty == TYjfunc || (I64 && thunkty == TYnfunc)) + { // ADD EAX,d + c = CNIL; + if (d) + c = genc2(c,0x81,modregrm(3,reg,I64 ? DI : AX),d); + } + else + { + c = genc(CNIL,0x81,modregrm(2,reg,4), + FLconst,p, // to this + FLconst,d); // ADD p[ESP],d + c->Isib = modregrm(0,4,SP); + } + if (I64 && c) + c->Irex |= REX_W; + } + else + { + /* + Generate: + MOV BX,SP + ADD [SS:] p[BX],d + For direct call: + JMP sfunc + For virtual call: + MOV BX, p[BX] BX = this + MOV BX, d2[BX] BX = this->vptr + JMP i[BX] jump to virtual function + */ + + + c = genregs(CNIL,0x89,SP,BX); /* MOV BX,SP */ + c1 = genc(CNIL,0x81,modregrm(2,0,7), + FLconst,p, /* to this */ + FLconst,d); /* ADD p[BX],d */ + if (config.wflags & WFssneds || + // If DS needs reloading from SS, + // then assume SS != DS on thunk entry + (config.wflags & WFss && LARGEDATA)) + c1->Iflags |= CFss; /* SS: */ + c = cat(c,c1); + } + + if ((i & 0xFFFF) != 0xFFFF) /* if virtual call */ + { code *c2,*c3; + +#define FARTHIS (tysize(thisty) > REGSIZE) +#define FARVPTR FARTHIS + +#if TARGET_SEGMENTED + assert(thisty != TYvptr); /* can't handle this case */ +#endif + + if (!I16) + { + assert(!FARTHIS && !LARGECODE); + if (thunkty == TYmfunc) // if 'this' is in ECX + { c1 = CNIL; + + // MOV EAX,d2[ECX] + c2 = genc1(CNIL,0x8B,modregrm(2,AX,CX),FLconst,d2); + } + else if (thunkty == TYjfunc) // if 'this' is in EAX + { c1 = CNIL; + + // MOV EAX,d2[EAX] + c2 = genc1(CNIL,0x8B,modregrm(2,AX,AX),FLconst,d2); + } + else + { + // MOV EAX,p[ESP] + c1 = genc1(CNIL,0x8B,(modregrm(0,4,SP) << 8) | modregrm(2,AX,4),FLconst,(targ_uns) p); + if (I64) + c1->Irex |= REX_W; + + // MOV EAX,d2[EAX] + c2 = genc1(CNIL,0x8B,modregrm(2,AX,AX),FLconst,d2); + } + if (I64) + code_orrex(c2, REX_W); + /* JMP i[EAX] */ + c3 = genc1(CNIL,0xFF,modregrm(2,4,0),FLconst,(targ_uns) i); + } + else + { + /* MOV/LES BX,[SS:] p[BX] */ + c1 = genc1(CNIL,(FARTHIS ? 0xC4 : 0x8B),modregrm(2,BX,7),FLconst,(targ_uns) p); + if (config.wflags & WFssneds || + // If DS needs reloading from SS, + // then assume SS != DS on thunk entry + (config.wflags & WFss && LARGEDATA)) + c1->Iflags |= CFss; /* SS: */ + + /* MOV/LES BX,[ES:]d2[BX] */ + c2 = genc1(CNIL,(FARVPTR ? 0xC4 : 0x8B),modregrm(2,BX,7),FLconst,d2); + if (FARTHIS) + c2->Iflags |= CFes; /* ES: */ + + /* JMP i[BX] */ + c3 = genc1(CNIL,0xFF,modregrm(2,(LARGECODE ? 5 : 4),7),FLconst,(targ_uns) i); + if (FARVPTR) + c3->Iflags |= CFes; /* ES: */ + } + c = cat4(c,c1,c2,c3); + } + else + { + c1 = gencs(CNIL,(LARGECODE ? 0xEA : 0xE9),0,FLfunc,sfunc); /* JMP sfunc */ + c1->Iflags |= LARGECODE ? (CFseg | CFoff) : (CFselfrel | CFoff); + c = cat(c,c1); + } + + thunkoffset = Coffset; + pinholeopt(c,NULL); + codout(c); + code_free(c); + + sthunk->Soffset = thunkoffset; + sthunk->Ssize = Coffset - thunkoffset; /* size of thunk */ + sthunk->Sseg = cseg; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + objpubdef(cseg,sthunk,sthunk->Soffset); +#endif + searchfixlist(sthunk); /* resolve forward refs */ +} + +/***************************** + * Assume symbol s is extern. + */ + +void makeitextern(symbol *s) +{ + if (s->Sxtrnnum == 0) + { s->Sclass = SCextern; /* external */ + /*printf("makeitextern(x%x)\n",s);*/ + objextern(s); + } +} + + +/******************************* + * Replace JMPs in Bgotocode with JMP SHORTs whereever possible. + * This routine depends on FLcode jumps to only be forward + * referenced. + * BFLjmpoptdone is set to TRUE if nothing more can be done + * with this block. + * Input: + * flag !=0 means don't have correct Boffsets yet + * Returns: + * number of bytes saved + */ + +int branch(block *bl,int flag) +{ int bytesaved; + code *c,*cn,*ct; + targ_size_t offset,disp; + targ_size_t csize; + + if (!flag) + bl->Bflags |= BFLjmpoptdone; // assume this will be all + c = bl->Bcode; + if (!c) + return 0; + bytesaved = 0; + offset = bl->Boffset; /* offset of start of block */ + while (1) + { unsigned char op; + + csize = calccodsize(c); + cn = code_next(c); + op = c->Iop; + if ((op & ~0x0F) == 0x70 && c->Iflags & CFjmp16 || + op == JMP) + { + L1: + switch (c->IFL2) + { + case FLblock: + if (flag) // no offsets yet, don't optimize + goto L3; + disp = c->IEV2.Vblock->Boffset - offset - csize; + + /* If this is a forward branch, and there is an aligned + * block intervening, it is possible that shrinking + * the jump instruction will cause it to be out of + * range of the target. This happens if the alignment + * prevents the target block from moving correspondingly + * closer. + */ + if (disp >= 0x7F-4 && c->IEV2.Vblock->Boffset > offset) + { /* Look for intervening alignment + */ + for (block *b = bl->Bnext; b; b = b->Bnext) + { + if (b->Balign) + { + bl->Bflags &= ~BFLjmpoptdone; // some JMPs left + goto L3; + } + if (b == c->IEV2.Vblock) + break; + } + } + + break; + + case FLcode: + { code *cr; + + disp = 0; + + ct = c->IEV2.Vcode; /* target of branch */ + assert(ct->Iflags & (CFtarg | CFtarg2)); + for (cr = cn; cr; cr = code_next(cr)) + { + if (cr == ct) + break; + disp += calccodsize(cr); + } + + if (!cr) + { // Didn't find it in forward search. Try backwards jump + int s = 0; + disp = 0; + for (cr = bl->Bcode; cr != cn; cr = code_next(cr)) + { + assert(cr != NULL); // must have found it + if (cr == ct) + s = 1; + if (s) + disp += calccodsize(cr); + } + } + + if (config.flags4 & CFG4optimized && !flag) + { + /* Propagate branch forward past junk */ + while (1) + { if (ct->Iop == NOP || + ct->Iop == (ESCAPE | ESClinnum)) + { ct = code_next(ct); + if (!ct) + goto L2; + } + else + { c->IEV2.Vcode = ct; + ct->Iflags |= CFtarg; + break; + } + } + + /* And eliminate jmps to jmps */ + if ((op == ct->Iop || ct->Iop == JMP) && + (op == JMP || c->Iflags & CFjmp16)) + { c->IFL2 = ct->IFL2; + c->IEV2.Vcode = ct->IEV2.Vcode; + /*printf("eliminating branch\n");*/ + goto L1; + } + L2: ; + } + } + break; + + default: + goto L3; + } + + if (disp == 0) // bra to next instruction + { bytesaved += csize; + c->Iop = NOP; // del branch instruction + c->IEV2.Vcode = NULL; + c = cn; + if (!c) + break; + continue; + } + else if ((targ_size_t)(targ_schar)(disp - 2) == (disp - 2) && + (targ_size_t)(targ_schar)disp == disp) + { + if (op == JMP) + { c->Iop = JMPS; // JMP SHORT + bytesaved += I16 ? 1 : 3; + } + else // else Jcond + { c->Iflags &= ~CFjmp16; // a branch is ok + bytesaved += I16 ? 3 : 4; + + // Replace a cond jump around a call to a function that + // never returns with a cond jump to that function. + if (config.flags4 & CFG4optimized && + config.target_cpu >= TARGET_80386 && + disp == (I16 ? 3 : 5) && + cn && + cn->Iop == CALL && + cn->IFL2 == FLfunc && + cn->IEVsym2->Sflags & SFLexit && + !(cn->Iflags & (CFtarg | CFtarg2)) + ) + { + cn->Iop = 0x0F00 | ((c->Iop & 0x0F) ^ 0x81); + c->Iop = NOP; + c->IEV2.Vcode = NULL; + bytesaved++; + + // If nobody else points to ct, we can remove the CFtarg + if (flag && ct) + { code *cx; + + for (cx = bl->Bcode; 1; cx = code_next(cx)) + { + if (!cx) + { ct->Iflags &= ~CFtarg; + break; + } + if (cx->IEV2.Vcode == ct) + break; + } + } + } + } + csize = calccodsize(c); + } + else + bl->Bflags &= ~BFLjmpoptdone; // some JMPs left + } +L3: + if (cn) + { offset += csize; + c = cn; + } + else + break; + } + //printf("bytesaved = x%x\n",bytesaved); + return bytesaved; +} + +/************************************************ + * Adjust all Soffset's of stack variables so they + * are all relative to the frame pointer. + */ + +#if MARS + +void cod3_adjSymOffsets() +{ SYMIDX si; + + //printf("cod3_adjSymOffsets()\n"); + for (si = 0; si < globsym.top; si++) + { //printf("globsym.tab[%d] = %p\n",si,globsym.tab[si]); + symbol *s = globsym.tab[si]; + + switch (s->Sclass) + { + case SCparameter: + case SCregpar: +//printf("s = '%s', Soffset = x%x, Poff = x%x, EBPtoESP = x%x\n", s->Sident, s->Soffset, Poff, EBPtoESP); + s->Soffset += Poff; +if (0 && !(funcsym_p->Sfunc->Fflags3 & Fmember)) +{ + if (!hasframe) + s->Soffset += EBPtoESP; + if (funcsym_p->Sfunc->Fflags3 & Fnested) + s->Soffset += REGSIZE; +} + break; + case SCauto: + case SCfastpar: + case SCregister: + case_auto: +//printf("s = '%s', Soffset = x%x, Aoff = x%x, BPoff = x%x EBPtoESP = x%x\n", s->Sident, s->Soffset, Aoff, BPoff, EBPtoESP); +// if (!(funcsym_p->Sfunc->Fflags3 & Fnested)) + s->Soffset += Aoff + BPoff; + break; + case SCbprel: + break; + default: + continue; + } +#if 0 + if (!hasframe) + s->Soffset += EBPtoESP; +#endif + } +} + +#endif + +/******************************* + * Take symbol info in union ev and replace it with a real address + * in Vpointer. + */ + +void assignaddr(block *bl) +{ + int EBPtoESPsave = EBPtoESP; + int hasframesave = hasframe; + + if (bl->Bflags & BFLoutsideprolog) + { EBPtoESP = -REGSIZE; + hasframe = 0; + } + assignaddrc(bl->Bcode); + hasframe = hasframesave; + EBPtoESP = EBPtoESPsave; +} + +void assignaddrc(code *c) +{ + int sn; + symbol *s; + unsigned char ins,rm; + targ_size_t soff; + targ_size_t base; + + base = EBPtoESP; + for (; c; c = code_next(c)) + { +#ifdef DEBUG + if (0) + { printf("assignaddrc()\n"); + c->print(); + } + if (code_next(c) && code_next(code_next(c)) == c) + assert(0); +#endif + if (c->Iflags & CFvex) + ins = vex_inssize(c); + else if ((c->Iop & 0xFFFD00) == 0x0F3800) + ins = inssize2[(c->Iop >> 8) & 0xFF]; + else if ((c->Iop & 0xFF00) == 0x0F00) + ins = inssize2[c->Iop & 0xFF]; + else if ((c->Iop & 0xFF) == ESCAPE) + { + if (c->Iop == (ESCAPE | ESCadjesp)) + { + //printf("adjusting EBPtoESP (%d) by %ld\n",EBPtoESP,c->IEV2.Vint); + EBPtoESP += c->IEV1.Vint; + c->Iop = NOP; + } + if (c->Iop == (ESCAPE | ESCframeptr)) + { // Convert to load of frame pointer + // c->Irm is the register to use + if (hasframe) + { // MOV reg,EBP + c->Iop = 0x89; + if (c->Irm & 8) + c->Irex |= REX_B; + c->Irm = modregrm(3,BP,c->Irm & 7); + } + else + { // LEA reg,EBPtoESP[ESP] + c->Iop = 0x8D; + if (c->Irm & 8) + c->Irex |= REX_R; + c->Irm = modregrm(2,c->Irm & 7,4); + c->Isib = modregrm(0,4,SP); + c->Iflags = CFoff; + c->IFL1 = FLconst; + c->IEV1.Vuns = EBPtoESP; + } + } + if (I64) + c->Irex |= REX_W; + continue; + } + else + ins = inssize[c->Iop & 0xFF]; + if (!(ins & M) || + ((rm = c->Irm) & 0xC0) == 0xC0) + goto do2; /* if no first operand */ + if (is32bitaddr(I32,c->Iflags)) + { + + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 4 && (c->Isib & 7) == 5 || (rm & 7) == 5)) + ) + goto do2; /* if no first operand */ + } + else + { + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 6)) + ) + goto do2; /* if no first operand */ + } + s = c->IEVsym1; + switch (c->IFL1) + { +#if OMFOBJ + case FLdata: + if (s->Sclass == SCcomdat) + { c->IFL1 = FLextern; + goto do2; + } +#if MARS + c->IEVseg1 = s->Sseg; +#else + c->IEVseg1 = DATA; +#endif + c->IEVpointer1 += s->Soffset; + c->IFL1 = FLdatseg; + goto do2; + case FLudata: +#if MARS + c->IEVseg1 = s->Sseg; +#else + c->IEVseg1 = UDATA; +#endif + c->IEVpointer1 += s->Soffset; + c->IFL1 = FLdatseg; + goto do2; +#else // don't loose symbol information + case FLdata: + case FLudata: + case FLtlsdata: + c->IFL1 = FLextern; + goto do2; +#endif + case FLdatseg: + c->IEVseg1 = DATA; + goto do2; + +#if TARGET_SEGMENTED + case FLfardata: + case FLcsdata: +#endif + case FLpseudo: + goto do2; + + case FLstack: + //printf("Soffset = %d, EBPtoESP = %d, base = %d, pointer = %d\n", + //s->Soffset,EBPtoESP,base,c->IEVpointer1); + c->IEVpointer1 += s->Soffset + EBPtoESP - base - EEoffset; + break; + + case FLreg: + case FLauto: + soff = Aoff; + L1: + if (s->Sflags & SFLunambig && !(s->Sflags & SFLread) && // if never loaded + !anyiasm && + // if not optimized, leave it in for debuggability + (config.flags4 & CFG4optimized || !config.fulltypes)) + { c->Iop = NOP; // remove references to it + continue; + } + if (s->Sfl == FLreg && c->IEVpointer1 < 2) + { int reg = s->Sreglsw; + + assert(!(s->Sregm & ~mask[reg])); + if (c->IEVpointer1 == 1) + { assert(reg < 4); /* must be a BYTEREGS */ + reg |= 4; /* convert to high byte reg */ + } + if (reg & 8) + { assert(I64); + c->Irex |= REX_B; + reg &= 7; + } + c->Irm = (c->Irm & modregrm(0,7,0)) + | modregrm(3,0,reg); + assert(c->Iop != LES && c->Iop != LEA); + goto do2; + } + else + { c->IEVpointer1 += s->Soffset + soff + BPoff; + if (s->Sflags & SFLunambig) + c->Iflags |= CFunambig; + L2: + if (!hasframe) + { /* Convert to ESP relative address instead of EBP */ + unsigned char rm; + + assert(!I16); + c->IEVpointer1 += EBPtoESP; + rm = c->Irm; + if ((rm & 7) == 4) // if SIB byte + { + assert((c->Isib & 7) == BP); + assert((rm & 0xC0) != 0); + c->Isib = (c->Isib & ~7) | modregrm(0,0,SP); + } + else + { + assert((rm & 7) == 5); + c->Irm = (rm & modregrm(0,7,0)) + | modregrm(2,0,4); + c->Isib = modregrm(0,4,SP); + } + } + } + break; + case FLpara: + soff = Poff - BPoff; // cancel out add of BPoff + goto L1; + case FLtmp: + soff = Toff; + goto L1; + case FLfltreg: + c->IEVpointer1 += Foff + BPoff; + c->Iflags |= CFunambig; + goto L2; + case FLallocatmp: + c->IEVpointer1 += AAoff + BPoff; + goto L2; + case FLbprel: + c->IEVpointer1 += s->Soffset; + break; + case FLcs: + sn = c->IEV1.Vuns; + if (!CSE_loaded(sn)) // if never loaded + { c->Iop = NOP; + continue; + } + c->IEVpointer1 = sn * REGSIZE + CSoff + BPoff; + c->Iflags |= CFunambig; + goto L2; + case FLregsave: + sn = c->IEV1.Vuns; + c->IEVpointer1 = sn + regsave.off + BPoff; + c->Iflags |= CFunambig; + goto L2; + case FLndp: +#if MARS + assert(c->IEV1.Vuns < NDP::savetop); +#endif + c->IEVpointer1 = c->IEV1.Vuns * NDPSAVESIZE + NDPoff + BPoff; + c->Iflags |= CFunambig; + goto L2; + case FLoffset: + break; + case FLlocalsize: + c->IEVpointer1 += localsize; + break; + case FLconst: + default: + goto do2; + } + c->IFL1 = FLconst; + do2: + /* Ignore TEST (F6 and F7) opcodes */ + if (!(ins & T)) goto done; /* if no second operand */ + s = c->IEVsym2; + switch (c->IFL2) + { +#if ELFOBJ || MACHOBJ + case FLdata: + case FLudata: + case FLtlsdata: + c->IFL2 = FLextern; + goto do2; +#else + case FLdata: + if (s->Sclass == SCcomdat) + { c->IFL2 = FLextern; + goto do2; + } +#if MARS + c->IEVseg2 = s->Sseg; +#else + c->IEVseg2 = DATA; +#endif + c->IEVpointer2 += s->Soffset; + c->IFL2 = FLdatseg; + goto done; + case FLudata: +#if MARS + c->IEVseg2 = s->Sseg; +#else + c->IEVseg2 = UDATA; +#endif + c->IEVpointer2 += s->Soffset; + c->IFL2 = FLdatseg; + goto done; +#endif + case FLdatseg: + c->IEVseg2 = DATA; + goto done; +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: + goto done; +#endif + case FLreg: + case FLpseudo: + assert(0); + /* NOTREACHED */ + case FLauto: + c->IEVpointer2 += s->Soffset + Aoff + BPoff; + break; + case FLpara: + c->IEVpointer2 += s->Soffset + Poff; + break; + case FLtmp: + c->IEVpointer2 += s->Soffset + Toff + BPoff; + break; + case FLfltreg: + c->IEVpointer2 += Foff + BPoff; + break; + case FLallocatmp: + c->IEVpointer2 += AAoff + BPoff; + break; + case FLbprel: + c->IEVpointer2 += s->Soffset; + break; + + case FLstack: + c->IEVpointer2 += s->Soffset + EBPtoESP - base; + break; + + case FLcs: + case FLndp: + case FLregsave: + assert(0); + /* NOTREACHED */ + + case FLconst: + break; + + case FLlocalsize: + c->IEVpointer2 += localsize; + break; + + default: + goto done; + } + c->IFL2 = FLconst; + done: + ; + } +} + +/******************************* + * Return offset from BP of symbol s. + */ + +targ_size_t cod3_bpoffset(symbol *s) +{ targ_size_t offset; + + symbol_debug(s); + offset = s->Soffset; + switch (s->Sfl) + { + case FLpara: + offset += Poff; + break; + case FLauto: + offset += Aoff + BPoff; + break; + case FLtmp: + offset += Toff + BPoff; + break; + default: +#ifdef DEBUG + WRFL((enum FL)s->Sfl); + symbol_print(s); +#endif + assert(0); + } + assert(hasframe); + return offset; +} + + +/******************************* + * Find shorter versions of the same instructions. + * Does these optimizations: + * replaces jmps to the next instruction with NOPs + * sign extension of modregrm displacement + * sign extension of immediate data (can't do it for OR, AND, XOR + * as the opcodes are not defined) + * short versions for AX EA + * short versions for reg EA + * Input: + * b -> block for code (or NULL) + */ + +void pinholeopt(code *c,block *b) +{ targ_size_t a; + unsigned op,mod; + unsigned char ins; + int usespace; + int useopsize; + int space; + block *bn; + +#ifdef DEBUG + static int tested; if (!tested) { tested++; pinholeopt_unittest(); } +#endif + +#if 0 + code *cstart = c; + if (debugc) + { + printf("+pinholeopt(%p)\n",c); + } +#endif + + if (b) + { bn = b->Bnext; + usespace = (config.flags4 & CFG4space && b->BC != BCasm); + useopsize = (I16 || (config.flags4 & CFG4space && b->BC != BCasm)); + } + else + { bn = NULL; + usespace = (config.flags4 & CFG4space); + useopsize = (I16 || config.flags4 & CFG4space); + } + for (; c; c = code_next(c)) + { + L1: + op = c->Iop; + if (c->Iflags & CFvex) + ins = vex_inssize(c); + else if ((op & 0xFFFD00) == 0x0F3800) + ins = inssize2[(op >> 8) & 0xFF]; + else if ((op & 0xFF00) == 0x0F00) + ins = inssize2[op & 0xFF]; + else + ins = inssize[op & 0xFF]; + if (ins & M) // if modregrm byte + { int shortop = (c->Iflags & CFopsize) ? !I16 : I16; + int local_BPRM = BPRM; + + if (c->Iflags & CFaddrsize) + local_BPRM ^= 5 ^ 6; // toggle between 5 and 6 + + unsigned rm = c->Irm; + unsigned reg = rm & modregrm(0,7,0); // isolate reg field + unsigned ereg = rm & 7; + //printf("c = %p, op = %02x rm = %02x\n", c, op, rm); + + /* If immediate second operand */ + if ((ins & T || + ((op == 0xF6 || op == 0xF7) && (reg < modregrm(0,2,0) || reg > modregrm(0,3,0))) + ) && + c->IFL2 == FLconst) + { + int flags = c->Iflags & CFpsw; /* if want result in flags */ + targ_long u = c->IEV2.Vuns; + if (ins & E) + u = (signed char) u; + else if (shortop) + u = (short) u; + + // Replace CMP reg,0 with TEST reg,reg + if ((op & 0xFE) == 0x80 && // 80 is CMP R8,imm8; 81 is CMP reg,imm + rm >= modregrm(3,7,AX) && + u == 0) + { c->Iop = (op & 1) | 0x84; + c->Irm = modregrm(3,ereg,ereg); + if (c->Irex & REX_B) + c->Irex |= REX_R; + goto L1; + } + + /* Optimize ANDs with an immediate constant */ + if ((op == 0x81 || op == 0x80) && reg == modregrm(0,4,0)) + { + if (rm >= modregrm(3,4,AX)) // AND reg,imm + { + if (u == 0) + { /* Replace with XOR reg,reg */ + c->Iop = 0x30 | (op & 1); + c->Irm = modregrm(3,ereg,ereg); + if (c->Irex & REX_B) + c->Irex |= REX_R; + goto L1; + } + if (u == 0xFFFFFFFF && !flags) + { c->Iop = NOP; + goto L1; + } + } + if (op == 0x81 && !flags) + { // If we can do the operation in one byte + + // If EA is not SI or DI + if ((rm < modregrm(3,4,SP) || I64) && + (config.flags4 & CFG4space || + config.target_cpu < TARGET_PentiumPro) + ) + { + if ((u & 0xFFFFFF00) == 0xFFFFFF00) + goto L2; + else if (rm < modregrm(3,0,0) || (!c->Irex && ereg < 4)) + { if (!shortop) + { if ((u & 0xFFFF00FF) == 0xFFFF00FF) + goto L3; + } + else + { + if ((u & 0xFF) == 0xFF) + goto L3; + } + } + } + if (!shortop && useopsize) + { + if ((u & 0xFFFF0000) == 0xFFFF0000) + { c->Iflags ^= CFopsize; + goto L1; + } + if ((u & 0xFFFF) == 0xFFFF && rm < modregrm(3,4,AX)) + { c->IEVoffset1 += 2; /* address MSW */ + c->IEV2.Vuns >>= 16; + c->Iflags ^= CFopsize; + goto L1; + } + if (rm >= modregrm(3,4,AX)) + { + if (u == 0xFF && (rm <= modregrm(3,4,BX) || I64)) + { c->Iop = 0x0FB6; // MOVZX + c->Irm = modregrm(3,ereg,ereg); + if (c->Irex & REX_B) + c->Irex |= REX_R; + goto L1; + } + if (u == 0xFFFF) + { c->Iop = 0x0FB7; // MOVZX + c->Irm = modregrm(3,ereg,ereg); + if (c->Irex & REX_B) + c->Irex |= REX_R; + goto L1; + } + } + } + } + } + + /* Look for ADD,OR,SUB,XOR with u that we can eliminate */ + if (!flags && + (op == 0x81 || op == 0x80) && + (reg == modregrm(0,0,0) || reg == modregrm(0,1,0) || // ADD,OR + reg == modregrm(0,5,0) || reg == modregrm(0,6,0)) // SUB, XOR + ) + { + if (u == 0) + { + c->Iop = NOP; + goto L1; + } + if (u == ~0 && reg == modregrm(0,6,0)) /* XOR */ + { + c->Iop = 0xF6 | (op & 1); /* NOT */ + c->Irm ^= modregrm(0,6^2,0); + goto L1; + } + if (!shortop && + useopsize && + op == 0x81 && + (u & 0xFFFF0000) == 0 && + (reg == modregrm(0,6,0) || reg == modregrm(0,1,0))) + { c->Iflags ^= CFopsize; + goto L1; + } + } + + /* Look for TEST or OR or XOR with an immediate constant */ + /* that we can replace with a byte operation */ + if (op == 0xF7 && reg == modregrm(0,0,0) || + op == 0x81 && reg == modregrm(0,6,0) && !flags || + op == 0x81 && reg == modregrm(0,1,0)) + { + // See if we can replace a dword with a word + // (avoid for 32 bit instructions, because CFopsize + // is too slow) + if (!shortop && useopsize) + { if ((u & 0xFFFF0000) == 0) + { c->Iflags ^= CFopsize; + goto L1; + } + /* If memory (not register) addressing mode */ + if ((u & 0xFFFF) == 0 && rm < modregrm(3,0,AX)) + { c->IEVoffset1 += 2; /* address MSW */ + c->IEV2.Vuns >>= 16; + c->Iflags ^= CFopsize; + goto L1; + } + } + + // If EA is not SI or DI + if (rm < (modregrm(3,0,SP) | reg) && + (usespace || + config.target_cpu < TARGET_PentiumPro) + ) + { + if ((u & 0xFFFFFF00) == 0) + { + L2: c->Iop--; /* to byte instruction */ + c->Iflags &= ~CFopsize; + goto L1; + } + if (((u & 0xFFFF00FF) == 0 || + (shortop && (u & 0xFF) == 0)) && + (rm < modregrm(3,0,0) || (!c->Irex && ereg < 4))) + { + L3: + c->IEV2.Vuns >>= 8; + if (rm >= (modregrm(3,0,AX) | reg)) + c->Irm |= 4; /* AX->AH, BX->BH, etc. */ + else + c->IEVoffset1 += 1; + goto L2; + } + } +#if 0 + // BUG: which is right? + else if ((u & 0xFFFF0000) == 0) +#else + else if (0 && op == 0xF7 && + rm >= modregrm(3,0,SP) && + (u & 0xFFFF0000) == 0) +#endif + c->Iflags &= ~CFopsize; + } + + // Try to replace TEST reg,-1 with TEST reg,reg + if (op == 0xF6 && rm >= modregrm(3,0,AX) && rm <= modregrm(3,0,7)) // TEST regL,immed8 + { if ((u & 0xFF) == 0xFF) + { + L4: c->Iop = 0x84; // TEST regL,regL + c->Irm = modregrm(3,ereg,ereg); + if (c->Irex & REX_B) + c->Irex |= REX_R; + c->Iflags &= ~CFopsize; + goto L1; + } + } + if (op == 0xF7 && rm >= modregrm(3,0,AX) && rm <= modregrm(3,0,7) && (I64 || ereg < 4)) + { if (u == 0xFF) + goto L4; + if ((u & 0xFFFF) == 0xFF00 && shortop && !c->Irex && ereg < 4) + { ereg |= 4; /* to regH */ + goto L4; + } + } + + /* Look for sign extended immediate data */ + if ((signed char) u == u) + { + if (op == 0x81) + { if (reg != 0x08 && reg != 0x20 && reg != 0x30) + c->Iop = op = 0x83; /* 8 bit sgn ext */ + } + else if (op == 0x69) /* IMUL rw,ew,dw */ + c->Iop = op = 0x6B; /* IMUL rw,ew,db */ + } + + // Look for SHIFT EA,imm8 we can replace with short form + if (u == 1 && ((op & 0xFE) == 0xC0)) + c->Iop |= 0xD0; + + } /* if immediate second operand */ + + /* Look for AX short form */ + if (ins & A) + { if (rm == modregrm(0,AX,local_BPRM) && + !(c->Irex & REX_R) && // and it's AX, not R8 + (op & ~3) == 0x88 && + !I64) + { op = ((op & 3) + 0xA0) ^ 2; + /* 8A-> A0 */ + /* 8B-> A1 */ + /* 88-> A2 */ + /* 89-> A3 */ + c->Iop = op; + c->IFL2 = c->IFL1; + c->IEV2 = c->IEV1; + } + + /* Replace MOV REG1,REG2 with MOV EREG1,EREG2 */ + else if (!I16 && + (op == 0x89 || op == 0x8B) && + (rm & 0xC0) == 0xC0 && + (!b || b->BC != BCasm) + ) + c->Iflags &= ~CFopsize; + + // If rm is AX + else if ((rm & modregrm(3,0,7)) == modregrm(3,0,AX) && !(c->Irex & (REX_R | REX_B))) + { switch (op) + { case 0x80: op = reg | 4; break; + case 0x81: op = reg | 5; break; + case 0x87: op = 0x90 + (reg>>3); break; // XCHG + case 0xF6: + if (reg == 0) + op = 0xA8; /* TEST AL,immed8 */ + break; + case 0xF7: + if (reg == 0) + op = 0xA9; /* TEST AX,immed16 */ + break; + } + c->Iop = op; + } + } + + /* Look for reg short form */ + if ((ins & R) && (rm & 0xC0) == 0xC0) + { switch (op) + { case 0xC6: op = 0xB0 + ereg; break; + case 0xC7: op = 0xB8 + ereg; break; + case 0xFF: + switch (reg) + { case 6<<3: op = 0x50+ereg; break;/* PUSH*/ + case 0<<3: if (!I64) op = 0x40+ereg; break; /* INC*/ + case 1<<3: if (!I64) op = 0x48+ereg; break; /* DEC*/ + } + break; + case 0x8F: op = 0x58 + ereg; break; + case 0x87: + if (reg == 0) op = 0x90 + ereg; + break; + } + c->Iop = op; + } + + // Look to replace SHL reg,1 with ADD reg,reg + if ((op & ~1) == 0xD0 && + (rm & modregrm(3,7,0)) == modregrm(3,4,0) && + config.target_cpu >= TARGET_80486) + { + c->Iop &= 1; + c->Irm = (rm & modregrm(3,0,7)) | (ereg << 3); + if (c->Irex & REX_B) + c->Irex |= REX_R; + if (!(c->Iflags & CFpsw) && !I16) + c->Iflags &= ~CFopsize; + goto L1; + } + + /* Look for sign extended modregrm displacement, or 0 + * displacement. + */ + + if (((rm & 0xC0) == 0x80) && // it's a 16/32 bit disp + c->IFL1 == FLconst) // and it's a constant + { + a = c->IEVpointer1; + if (a == 0 && (rm & 7) != local_BPRM && // if 0[disp] + !(local_BPRM == 5 && (rm & 7) == 4 && (c->Isib & 7) == BP) + ) + c->Irm &= 0x3F; + else if (!I16) + { + if ((targ_size_t)(targ_schar)a == a) + c->Irm ^= 0xC0; /* do 8 sx */ + } + else if (((targ_size_t)(targ_schar)a & 0xFFFF) == (a & 0xFFFF)) + c->Irm ^= 0xC0; /* do 8 sx */ + } + + /* Look for LEA reg,[ireg], replace with MOV reg,ireg */ + else if (op == 0x8D) + { rm = c->Irm & 7; + mod = c->Irm & modregrm(3,0,0); + if (mod == 0) + { + if (!I16) + { + switch (rm) + { + case 4: + case 5: + break; + default: + c->Irm |= modregrm(3,0,0); + c->Iop = 0x8B; + break; + } + } + else + { + switch (rm) + { + case 4: rm = modregrm(3,0,SI); goto L6; + case 5: rm = modregrm(3,0,DI); goto L6; + case 7: rm = modregrm(3,0,BX); goto L6; + L6: c->Irm = rm + reg; + c->Iop = 0x8B; + break; + } + } + } + + /* replace LEA reg,0[BP] with MOV reg,BP */ + else if (mod == modregrm(1,0,0) && rm == local_BPRM && + c->IFL1 == FLconst && c->IEVpointer1 == 0) + { c->Iop = 0x8B; /* MOV reg,BP */ + c->Irm = modregrm(3,0,BP) + reg; + } + } + + // Replace [R13] with 0[R13] + if (c->Irex & REX_B && (c->Irm & modregrm(3,0,5)) == modregrm(0,0,5)) + { + c->Irm |= modregrm(1,0,0); + c->IFL1 = FLconst; + c->IEVpointer1 = 0; + } + } + else if (!(c->Iflags & CFvex)) + { + switch (op) + { + default: + if ((op & ~0x0F) != 0x70) + break; + case JMP: + switch (c->IFL2) + { case FLcode: + if (c->IEV2.Vcode == code_next(c)) + { c->Iop = NOP; + continue; + } + break; + case FLblock: + if (!code_next(c) && c->IEV2.Vblock == bn) + { c->Iop = NOP; + continue; + } + break; + case FLconst: + case FLfunc: + case FLextern: + break; + default: +#ifdef DEBUG + WRFL((enum FL)c->IFL2); +#endif + assert(0); + } + break; + + case 0x68: // PUSH immed16 + if (c->IFL2 == FLconst) + { + targ_long u = c->IEV2.Vuns; + if (I64 || + ((c->Iflags & CFopsize) ? I16 : I32)) + { // PUSH 32/64 bit operand + if (u == (signed char) u) + c->Iop = 0x6A; // PUSH immed8 + } + else // PUSH 16 bit operand + { if ((short)u == (signed char) u) + c->Iop = 0x6A; // PUSH immed8 + } + } + break; + } + } + } +#if 0 + if (1 || debugc) { + printf("-pinholeopt(%p)\n",cstart); + for (c = cstart; c; c = code_next(c)) + c->print(); + } +#endif +} + +#ifdef DEBUG +STATIC void pinholeopt_unittest() +{ + //printf("pinholeopt_unittest()\n"); + struct CS { unsigned model,op,ea,ev1,ev2,flags; } tests[][2] = + { + // XOR reg,immed NOT regL + {{ 16,0x81,modregrm(3,6,BX),0,0xFF,0 }, { 0,0xF6,modregrm(3,2,BX),0,0xFF }}, + + // MOV 0[BX],3 MOV [BX],3 + {{ 16,0xC7,modregrm(2,0,7),0,3}, { 0,0xC7,modregrm(0,0,7),0,3 }}, + +#if 0 // only if config.flags4 & CFG4space + // TEST regL,immed8 + {{ 0,0xF6,modregrm(3,0,BX),0,0xFF,0 }, { 0,0x84,modregrm(3,BX,BX),0,0xFF }}, + {{ 0,0xF7,modregrm(3,0,BX),0,0xFF,0 }, { 0,0x84,modregrm(3,BX,BX),0,0xFF }}, + {{ 64,0xF6,modregrmx(3,0,R8),0,0xFF,0 }, { 0,0x84,modregxrmx(3,R8,R8),0,0xFF }}, + {{ 64,0xF7,modregrmx(3,0,R8),0,0xFF,0 }, { 0,0x84,modregxrmx(3,R8,R8),0,0xFF }}, +#endif + + // PUSH immed => PUSH immed8 + {{ 0,0x68,0,0,0 }, { 0,0x6A,0,0,0 }}, + {{ 0,0x68,0,0,0x7F }, { 0,0x6A,0,0,0x7F }}, + {{ 0,0x68,0,0,0x80 }, { 0,0x68,0,0,0x80 }}, + {{ 16,0x68,0,0,0,CFopsize }, { 0,0x6A,0,0,0,CFopsize }}, + {{ 16,0x68,0,0,0x7F,CFopsize }, { 0,0x6A,0,0,0x7F,CFopsize }}, + {{ 16,0x68,0,0,0x80,CFopsize }, { 0,0x68,0,0,0x80,CFopsize }}, + {{ 16,0x68,0,0,0x10000,0 }, { 0,0x6A,0,0,0x10000,0 }}, + {{ 16,0x68,0,0,0x10000,CFopsize }, { 0,0x68,0,0,0x10000,CFopsize }}, + {{ 32,0x68,0,0,0,CFopsize }, { 0,0x6A,0,0,0,CFopsize }}, + {{ 32,0x68,0,0,0x7F,CFopsize }, { 0,0x6A,0,0,0x7F,CFopsize }}, + {{ 32,0x68,0,0,0x80,CFopsize }, { 0,0x68,0,0,0x80,CFopsize }}, + {{ 32,0x68,0,0,0x10000,CFopsize }, { 0,0x6A,0,0,0x10000,CFopsize }}, + {{ 32,0x68,0,0,0x8000,CFopsize }, { 0,0x68,0,0,0x8000,CFopsize }}, + }; + + //config.flags4 |= CFG4space; + for (int i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) + { CS *pin = &tests[i][0]; + CS *pout = &tests[i][1]; + code cs; + memset(&cs, 0, sizeof(cs)); + if (pin->model) + { + if (I16 && pin->model != 16) + continue; + if (I32 && pin->model != 32) + continue; + if (I64 && pin->model != 64) + continue; + } + //printf("[%d]\n", i); + cs.Iop = pin->op; + cs.Iea = pin->ea; + cs.IFL1 = FLconst; + cs.IFL2 = FLconst; + cs.IEV1.Vuns = pin->ev1; + cs.IEV2.Vuns = pin->ev2; + cs.Iflags = pin->flags; + pinholeopt(&cs, NULL); + if (cs.Iop != pout->op) + { printf("[%d] Iop = x%02x, pout = x%02x\n", i, cs.Iop, pout->op); + assert(0); + } + assert(cs.Iea == pout->ea); + assert(cs.IEV1.Vuns == pout->ev1); + assert(cs.IEV2.Vuns == pout->ev2); + assert(cs.Iflags == pout->flags); + } +} +#endif + +/************************** + * Compute jump addresses for FLcode. + * Note: only works for forward referenced code. + * only direct jumps and branches are detected. + * LOOP instructions only work for backward refs. + */ + +void jmpaddr(code *c) +{ code *ci,*cn,*ctarg,*cstart; + targ_size_t ad; + unsigned op; + + //printf("jmpaddr()\n"); + cstart = c; /* remember start of code */ + while (c) + { + op = c->Iop; + if (op <= 0xEB && + inssize[op] & T && // if second operand + c->IFL2 == FLcode && + ((op & ~0x0F) == 0x70 || op == JMP || op == JMPS || op == JCXZ || op == CALL)) + { ci = code_next(c); + ctarg = c->IEV2.Vcode; /* target code */ + ad = 0; /* IP displacement */ + while (ci && ci != ctarg) + { + ad += calccodsize(ci); + ci = code_next(ci); + } + if (!ci) + goto Lbackjmp; // couldn't find it + if (!I16 || op == JMP || op == JMPS || op == JCXZ || op == CALL) + c->IEVpointer2 = ad; + else /* else conditional */ + { if (!(c->Iflags & CFjmp16)) /* if branch */ + c->IEVpointer2 = ad; + else /* branch around a long jump */ + { cn = code_next(c); + code_next(c) = code_calloc(); + code_next(code_next(c)) = cn; + c->Iop = op ^ 1; /* converse jmp */ + c->Iflags &= ~CFjmp16; + c->IEVpointer2 = I16 ? 3 : 5; + cn = code_next(c); + cn->Iop = JMP; /* long jump */ + cn->IFL2 = FLconst; + cn->IEVpointer2 = ad; + } + } + c->IFL2 = FLconst; + } + if (op == LOOP && c->IFL2 == FLcode) /* backwards refs */ + { + Lbackjmp: + ctarg = c->IEV2.Vcode; + for (ci = cstart; ci != ctarg; ci = code_next(ci)) + if (!ci || ci == c) + assert(0); + ad = 2; /* - IP displacement */ + while (ci != c) + { assert(ci); + ad += calccodsize(ci); + ci = code_next(ci); + } + c->IEVpointer2 = (-ad) & 0xFF; + c->IFL2 = FLconst; + } + c = code_next(c); + } +} + +/******************************* + * Calculate bl->Bsize. + */ + +unsigned calcblksize(code *c) +{ unsigned size; + + for (size = 0; c; c = code_next(c)) + { + unsigned sz = calccodsize(c); + //printf("off=%02x, sz = %d, code %p: op=%02x\n", size, sz, c, c->Iop); + size += sz; + } +//printf("calcblksize(c = x%x) = %d\n", c, size); + return size; +} + +/***************************** + * Calculate and return code size of a code. + * Note that NOPs are sometimes used as markers, but are + * never output. LINNUMs are never output. + * Note: This routine must be fast. Profiling shows it is significant. + */ + +unsigned calccodsize(code *c) +{ unsigned size; + unsigned op; + unsigned char rm,mod,ins; + unsigned iflags; + unsigned i32 = I32 || I64; + unsigned a32 = i32; + +#ifdef DEBUG + assert((a32 & ~1) == 0); +#endif + iflags = c->Iflags; + op = c->Iop; + if (iflags & CFvex) + { + ins = vex_inssize(c); + size = ins & 7; + goto Lmodrm; + } + else if ((op & 0xFF00) == 0x0F00 || (op & 0xFFFD00) == 0x0F3800) + op = 0x0F; + else + op &= 0xFF; + switch (op) + { + case 0x0F: + if ((c->Iop & 0xFFFD00) == 0x0F3800) + { // 3 byte op ( 0F38-- or 0F3A-- ) + ins = inssize2[(c->Iop >> 8) & 0xFF]; + size = ins & 7; + if (c->Iop & 0xFF000000) + size++; + } + else + { // 2 byte op ( 0F-- ) + ins = inssize2[c->Iop & 0xFF]; + size = ins & 7; + if (c->Iop & 0xFF0000) + size++; + } + break; + + case NOP: + case ESCAPE: + size = 0; // since these won't be output + goto Lret2; + + case ASM: + if (c->Iflags == CFaddrsize) // kludge for DA inline asm + size = NPTRSIZE; + else + size = c->IEV1.as.len; + goto Lret2; + + case 0xA1: + case 0xA3: + if (c->Irex) + { + size = 9; // 64 bit immediate value for MOV to/from RAX + goto Lret; + } + goto Ldefault; + + case 0xF6: /* TEST mem8,immed8 */ + ins = inssize[op]; + size = ins & 7; + if (i32) + size = inssize32[op]; + if ((c->Irm & (7<<3)) == 0) + size++; /* size of immed8 */ + break; + + case 0xF7: + ins = inssize[op]; + size = ins & 7; + if (i32) + size = inssize32[op]; + if ((c->Irm & (7<<3)) == 0) + size += (i32 ^ ((iflags & CFopsize) !=0)) ? 4 : 2; + break; + + default: + Ldefault: + ins = inssize[op]; + size = ins & 7; + if (i32) + size = inssize32[op]; + } + + if (iflags & (CFwait | CFopsize | CFaddrsize | CFSEG)) + { + if (iflags & CFwait) // if add FWAIT prefix + size++; + if (iflags & CFSEG) // if segment override + size++; + + // If the instruction has a second operand that is not an 8 bit, + // and the operand size prefix is present, then fix the size computation + // because the operand size will be different. + // Walter, I had problems with this bit at the end. There can still be + // an ADDRSIZE prefix for these and it does indeed change the operand size. + + if (iflags & (CFopsize | CFaddrsize)) + { + if ((ins & (T|E)) == T) + { + if ((op & 0xAC) == 0xA0) + { + if (iflags & CFaddrsize && !I64) + { if (I32) + size -= 2; + else + size += 2; + } + } + else if (iflags & CFopsize) + { if (I16) + size += 2; + else + size -= 2; + } + } + if (iflags & CFaddrsize) + { if (!I64) + a32 ^= 1; + size++; + } + if (iflags & CFopsize) + size++; /* +1 for OPSIZE prefix */ + } + } + +Lmodrm: + if ((op & ~0x0F) == 0x70) + { if (iflags & CFjmp16) // if long branch + size += I16 ? 3 : 4; // + 3(4) bytes for JMP + } + else if (ins & M) // if modregrm byte + { + rm = c->Irm; + mod = rm & 0xC0; + if (a32 || I64) + { // 32 bit addressing + if (issib(rm)) + size++; + switch (mod) + { case 0: + if (issib(rm) && (c->Isib & 7) == 5 || + (rm & 7) == 5) + size += 4; /* disp32 */ + if (c->Irex & REX_B && (rm & 7) == 5) + /* Instead of selecting R13, this mode is an [RIP] relative + * address. Although valid, it's redundant, and should not + * be generated. Instead, generate 0[R13] instead of [R13]. + */ + assert(0); + break; + case 0x40: + size++; /* disp8 */ + break; + case 0x80: + size += 4; /* disp32 */ + break; + } + } + else + { // 16 bit addressing + if (mod == 0x40) /* 01: 8 bit displacement */ + size++; + else if (mod == 0x80 || (mod == 0 && (rm & 7) == 6)) + size += 2; + } + } + +Lret: + if (!(iflags & CFvex) && c->Irex) + { size++; + if (c->Irex & REX_W && (op & ~7) == 0xB8) + size += 4; + } +Lret2: + //printf("op = x%02x, size = %d\n",op,size); + return size; +} + +/******************************** + * Return !=0 if codes match. + */ + +#if 0 + +int code_match(code *c1,code *c2) +{ code cs1,cs2; + unsigned char ins; + + if (c1 == c2) + goto match; + cs1 = *c1; + cs2 = *c2; + if (cs1.Iop != cs2.Iop) + goto nomatch; + switch (cs1.Iop) + { + case ESCAPE | ESCctor: + case ESCAPE | ESCdtor: + goto nomatch; + + case NOP: + goto match; + + case ASM: + if (cs1.IEV1.as.len == cs2.IEV1.as.len && + memcmp(cs1.IEV1.as.bytes,cs2.IEV1.as.bytes,cs1.EV1.as.len) == 0) + goto match; + else + goto nomatch; + + default: + if ((cs1.Iop & 0xFF) == ESCAPE) + goto match; + break; + } + if (cs1.Iflags != cs2.Iflags) + goto nomatch; + + ins = inssize[cs1.Iop & 0xFF]; + if ((cs1.Iop & 0xFFFD00) == 0x0F3800) + { + ins = inssize2[(cs1.Iop >> 8) & 0xFF]; + } + else if ((cs1.Iop & 0xFF00) == 0x0F00) + { + ins = inssize2[cs1.Iop & 0xFF]; + } + + if (ins & M) // if modregrm byte + { + if (cs1.Irm != cs2.Irm) + goto nomatch; + if ((cs1.Irm & 0xC0) == 0xC0) + goto do2; + if (is32bitaddr(I32,cs1.Iflags)) + { + if (issib(cs1.Irm) && cs1.Isib != cs2.Isib) + goto nomatch; + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 4 && (c->Isib & 7) == 5 || (rm & 7) == 5)) + ) + goto do2; /* if no first operand */ + } + else + { + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 6)) + ) + goto do2; /* if no first operand */ + } + if (cs1.IFL1 != cs2.IFL1) + goto nomatch; + if (flinsymtab[cs1.IFL1] && cs1.IEVsym1 != cs2.IEVsym1) + goto nomatch; + if (cs1.IEVoffset1 != cs2.IEVoffset1) + goto nomatch; + } + +do2: + if (!(ins & T)) // if no second operand + goto match; + if (cs1.IFL2 != cs2.IFL2) + goto nomatch; + if (flinsymtab[cs1.IFL2] && cs1.IEVsym2 != cs2.IEVsym2) + goto nomatch; + if (cs1.IEVoffset2 != cs2.IEVoffset2) + goto nomatch; + +match: + return 1; + +nomatch: + return 0; +} + +#endif + +/************************** + * Write code to intermediate file. + * Code starts at offset. + * Returns: + * addr of end of code + */ + +static targ_size_t offset; /* to save code use a global */ +static char bytes[100]; +static char *pgen; + +#define GEN(c) (*pgen++ = (c)) +#define GENP(n,p) (memcpy(pgen,(p),(n)), pgen += (n)) +#if ELFOBJ || MACHOBJ +#define FLUSH() if (pgen-bytes) cod3_flush() +#else +#define FLUSH() ((pgen - bytes) && cod3_flush()) +#endif +#define OFFSET() (offset + (pgen - bytes)) + +STATIC void cod3_flush() +{ + // Emit accumulated bytes to code segment +#ifdef DEBUG + assert(pgen - bytes < sizeof(bytes)); +#endif + offset += obj_bytes(cseg,offset,pgen - bytes,bytes); + pgen = bytes; +} + +unsigned codout(code *c) +{ unsigned op; + unsigned char rm,mod; + unsigned char ins; + code *cn; + unsigned flags; + symbol *s; + +#ifdef DEBUG + if (debugc) printf("codout(%p), Coffset = x%llx\n",c,(unsigned long long)Coffset); +#endif + + pgen = bytes; + offset = Coffset; + for (; c; c = code_next(c)) + { +#ifdef DEBUG + if (debugc) { printf("off=%02lx, sz=%ld, ",(long)OFFSET(),(long)calccodsize(c)); c->print(); } + unsigned startoffset = OFFSET(); +#endif + op = c->Iop; + ins = inssize[op & 0xFF]; + switch (op & 0xFF) + { case ESCAPE: + /* Check for SSE4 opcode v/pmaxuw xmm1,xmm2/m128 */ + if(op == 0x660F383E || c->Iflags & CFvex) break; + + switch (op & 0xFFFF00) + { case ESClinnum: + /* put out line number stuff */ + objlinnum(c->IEV1.Vsrcpos,OFFSET()); + break; +#if SCPP +#if 1 + case ESCctor: + case ESCdtor: + case ESCoffset: + if (config.exe != EX_NT) + except_pair_setoffset(c,OFFSET() - funcoffset); + break; + case ESCmark: + case ESCrelease: + case ESCmark2: + case ESCrelease2: + break; +#else + case ESCctor: + except_push(OFFSET() - funcoffset,c->IEV1.Vtor,NULL); + break; + case ESCdtor: + except_pop(OFFSET() - funcoffset,c->IEV1.Vtor,NULL); + break; + case ESCmark: + except_mark(); + break; + case ESCrelease: + except_release(); + break; +#endif +#endif + } +#ifdef DEBUG + assert(calccodsize(c) == 0); +#endif + continue; + case NOP: /* don't send them out */ + if (op != NOP) + break; +#ifdef DEBUG + assert(calccodsize(c) == 0); +#endif + continue; + case ASM: + if (op != ASM) + break; + FLUSH(); + if (c->Iflags == CFaddrsize) // kludge for DA inline asm + { + do32bit(FLblockoff,&c->IEV1,0); + } + else + { + offset += obj_bytes(cseg,offset,c->IEV1.as.len,c->IEV1.as.bytes); + } +#ifdef DEBUG + assert(calccodsize(c) == c->IEV1.as.len); +#endif + continue; + } + flags = c->Iflags; + + // See if we need to flush (don't have room for largest code sequence) + if (pgen - bytes > sizeof(bytes) - (1+4+4+8+8)) + FLUSH(); + + // see if we need to put out prefix bytes + if (flags & (CFwait | CFPREFIX | CFjmp16)) + { int override; + + if (flags & CFwait) + GEN(0x9B); // FWAIT + /* ? SEGES : SEGSS */ + switch (flags & CFSEG) + { case CFes: override = SEGES; goto segover; + case CFss: override = SEGSS; goto segover; + case CFcs: override = SEGCS; goto segover; + case CFds: override = SEGDS; goto segover; + case CFfs: override = SEGFS; goto segover; + case CFgs: override = SEGGS; goto segover; + segover: GEN(override); + break; + } + + if (flags & CFaddrsize) + GEN(0x67); + + // Do this last because of instructions like ADDPD + if (flags & CFopsize) + GEN(0x66); /* operand size */ + + if ((op & ~0x0F) == 0x70 && flags & CFjmp16) /* long condit jmp */ + { + if (!I16) + { // Put out 16 bit conditional jump + c->Iop = op = 0x0F00 | (0x80 | (op & 0x0F)); + } + else + { + cn = code_calloc(); + /*cxcalloc++;*/ + code_next(cn) = code_next(c); + code_next(c) = cn; // link into code + cn->Iop = JMP; // JMP block + cn->IFL2 = c->IFL2; + cn->IEV2.Vblock = c->IEV2.Vblock; + c->Iop = op ^= 1; // toggle condition + c->IFL2 = FLconst; + c->IEVpointer2 = I16 ? 3 : 5; // skip over JMP block + c->Iflags &= ~CFjmp16; + } + } + } + + if (flags & CFvex) + { + if (flags & CFvex3) + { + GEN(0xC4); + GEN(VEX3_B1(c->Ivex)); + GEN(VEX3_B2(c->Ivex)); + GEN(c->Ivex.op); + } + else + { + GEN(0xC5); + GEN(VEX2_B1(c->Ivex)); + GEN(c->Ivex.op); + } + ins = vex_inssize(c); + goto Lmodrm; + } + + if (op > 0xFF) + { + if ((op & 0xFFFD00) == 0x0F3800) + ins = inssize2[(op >> 8) & 0xFF]; + else if ((op & 0xFF00) == 0x0F00) + ins = inssize2[op & 0xFF]; + + if (op & 0xFF000000) + { + unsigned char op1 = op >> 24; + if (op1 == 0xF2 || op1 == 0xF3 || op1 == 0x66) + { + GEN(op1); + if (c->Irex) + GEN(c->Irex | REX); + } + else + { + if (c->Irex) + GEN(c->Irex | REX); + GEN(op1); + } + GEN((op >> 16) & 0xFF); + GEN((op >> 8) & 0xFF); + GEN(op & 0xFF); + } + else if (op & 0xFF0000) + { + unsigned char op1 = op >> 16; + if (op1 == 0xF2 || op1 == 0xF3 || op1 == 0x66) + { + GEN(op1); + if (c->Irex) + GEN(c->Irex | REX); + } + else + { + if (c->Irex) + GEN(c->Irex | REX); + GEN(op1); + } + GEN((op >> 8) & 0xFF); + GEN(op & 0xFF); + } + else + { + if (c->Irex) + GEN(c->Irex | REX); + GEN((op >> 8) & 0xFF); + GEN(op & 0xFF); + } + } + else + { + if (c->Irex) + GEN(c->Irex | REX); + GEN(op); + } + Lmodrm: + if (ins & M) /* if modregrm byte */ + { + rm = c->Irm; + GEN(rm); + + // Look for an address size override when working with the + // MOD R/M and SIB bytes + + if (is32bitaddr( I32, flags)) + { + if (issib(rm)) + GEN(c->Isib); + switch (rm & 0xC0) + { case 0x40: + do8bit((enum FL) c->IFL1,&c->IEV1); // 8 bit + break; + case 0: + if (!(issib(rm) && (c->Isib & 7) == 5 || + (rm & 7) == 5)) + break; + case 0x80: + { int flags = CFoff; + targ_size_t val = 0; + if (I64) + { + if ((rm & modregrm(3,0,7)) == modregrm(0,0,5)) // if disp32[RIP] + { flags |= CFpc32; + val = -4; + unsigned reg = rm & modregrm(0,7,0); + if (ins & T || + ((op == 0xF6 || op == 0xF7) && (reg == modregrm(0,0,0) || reg == modregrm(0,1,0)))) + { if (ins & E) + val = -5; + else if (c->Iflags & CFopsize) + val = -6; + else + val = -8; + } +#if TARGET_OSX + // Mach-O linkage already takes the 4 byte size into account + val += 4; +#endif + } + } + do32bit((enum FL)c->IFL1,&c->IEV1,flags,val); + break; + } + } + } + else + { + switch (rm & 0xC0) + { case 0x40: + do8bit((enum FL) c->IFL1,&c->IEV1); // 8 bit + break; + case 0: + if ((rm & 7) != 6) + break; + case 0x80: + do16bit((enum FL)c->IFL1,&c->IEV1,CFoff); + break; + } + } + } + else + { + if (op == 0xC8) + do16bit((enum FL)c->IFL1,&c->IEV1,0); + } + flags &= CFseg | CFoff | CFselfrel; + if (ins & T) /* if second operand */ + { if (ins & E) /* if data-8 */ + do8bit((enum FL) c->IFL2,&c->IEV2); + else if (!I16) + { + switch (op) + { case 0xC2: /* RETN imm16 */ + case 0xCA: /* RETF imm16 */ + do16: + do16bit((enum FL)c->IFL2,&c->IEV2,flags); + break; + + case 0xA1: + case 0xA3: + if (I64 && c->Irex) + { + do64: + do64bit((enum FL)c->IFL2,&c->IEV2,flags); + break; + } + case 0xA0: /* MOV AL,byte ptr [] */ + case 0xA2: + if (c->Iflags & CFaddrsize && !I64) + goto do16; + else + do32: + do32bit((enum FL)c->IFL2,&c->IEV2,flags); + break; + case 0x9A: + case 0xEA: + if (c->Iflags & CFopsize) + goto ptr1616; + else + goto ptr1632; + + case 0x68: // PUSH immed32 + if ((enum FL)c->IFL2 == FLblock) + { + c->IFL2 = FLblockoff; + goto do32; + } + else + goto case_default; + + case CALL: // CALL rel + case JMP: // JMP rel + flags |= CFselfrel; + goto case_default; + + default: + if ((op|0xF) == 0x0F8F) // Jcc rel16 rel32 + flags |= CFselfrel; + if (I64 && (op & ~7) == 0xB8 && c->Irex & REX_W) + goto do64; + case_default: + if (c->Iflags & CFopsize) + goto do16; + else + goto do32; + break; + } + } + else + { + switch (op) { + case 0xC2: + case 0xCA: + goto do16; + case 0xA0: + case 0xA1: + case 0xA2: + case 0xA3: + if (c->Iflags & CFaddrsize) + goto do32; + else + goto do16; + break; + case 0x9A: + case 0xEA: + if (c->Iflags & CFopsize) + goto ptr1632; + else + goto ptr1616; + + ptr1616: + ptr1632: + //assert(c->IFL2 == FLfunc); + FLUSH(); + if (c->IFL2 == FLdatseg) + { + reftodatseg(cseg,offset,c->IEVpointer2, + c->IEVseg2,flags); + offset += 4; + } + else + { + s = c->IEVsym2; + offset += reftoident(cseg,offset,s,0,flags); + } + break; + + case 0x68: // PUSH immed16 + if ((enum FL)c->IFL2 == FLblock) + { c->IFL2 = FLblockoff; + goto do16; + } + else + goto case_default16; + + case CALL: + case JMP: + flags |= CFselfrel; + default: + case_default16: + if (c->Iflags & CFopsize) + goto do32; + else + goto do16; + break; + } + } + } + else if (op == 0xF6) /* TEST mem8,immed8 */ + { if ((rm & (7<<3)) == 0) + do8bit((enum FL)c->IFL2,&c->IEV2); + } + else if (op == 0xF7) + { if ((rm & (7<<3)) == 0) /* TEST mem16/32,immed16/32 */ + { + if ((I32 || I64) ^ ((c->Iflags & CFopsize) != 0)) + do32bit((enum FL)c->IFL2,&c->IEV2,flags); + else + do16bit((enum FL)c->IFL2,&c->IEV2,flags); + } + } +#ifdef DEBUG + if (OFFSET() - startoffset != calccodsize(c)) + { + printf("actual: %d, calc: %d\n", (int)(OFFSET() - startoffset), (int)calccodsize(c)); + c->print(); + assert(0); + } +#endif + } + FLUSH(); + Coffset = offset; + //printf("-codout(), Coffset = x%x\n", Coffset); + return offset; /* ending address */ +} + + +STATIC void do64bit(enum FL fl,union evc *uev,int flags) +{ char *p; + symbol *s; + targ_size_t ad; + + assert(I64); + switch (fl) + { + case FLconst: + ad = * (targ_size_t *) uev; + L1: + GENP(8,&ad); + return; + case FLdatseg: + FLUSH(); + reftodatseg(cseg,offset,uev->_EP.Vpointer,uev->_EP.Vseg,CFoffset64 | flags); + break; + case FLframehandler: + framehandleroffset = OFFSET(); + ad = 0; + goto L1; + case FLswitch: + FLUSH(); + ad = uev->Vswitch->Btableoffset; + if (config.flags & CFGromable) + reftocodseg(cseg,offset,ad); + else + reftodatseg(cseg,offset,ad,JMPSEG,CFoff); + break; +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#if DEBUG + symbol_print(uev->sp.Vsym); +#endif +#endif + // NOTE: In ELFOBJ all symbol refs have been tagged FLextern + // strings and statics are treated like offsets from a + // un-named external with is the start of .rodata or .data + case FLextern: /* external data symbol */ + case FLtlsdata: +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case FLgot: + case FLgotoff: +#endif + FLUSH(); + s = uev->sp.Vsym; /* symbol pointer */ + reftoident(cseg,offset,s,uev->sp.Voffset,CFoffset64 | flags); + break; + +#if TARGET_OSX + case FLgot: + funcsym_p->Slocalgotoffset = OFFSET(); + ad = 0; + goto L1; +#endif + + case FLfunc: /* function call */ + s = uev->sp.Vsym; /* symbol pointer */ + assert(TARGET_SEGMENTED || !tyfarfunc(s->ty())); + FLUSH(); + reftoident(cseg,offset,s,0,CFoffset64 | flags); + break; + + case FLblock: /* displacement to another block */ + ad = uev->Vblock->Boffset - OFFSET() - 4; + //printf("FLblock: funcoffset = %x, OFFSET = %x, Boffset = %x, ad = %x\n", funcoffset, OFFSET(), uev->Vblock->Boffset, ad); + goto L1; + + case FLblockoff: + FLUSH(); + assert(uev->Vblock); + //printf("FLblockoff: offset = %x, Boffset = %x, funcoffset = %x\n", offset, uev->Vblock->Boffset, funcoffset); + reftocodseg(cseg,offset,uev->Vblock->Boffset); + break; + + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + } + offset += 8; +} + + +STATIC void do32bit(enum FL fl,union evc *uev,int flags, targ_size_t val) +{ char *p; + symbol *s; + targ_size_t ad; + + //printf("do32bit(flags = x%x)\n", flags); + switch (fl) + { + case FLconst: + assert(sizeof(targ_size_t) == 4 || sizeof(targ_size_t) == 8); + ad = * (targ_size_t *) uev; + L1: + GENP(4,&ad); + return; + case FLdatseg: + FLUSH(); + reftodatseg(cseg,offset,uev->_EP.Vpointer,uev->_EP.Vseg,flags); + break; + case FLframehandler: + framehandleroffset = OFFSET(); + ad = 0; + goto L1; + case FLswitch: + FLUSH(); + ad = uev->Vswitch->Btableoffset; + if (config.flags & CFGromable) + reftocodseg(cseg,offset,ad); + else + reftodatseg(cseg,offset,ad,JMPSEG,CFoff); + break; +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#if DEBUG + symbol_print(uev->sp.Vsym); +#endif +#endif + // NOTE: In ELFOBJ all symbol refs have been tagged FLextern + // strings and statics are treated like offsets from a + // un-named external with is the start of .rodata or .data + case FLextern: /* external data symbol */ + case FLtlsdata: +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case FLgot: + case FLgotoff: +#endif + FLUSH(); + s = uev->sp.Vsym; /* symbol pointer */ + reftoident(cseg,offset,s,uev->sp.Voffset + val,flags); + break; + +#if TARGET_OSX + case FLgot: + funcsym_p->Slocalgotoffset = OFFSET(); + ad = 0; + goto L1; +#endif + + case FLfunc: /* function call */ + s = uev->sp.Vsym; /* symbol pointer */ +#if TARGET_SEGMENTED + if (tyfarfunc(s->ty())) + { /* Large code references are always absolute */ + FLUSH(); + offset += reftoident(cseg,offset,s,0,flags) - 4; + } + else if (s->Sseg == cseg && + (s->Sclass == SCstatic || s->Sclass == SCglobal) && + s->Sxtrnnum == 0 && flags & CFselfrel) + { /* if we know it's relative address */ + ad = s->Soffset - OFFSET() - 4; + goto L1; + } + else +#endif + { + assert(TARGET_SEGMENTED || !tyfarfunc(s->ty())); + FLUSH(); + reftoident(cseg,offset,s,val,flags); + } + break; + + case FLblock: /* displacement to another block */ + ad = uev->Vblock->Boffset - OFFSET() - 4; + //printf("FLblock: funcoffset = %x, OFFSET = %x, Boffset = %x, ad = %x\n", funcoffset, OFFSET(), uev->Vblock->Boffset, ad); + goto L1; + + case FLblockoff: + FLUSH(); + assert(uev->Vblock); + //printf("FLblockoff: offset = %x, Boffset = %x, funcoffset = %x\n", offset, uev->Vblock->Boffset, funcoffset); + reftocodseg(cseg,offset,uev->Vblock->Boffset); + break; + + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + } + offset += 4; +} + + +STATIC void do16bit(enum FL fl,union evc *uev,int flags) +{ char *p; + symbol *s; + targ_size_t ad; + + switch (fl) + { + case FLconst: + GENP(2,(char *) uev); + return; + case FLdatseg: + FLUSH(); + reftodatseg(cseg,offset,uev->_EP.Vpointer,uev->_EP.Vseg,flags); + break; + case FLswitch: + FLUSH(); + ad = uev->Vswitch->Btableoffset; + if (config.flags & CFGromable) + reftocodseg(cseg,offset,ad); + else + reftodatseg(cseg,offset,ad,JMPSEG,CFoff); + break; +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#endif + case FLextern: /* external data symbol */ + case FLtlsdata: + assert(SIXTEENBIT || TARGET_SEGMENTED); + FLUSH(); + s = uev->sp.Vsym; /* symbol pointer */ + reftoident(cseg,offset,s,uev->sp.Voffset,flags); + break; + case FLfunc: /* function call */ + assert(SIXTEENBIT || TARGET_SEGMENTED); + s = uev->sp.Vsym; /* symbol pointer */ + if (tyfarfunc(s->ty())) + { /* Large code references are always absolute */ + FLUSH(); + offset += reftoident(cseg,offset,s,0,flags) - 2; + } + else if (s->Sseg == cseg && + (s->Sclass == SCstatic || s->Sclass == SCglobal) && + s->Sxtrnnum == 0 && flags & CFselfrel) + { /* if we know it's relative address */ + ad = s->Soffset - OFFSET() - 2; + goto L1; + } + else + { FLUSH(); + reftoident(cseg,offset,s,0,flags); + } + break; + case FLblock: /* displacement to another block */ + ad = uev->Vblock->Boffset - OFFSET() - 2; +#ifdef DEBUG + { + targ_ptrdiff_t delta = uev->Vblock->Boffset - OFFSET() - 2; + assert((signed short)delta == delta); + } +#endif + L1: + GENP(2,&ad); // displacement + return; + + case FLblockoff: + FLUSH(); + reftocodseg(cseg,offset,uev->Vblock->Boffset); + break; + + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + } + offset += 2; +} + +STATIC void do8bit(enum FL fl,union evc *uev) +{ char c; + targ_ptrdiff_t delta; + + switch (fl) + { + case FLconst: + c = uev->Vuns; + break; + case FLblock: + delta = uev->Vblock->Boffset - OFFSET() - 1; + if ((signed char)delta != delta) + { +#if MARS + if (uev->Vblock->Bsrcpos.Slinnum) + fprintf(stderr, "%s(%d): ", uev->Vblock->Bsrcpos.Sfilename, uev->Vblock->Bsrcpos.Slinnum); +#endif + fprintf(stderr, "block displacement of %lld exceeds the maximum offset of -128 to 127.\n", (long long)delta); + err_exit(); + } + c = delta; +#ifdef DEBUG + assert(uev->Vblock->Boffset > OFFSET() || c != 0x7F); +#endif + break; + default: +#ifdef DEBUG + fprintf(stderr,"fl = %d\n",fl); +#endif + assert(0); + } + GEN(c); +} + + +/********************************** + */ + +#if HYDRATE +void code_hydrate(code **pc) +{ + code *c; + unsigned char ins,rm; + enum FL fl; + + assert(pc); + while (*pc) + { + c = (code *) ph_hydrate(pc); + if (c->Iflags & CFvex) + ins = vex_inssize(c); + else if ((c->Iop & 0xFFFD00) == 0x0F3800) + ins = inssize2[(c->Iop >> 8) & 0xFF]; + else if ((c->Iop & 0xFF00) == 0x0F00) + ins = inssize2[c->Iop & 0xFF]; + else + ins = inssize[c->Iop & 0xFF]; + switch (c->Iop) + { + default: + break; + + case ESCAPE | ESClinnum: + srcpos_hydrate(&c->IEV1.Vsrcpos); + goto done; + + case ESCAPE | ESCctor: + case ESCAPE | ESCdtor: + el_hydrate(&c->IEV1.Vtor); + goto done; + + case ASM: + ph_hydrate(&c->IEV1.as.bytes); + goto done; + } + if (!(ins & M) || + ((rm = c->Irm) & 0xC0) == 0xC0) + goto do2; /* if no first operand */ + if (is32bitaddr(I32,c->Iflags)) + { + + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 4 && (c->Isib & 7) == 5 || (rm & 7) == 5)) + ) + goto do2; /* if no first operand */ + } + else + { + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 6)) + ) + goto do2; /* if no first operand */ + } + fl = (enum FL) c->IFL1; + switch (fl) + { + case FLudata: + case FLdata: + case FLreg: + case FLauto: + case FLbprel: + case FLpara: +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#endif + case FLtlsdata: + case FLfunc: + case FLpseudo: + case FLextern: + case FLtmp: + assert(flinsymtab[fl]); + symbol_hydrate(&c->IEVsym1); + symbol_debug(c->IEVsym1); + break; + case FLdatseg: + case FLfltreg: + case FLallocatmp: + case FLcs: + case FLndp: + case FLoffset: + case FLlocalsize: + case FLconst: + case FLframehandler: + assert(!flinsymtab[fl]); + break; + case FLcode: + (void) ph_hydrate(&c->IEV1.Vcode); + break; + case FLblock: + case FLblockoff: + (void) ph_hydrate(&c->IEV1.Vblock); + break; +#if SCPP + case FLctor: + case FLdtor: + el_hydrate(&c->IEV1.Vtor); + break; +#endif + case FLasm: + (void) ph_hydrate(&c->IEV1.as.bytes); + break; + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + break; + } + do2: + /* Ignore TEST (F6 and F7) opcodes */ + if (!(ins & T)) + goto done; /* if no second operand */ + + fl = (enum FL) c->IFL2; + switch (fl) + { + case FLudata: + case FLdata: + case FLreg: + case FLauto: + case FLbprel: + case FLpara: +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#endif + case FLtlsdata: + case FLfunc: + case FLpseudo: + case FLextern: + case FLtmp: + assert(flinsymtab[fl]); + symbol_hydrate(&c->IEVsym2); + symbol_debug(c->IEVsym2); + break; + case FLdatseg: + case FLfltreg: + case FLallocatmp: + case FLcs: + case FLndp: + case FLoffset: + case FLlocalsize: + case FLconst: + case FLframehandler: + assert(!flinsymtab[fl]); + break; + case FLcode: + (void) ph_hydrate(&c->IEV2.Vcode); + break; + case FLblock: + case FLblockoff: + (void) ph_hydrate(&c->IEV2.Vblock); + break; + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + break; + } + done: + ; + + pc = &code_next(c); + } +} +#endif + +/********************************** + */ + +#if DEHYDRATE +void code_dehydrate(code **pc) +{ + code *c; + unsigned char ins,rm; + enum FL fl; + + while ((c = *pc) != NULL) + { + ph_dehydrate(pc); + + if (c->Iflags & CFvex) + ins = vex_inssize(c); + else if ((c->Iop & 0xFFFD00) == 0x0F3800) + ins = inssize2[(c->Iop >> 8) & 0xFF]; + else if ((c->Iop & 0xFF00) == 0x0F00) + ins = inssize2[c->Iop & 0xFF]; + else + ins = inssize[c->Iop & 0xFF]; + switch (c->Iop) + { + default: + break; + + case ESCAPE | ESClinnum: + srcpos_dehydrate(&c->IEV1.Vsrcpos); + goto done; + + case ESCAPE | ESCctor: + case ESCAPE | ESCdtor: + el_dehydrate(&c->IEV1.Vtor); + goto done; + + case ASM: + ph_dehydrate(&c->IEV1.as.bytes); + goto done; + } + + if (!(ins & M) || + ((rm = c->Irm) & 0xC0) == 0xC0) + goto do2; /* if no first operand */ + if (is32bitaddr(I32,c->Iflags)) + { + + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 4 && (c->Isib & 7) == 5 || (rm & 7) == 5)) + ) + goto do2; /* if no first operand */ + } + else + { + if ( + ((rm & 0xC0) == 0 && !((rm & 7) == 6)) + ) + goto do2; /* if no first operand */ + } + fl = (enum FL) c->IFL1; + switch (fl) + { + case FLudata: + case FLdata: + case FLreg: + case FLauto: + case FLbprel: + case FLpara: +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#endif + case FLtlsdata: + case FLfunc: + case FLpseudo: + case FLextern: + case FLtmp: + assert(flinsymtab[fl]); + symbol_dehydrate(&c->IEVsym1); + break; + case FLdatseg: + case FLfltreg: + case FLallocatmp: + case FLcs: + case FLndp: + case FLoffset: + case FLlocalsize: + case FLconst: + case FLframehandler: + assert(!flinsymtab[fl]); + break; + case FLcode: + ph_dehydrate(&c->IEV1.Vcode); + break; + case FLblock: + case FLblockoff: + ph_dehydrate(&c->IEV1.Vblock); + break; +#if SCPP + case FLctor: + case FLdtor: + el_dehydrate(&c->IEV1.Vtor); + break; +#endif + case FLasm: + ph_dehydrate(&c->IEV1.as.bytes); + break; + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + break; + } + do2: + /* Ignore TEST (F6 and F7) opcodes */ + if (!(ins & T)) + goto done; /* if no second operand */ + + fl = (enum FL) c->IFL2; + switch (fl) + { + case FLudata: + case FLdata: + case FLreg: + case FLauto: + case FLbprel: + case FLpara: +#if TARGET_SEGMENTED + case FLcsdata: + case FLfardata: +#endif + case FLtlsdata: + case FLfunc: + case FLpseudo: + case FLextern: + case FLtmp: + assert(flinsymtab[fl]); + symbol_dehydrate(&c->IEVsym2); + break; + case FLdatseg: + case FLfltreg: + case FLallocatmp: + case FLcs: + case FLndp: + case FLoffset: + case FLlocalsize: + case FLconst: + case FLframehandler: + assert(!flinsymtab[fl]); + break; + case FLcode: + ph_dehydrate(&c->IEV2.Vcode); + break; + case FLblock: + case FLblockoff: + ph_dehydrate(&c->IEV2.Vblock); + break; + default: +#ifdef DEBUG + WRFL(fl); +#endif + assert(0); + break; + } + done: + ; + pc = &code_next(c); + } +} +#endif + +/*************************** + * Debug code to dump code stucture. + */ + +#if DEBUG + +void WRcodlst(code *c) +{ for (; c; c = code_next(c)) + c->print(); +} + +void code::print() +{ + unsigned char ins; + unsigned char rexb; + code *c = this; + + if (c == CNIL) + { printf("code 0\n"); + return; + } + + unsigned op = c->Iop; + if (c->Iflags & CFvex) + ins = vex_inssize(c); + else if ((c->Iop & 0xFFFD00) == 0x0F3800) + ins = inssize2[(op >> 8) & 0xFF]; + else if ((c->Iop & 0xFF00) == 0x0F00) + ins = inssize2[op & 0xFF]; + else + ins = inssize[op & 0xFF]; + + printf("code %p: nxt=%p ",c,code_next(c)); + + if (c->Iflags & CFvex) + { + if (c->Iflags & CFvex3) + { printf("vex=0xC4"); + printf(" 0x%02X", VEX3_B1(c->Ivex)); + printf(" 0x%02X", VEX3_B2(c->Ivex)); + rexb = + ( c->Ivex.w ? REX_W : 0) | + (!c->Ivex.r ? REX_R : 0) | + (!c->Ivex.x ? REX_X : 0) | + (!c->Ivex.b ? REX_B : 0); + } + else + { printf("vex=0xC5"); + printf(" 0x%02X", VEX2_B1(c->Ivex)); + rexb = !c->Ivex.r ? REX_R : 0; + } + printf(" "); + } + else + rexb = c->Irex; + + if (rexb) + { printf("rex=0x%02X ", c->Irex); + if (rexb & REX_W) + printf("W"); + if (rexb & REX_R) + printf("R"); + if (rexb & REX_X) + printf("X"); + if (rexb & REX_B) + printf("B"); + printf(" "); + } + printf("op=0x%02X",op); + + if ((op & 0xFF) == ESCAPE) + { if ((op & 0xFF00) == ESClinnum) + { printf(" linnum = %d\n",c->IEV1.Vsrcpos.Slinnum); + return; + } + printf(" ESCAPE %d",c->Iop >> 8); + } + if (c->Iflags) + printf(" flg=%x",c->Iflags); + if (ins & M) + { unsigned rm = c->Irm; + printf(" rm=0x%02X=%d,%d,%d",rm,(rm>>6)&3,(rm>>3)&7,rm&7); + if (!I16 && issib(rm)) + { unsigned char sib = c->Isib; + printf(" sib=%02x=%d,%d,%d",sib,(sib>>6)&3,(sib>>3)&7,sib&7); + } + if ((rm & 0xC7) == BPRM || (rm & 0xC0) == 0x80 || (rm & 0xC0) == 0x40) + { + switch (c->IFL1) + { + case FLconst: + case FLoffset: + printf(" int = %4d",c->IEV1.Vuns); + break; + case FLblock: + printf(" block = %p",c->IEV1.Vblock); + break; + case FLswitch: + case FLblockoff: + case FLlocalsize: + case FLframehandler: + case 0: + break; + case FLdatseg: + printf(" %d.%llx",c->IEVseg1,(unsigned long long)c->IEVpointer1); + break; + case FLauto: + case FLreg: + case FLdata: + case FLudata: + case FLpara: + case FLtmp: + case FLbprel: + case FLtlsdata: + printf(" sym='%s'",c->IEVsym1->Sident); + break; + case FLextern: + printf(" FLextern offset = %4d",(int)c->IEVoffset1); + break; + default: + WRFL((enum FL)c->IFL1); + break; + } + } + } + if (ins & T) + { printf(" "); WRFL((enum FL)c->IFL2); + switch (c->IFL2) + { + case FLconst: + printf(" int = %4d",c->IEV2.Vuns); + break; + case FLblock: + printf(" block = %p",c->IEV2.Vblock); + break; + case FLswitch: + case FLblockoff: + case 0: + case FLlocalsize: + case FLframehandler: + break; + case FLdatseg: + printf(" %d.%llx",c->IEVseg2,(unsigned long long)c->IEVpointer2); + break; + case FLauto: + case FLreg: + case FLpara: + case FLtmp: + case FLbprel: + case FLfunc: + case FLdata: + case FLudata: + case FLtlsdata: + printf(" sym='%s'",c->IEVsym2->Sident); + break; + case FLcode: + printf(" code = %p",c->IEV2.Vcode); + break; + default: + WRFL((enum FL)c->IFL2); + break; + } + } + printf("\n"); +} +#endif + +#endif // !SPP diff --git a/backend/cod4.c b/backend/cod4.c new file mode 100644 index 00000000..fc6e1977 --- /dev/null +++ b/backend/cod4.c @@ -0,0 +1,3438 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include + +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "global.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + + /* AX,CX,DX,BX */ +const unsigned dblreg[4] = { BX,DX,(unsigned)-1,CX }; + + +/******************************* + * Return number of times symbol s appears in tree e. + */ + +STATIC int intree(symbol *s,elem *e) +{ + if (EOP(e)) + return intree(s,e->E1) + (EBIN(e) ? intree(s,e->E2) : 0); + return e->Eoper == OPvar && e->EV.sp.Vsym == s; +} + +/*********************************** + * Determine if expression e can be evaluated directly into register + * variable s. + * Have to be careful about things like x=x+x+x, and x=a+x. + * Returns: + * !=0 can + * 0 can't + */ + +int doinreg(symbol *s, elem *e) +{ int in = 0; + int op; + + L1: + op = e->Eoper; + if (op == OPind || + OTcall(op) || + OTleaf(op) || + (in = intree(s,e)) == 0 || + (OTunary(op) && !EOP(e->E1)) + ) + return 1; + if (in == 1) + { + switch (op) + { + case OPadd: + case OPmin: + case OPand: + case OPor: + case OPxor: + case OPshl: + case OPmul: + if (!intree(s,e->E2)) + { + e = e->E1; + goto L1; + } + } + } + return 0; +} + +/**************************** + * Return code for saving common subexpressions if EA + * turns out to be a register. + * This is called just before modifying an EA. + */ + +code *modEA(code *c) +{ + if ((c->Irm & 0xC0) == 0xC0) // addressing mode refers to a register + { + unsigned reg = c->Irm & 7; + if (c->Irex & REX_B) + { reg |= 8; + assert(I64); + } + return getregs(mask[reg]); + } + return CNIL; +} + +#if TARGET_WINDOS +// This code is for CPUs that do not support the 8087 + +/**************************** + * Gen code for op= for doubles. + */ + +STATIC code * opassdbl(elem *e,regm_t *pretregs,unsigned op) +{ code *c1,*c2,*c3,*c4,*c5,*c6,cs; + unsigned clib; + regm_t retregs2,retregs,idxregs; + tym_t tym; + elem *e1; + + static unsigned clibtab[OPdivass - OPpostinc + 1] = + /* OPpostinc,OPpostdec,OPeq,OPaddass,OPminass,OPmulass,OPdivass */ + { CLIBdadd, CLIBdsub, (unsigned)-1, CLIBdadd,CLIBdsub,CLIBdmul,CLIBddiv }; + + if (config.inline8087) + return opass87(e,pretregs); + clib = clibtab[op - OPpostinc]; + e1 = e->E1; + tym = tybasic(e1->Ety); + c1 = getlvalue(&cs,e1,DOUBLEREGS | mBX | mCX); + + if (tym == TYfloat) + { + clib += CLIBfadd - CLIBdadd; /* convert to float operation */ + + /* Load EA into FLOATREGS */ + c1 = cat(c1,getregs(FLOATREGS)); + cs.Iop = 0x8B; + cs.Irm |= modregrm(0,AX,0); + c1 = gen(c1,&cs); + + if (!I32) + { + cs.Irm |= modregrm(0,DX,0); + getlvalue_msw(&cs); + c1 = gen(c1,&cs); + getlvalue_lsw(&cs); + + } + retregs2 = FLOATREGS2; + idxregs = FLOATREGS | idxregm(&cs); + retregs = FLOATREGS; + } + else + { + if (I32) + { + /* Load EA into DOUBLEREGS */ + c1 = cat(c1,getregs(DOUBLEREGS_32)); + cs.Iop = 0x8B; + cs.Irm |= modregrm(0,AX,0); + c1 = gen(c1,&cs); + cs.Irm |= modregrm(0,DX,0); + getlvalue_msw(&cs); + c1 = gen(c1,&cs); + getlvalue_lsw(&cs); + + retregs2 = DOUBLEREGS2_32; + idxregs = DOUBLEREGS_32 | idxregm(&cs); + } + else + { + /* Push EA onto stack */ + cs.Iop = 0xFF; + cs.Irm |= modregrm(0,6,0); + cs.IEVoffset1 += DOUBLESIZE - REGSIZE; + c1 = gen(c1,&cs); + getlvalue_lsw(&cs); + gen(c1,&cs); + getlvalue_lsw(&cs); + gen(c1,&cs); + getlvalue_lsw(&cs); + gen(c1,&cs); + stackpush += DOUBLESIZE; + + retregs2 = DOUBLEREGS_16; + idxregs = idxregm(&cs); + } + retregs = DOUBLEREGS; + } + + if ((cs.Iflags & CFSEG) == CFes) + idxregs |= mES; + cgstate.stackclean++; + c3 = scodelem(e->E2,&retregs2,idxregs,FALSE); + cgstate.stackclean--; + c4 = callclib(e,clib,&retregs,0); + if (e1->Ecount) + cssave(e1,retregs,EOP(e1)); /* if lvalue is a CSE */ + freenode(e1); + cs.Iop = 0x89; /* MOV EA,DOUBLEREGS */ + c5 = fltregs(&cs,tym); + c6 = fixresult(e,retregs,pretregs); + return cat6(c1,CNIL,c3,c4,c5,c6); +} + +/**************************** + * Gen code for OPnegass for doubles. + */ + +STATIC code * opnegassdbl(elem *e,regm_t *pretregs) +{ code *c1,*c2,*c3,*c,*cl,*cr,cs; + unsigned clib; + regm_t retregs2,retregs,idxregs; + tym_t tym; + elem *e1; + int sz; + + if (config.inline8087) + return cdnegass87(e,pretregs); + e1 = e->E1; + tym = tybasic(e1->Ety); + sz = tysize[tym]; + + cl = getlvalue(&cs,e1,*pretregs ? DOUBLEREGS | mBX | mCX : 0); + cr = modEA(&cs); + cs.Irm |= modregrm(0,6,0); + cs.Iop = 0x80; + cs.IEVoffset1 += sz - 1; + cs.IFL2 = FLconst; + cs.IEV2.Vuns = 0x80; + c = gen(NULL,&cs); // XOR 7[EA],0x80 + if (tycomplex(tym)) + { + cs.IEVoffset1 -= sz / 2; + gen(c,&cs); // XOR 7[EA],0x80 + } + c = cat3(cl,cr,c); + + if (*pretregs || e1->Ecount) + { + cs.IEVoffset1 -= sz - 1; + + if (tym == TYfloat) + { + // Load EA into FLOATREGS + c1 = getregs(FLOATREGS); + cs.Iop = 0x8B; + NEWREG(cs.Irm, AX); + c1 = gen(c1,&cs); + + if (!I32) + { + NEWREG(cs.Irm, DX); + getlvalue_msw(&cs); + c1 = gen(c1,&cs); + getlvalue_lsw(&cs); + + } + retregs = FLOATREGS; + } + else + { + if (I32) + { + // Load EA into DOUBLEREGS + c1 = getregs(DOUBLEREGS_32); + cs.Iop = 0x8B; + cs.Irm &= ~modregrm(0,7,0); + cs.Irm |= modregrm(0,AX,0); + c1 = gen(c1,&cs); + cs.Irm |= modregrm(0,DX,0); + getlvalue_msw(&cs); + c1 = gen(c1,&cs); + getlvalue_lsw(&cs); + } + else + { +#if 1 + cs.Iop = 0x8B; + c1 = fltregs(&cs,TYdouble); // MOV DOUBLEREGS, EA +#else + // Push EA onto stack + cs.Iop = 0xFF; + cs.Irm |= modregrm(0,6,0); + cs.IEVoffset1 += DOUBLESIZE - REGSIZE; + c1 = gen(NULL,&cs); + cs.IEVoffset1 -= REGSIZE; + gen(c1,&cs); + cs.IEVoffset1 -= REGSIZE; + gen(c1,&cs); + cs.IEVoffset1 -= REGSIZE; + gen(c1,&cs); + stackpush += DOUBLESIZE; +#endif + } + retregs = DOUBLEREGS; + } + if (e1->Ecount) + cssave(e1,retregs,EOP(e1)); /* if lvalue is a CSE */ + } + else + { retregs = 0; + assert(e1->Ecount == 0); + c1 = NULL; + } + + freenode(e1); + c3 = fixresult(e,retregs,pretregs); + return cat3(c,c1,c3); +} +#endif + + + +/************************ + * Generate code for an assignment. + */ + +code *cdeq(elem *e,regm_t *pretregs) +{ + tym_t tymll; + unsigned reg; + int i; + code *cl,*cr,*c,cs; + elem *e11; + bool regvar; /* TRUE means evaluate into register variable */ + regm_t varregm; + unsigned varreg; + targ_int postinc; + + //printf("cdeq(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + elem *e1 = e->E1; + elem *e2 = e->E2; + int e2oper = e2->Eoper; + tym_t tyml = tybasic(e1->Ety); /* type of lvalue */ + regm_t retregs = *pretregs; + + if (tyxmmreg(tyml) && config.fpxmmregs) + return xmmeq(e, pretregs); + + if (tyfloating(tyml) && config.inline8087) + { + if (tycomplex(tyml)) + return complex_eq87(e, pretregs); + + if (!(retregs == 0 && + (e2oper == OPconst || e2oper == OPvar || e2oper == OPind)) + ) + return eq87(e,pretregs); + if (config.target_cpu >= TARGET_PentiumPro && + (e2oper == OPvar || e2oper == OPind) + ) + return eq87(e,pretregs); + if (tyml == TYldouble || tyml == TYildouble) + return eq87(e,pretregs); + } + + unsigned sz = tysize[tyml]; // # of bytes to transfer + assert((int)sz > 0); + + if (retregs == 0) /* if no return value */ + { int fl; + + if ((e2oper == OPconst || /* if rvalue is a constant */ + e2oper == OPrelconst && + !(I64 && config.flags3 & CFG3pic) && + ((fl = el_fl(e2)) == FLdata || + fl==FLudata || fl == FLextern) +#if TARGET_SEGMENTED + && !(e2->EV.sp.Vsym->ty() & mTYcs) +#endif + ) && + !evalinregister(e2) && + !e1->Ecount) /* and no CSE headaches */ + { + // Look for special case of (*p++ = ...), where p is a register variable + if (e1->Eoper == OPind && + ((e11 = e1->E1)->Eoper == OPpostinc || e11->Eoper == OPpostdec) && + e11->E1->Eoper == OPvar && + e11->E1->EV.sp.Vsym->Sfl == FLreg && + (!I16 || e11->E1->EV.sp.Vsym->Sregm & IDXREGS) + ) + { + postinc = e11->E2->EV.Vint; + if (e11->Eoper == OPpostdec) + postinc = -postinc; + cl = getlvalue(&cs,e11,RMstore); + freenode(e11->E2); + } + else + { postinc = 0; + cl = getlvalue(&cs,e1,RMstore); + + if (e2oper == OPconst && + config.flags4 & CFG4speed && + (config.target_cpu == TARGET_Pentium || + config.target_cpu == TARGET_PentiumMMX) && + (cs.Irm & 0xC0) == 0x80 + ) + { + if (I64 && sz == 8 && e2->EV.Vpointer) + { + // MOV reg,imm64 + // MOV EA,reg + regm_t rregm = allregs & ~idxregm(&cs); + unsigned reg; + cl = regwithvalue(cl,rregm,e2->EV.Vpointer,®,64); + cs.Iop = 0x89; + cs.Irm |= modregrm(0,reg & 7,0); + if (reg & 8) + cs.Irex |= REX_R; + c = gen(cl,&cs); + freenode(e2); + goto Lp; + } + if ((sz == REGSIZE || (I64 && sz == 4)) && e2->EV.Vint) + { + // MOV reg,imm + // MOV EA,reg + regm_t rregm = allregs & ~idxregm(&cs); + unsigned reg; + cl = regwithvalue(cl,rregm,e2->EV.Vint,®,0); + cs.Iop = 0x89; + cs.Irm |= modregrm(0,reg & 7,0); + if (reg & 8) + cs.Irex |= REX_R; + c = gen(cl,&cs); + freenode(e2); + goto Lp; + } + if (sz == 2 * REGSIZE && e2->EV.Vllong == 0) + { regm_t rregm; + unsigned reg; + + // MOV reg,imm + // MOV EA,reg + // MOV EA+2,reg + rregm = getscratch() & ~idxregm(&cs); + if (rregm) + { cl = regwithvalue(cl,rregm,e2->EV.Vint,®,0); + cs.Iop = 0x89; + cs.Irm |= modregrm(0,reg,0); + c = gen(cl,&cs); + getlvalue_msw(&cs); + c = gen(c,&cs); + freenode(e2); + goto Lp; + } + } + } + } + + /* If loading result into a register */ + if ((cs.Irm & 0xC0) == 0xC0) + { cl = cat(cl,modEA(&cs)); + if (sz == 2 * REGSIZE && cs.IFL1 == FLreg) + cl = cat(cl,getregs(cs.IEVsym1->Sregm)); + } + cs.Iop = (sz == 1) ? 0xC6 : 0xC7; + + if (e2oper == OPrelconst) + { + cs.IEVoffset2 = e2->EV.sp.Voffset; + cs.IFL2 = fl; + cs.IEVsym2 = e2->EV.sp.Vsym; + cs.Iflags |= CFoff; + cl = gen(cl,&cs); /* MOV EA,&variable */ + if (I64 && sz == 8) + code_orrex(cl, REX_W); + if (sz > REGSIZE) + { + cs.Iop = 0x8C; + getlvalue_msw(&cs); + cs.Irm |= modregrm(0,3,0); + cl = gen(cl,&cs); /* MOV EA+2,DS */ + } + } + else + { + assert(e2oper == OPconst); + cs.IFL2 = FLconst; + targ_size_t *p = (targ_size_t *) &(e2->EV); + cs.IEV2.Vsize_t = *p; + // Look for loading a register variable + if ((cs.Irm & 0xC0) == 0xC0) + { unsigned reg = cs.Irm & 7; + + if (cs.Irex & REX_B) + reg |= 8; + if (I64 && sz == 8) + cl = movregconst(cl,reg,*p,64); + else + cl = movregconst(cl,reg,*p,1 ^ (cs.Iop & 1)); + if (sz == 2 * REGSIZE) + { getlvalue_msw(&cs); + if (REGSIZE == 2) + cl = movregconst(cl,cs.Irm & 7,((unsigned short *)p)[1],0); + else if (REGSIZE == 4) + cl = movregconst(cl,cs.Irm & 7,((unsigned *)p)[1],0); + else if (REGSIZE == 8) + cl = movregconst(cl,cs.Irm & 7,p[1],0); + else + assert(0); + } + } + else if (I64 && sz == 8 && *p >= 0x80000000) + { // Use 64 bit MOV, as the 32 bit one gets sign extended + // MOV reg,imm64 + // MOV EA,reg + regm_t rregm = allregs & ~idxregm(&cs); + unsigned reg; + cl = regwithvalue(cl,rregm,e2->EV.Vpointer,®,64); + cs.Iop = 0x89; + cs.Irm |= modregrm(0,reg & 7,0); + if (reg & 8) + cs.Irex |= REX_R; + c = gen(cl,&cs); + freenode(e2); + goto Lp; + } + else + { int regsize; + + i = sz; + do + { regsize = REGSIZE; + retregs = (sz == 1) ? BYTEREGS : allregs; + if (i >= 4 && I16 && I386) + { + regsize = 4; + cs.Iflags |= CFopsize; // use opsize to do 32 bit operation + } + else + { + if (reghasvalue(retregs,*p,®)) + { + cs.Iop = (cs.Iop & 1) | 0x88; + cs.Irm |= modregrm(0,reg & 7,0); // MOV EA,reg + if (reg & 8) + cs.Irex |= REX_R; + if (I64 && sz == 1 && reg >= 4) + cs.Irex |= REX; + } + if (!I16 && i == 2) // if 16 bit operand + cs.Iflags |= CFopsize; + if (I64 && sz == 8) + cs.Irex |= REX_W; + } + cl = gen(cl,&cs); /* MOV EA,const */ + + p = (targ_size_t *)((char *) p + regsize); + cs.Iop = (cs.Iop & 1) | 0xC6; + cs.Irm &= ~modregrm(0,7,0); + cs.Irex &= ~REX_R; + cs.IEVoffset1 += regsize; + cs.IEV2.Vint = *p; + i -= regsize; + } while (i > 0); + } + } + freenode(e2); + c = cl; + goto Lp; + } + retregs = allregs; /* pick a reg, any reg */ + if (sz == 2 * REGSIZE) + retregs &= ~mBP; // BP cannot be used for register pair + } + if (retregs == mPSW) + { retregs = allregs; + if (sz == 2 * REGSIZE) + retregs &= ~mBP; // BP cannot be used for register pair + } + cs.Iop = 0x89; + if (sz == 1) // must have byte regs + { cs.Iop = 0x88; + retregs &= BYTEREGS; + if (!retregs) + retregs = BYTEREGS; + } + else if (retregs & mES +#if TARGET_SEGMENTED + && ( + (e1->Eoper == OPind && + ((tymll = tybasic(e1->E1->Ety)) == TYfptr || tymll == TYhptr)) || + (e1->Eoper == OPvar && e1->EV.sp.Vsym->Sfl == FLfardata) + ) +#endif + ) + // getlvalue() needs ES, so we can't return it + retregs = allregs; /* no conflicts with ES */ + else if (tyml == TYdouble || tyml == TYdouble_alias || retregs & mST0) + retregs = DOUBLEREGS; + regvar = FALSE; + varregm = 0; + if (config.flags4 & CFG4optimized) + { + // Be careful of cases like (x = x+x+x). We cannot evaluate in + // x if x is in a register. + if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable + doinreg(e1->EV.sp.Vsym,e2) && // and we can compute directly into it + !(sz == 1 && e1->EV.sp.Voffset == 1) + ) + { regvar = TRUE; + retregs = varregm; + reg = varreg; /* evaluate directly in target register */ + if (tysize(e1->Ety) == REGSIZE && + tysize(e1->EV.sp.Vsym->Stype->Tty) == 2 * REGSIZE) + { + if (e1->EV.sp.Voffset) + retregs &= mMSW; + else + retregs &= mLSW; + reg = findreg(retregs); + } + } + } + if (*pretregs & mPSW && !EOP(e1)) /* if evaluating e1 couldn't change flags */ + { /* Be careful that this lines up with jmpopcode() */ + retregs |= mPSW; + *pretregs &= ~mPSW; + } + cr = scodelem(e2,&retregs,0,TRUE); /* get rvalue */ + + // Look for special case of (*p++ = ...), where p is a register variable + if (e1->Eoper == OPind && + ((e11 = e1->E1)->Eoper == OPpostinc || e11->Eoper == OPpostdec) && + e11->E1->Eoper == OPvar && + e11->E1->EV.sp.Vsym->Sfl == FLreg && + (!I16 || e11->E1->EV.sp.Vsym->Sregm & IDXREGS) + ) + { + postinc = e11->E2->EV.Vint; + if (e11->Eoper == OPpostdec) + postinc = -postinc; + cl = getlvalue(&cs,e11,RMstore | retregs); + freenode(e11->E2); + if (I64 && sz < 8) + cs.Irex &= ~REX_W; // incorrectly set by getlvalue() + } + else + { postinc = 0; + cl = getlvalue(&cs,e1,RMstore | retregs); // get lvalue (cl == CNIL if regvar) + } + + c = getregs(varregm); + + assert(!(retregs & mES && (cs.Iflags & CFSEG) == CFes)); +#if TARGET_SEGMENTED + if ((tyml == TYfptr || tyml == TYhptr) && retregs & mES) + { + reg = findreglsw(retregs); + cs.Irm |= modregrm(0,reg,0); + c = gen(c,&cs); /* MOV EA,reg */ + getlvalue_msw(&cs); // point to where segment goes + cs.Iop = 0x8C; + NEWREG(cs.Irm,0); + gen(c,&cs); /* MOV EA+2,ES */ + } + else +#endif + { + if (!I16) + { + reg = findreg(retregs & + ((sz > REGSIZE) ? mBP | mLSW : mBP | ALLREGS)); + cs.Irm |= modregrm(0,reg & 7,0); + if (reg & 8) + cs.Irex |= REX_R; + for (; TRUE; sz -= REGSIZE) + { + // Do not generate mov from register onto itself + if (regvar && reg == ((cs.Irm & 7) | (cs.Irex & REX_B ? 8 : 0))) + break; + if (sz == 2) // if 16 bit operand + cs.Iflags |= CFopsize; + else if (sz == 1 && reg >= 4) + cs.Irex |= REX; + c = gen(c,&cs); // MOV EA+offset,reg + if (sz <= REGSIZE) + break; + getlvalue_msw(&cs); + reg = findregmsw(retregs); + code_newreg(&cs, reg); + } + } + else + { + if (sz > REGSIZE) + cs.IEVoffset1 += sz - REGSIZE; /* 0,2,6 */ + reg = findreg(retregs & + (sz > REGSIZE ? mMSW : ALLREGS)); + if (tyml == TYdouble || tyml == TYdouble_alias) + reg = AX; + cs.Irm |= modregrm(0,reg,0); + /* Do not generate mov from register onto itself */ + if (!regvar || reg != (cs.Irm & 7)) + for (; TRUE; sz -= REGSIZE) /* 1,2,4 */ + { + c = gen(c,&cs); /* MOV EA+offset,reg */ + if (sz <= REGSIZE) + break; + cs.IEVoffset1 -= REGSIZE; + if (tyml == TYdouble || tyml == TYdouble_alias) + reg = dblreg[reg]; + else + reg = findreglsw(retregs); + NEWREG(cs.Irm,reg); + } + } + } + if (e1->Ecount || /* if lvalue is a CSE or */ + regvar) /* rvalue can't be a CSE */ + { + c = cat(c,getregs_imm(retregs)); // necessary if both lvalue and + // rvalue are CSEs (since a reg + // can hold only one e at a time) + cssave(e1,retregs,EOP(e1)); /* if lvalue is a CSE */ + } + + c = cat4(cr,cl,c,fixresult(e,retregs,pretregs)); +Lp: + if (postinc) + { + int reg = findreg(idxregm(&cs)); + if (*pretregs & mPSW) + { // Use LEA to avoid touching the flags + unsigned rm = cs.Irm & 7; + if (cs.Irex & REX_B) + rm |= 8; + c = genc1(c,0x8D,buildModregrm(2,reg,rm),FLconst,postinc); + if (tysize(e11->E1->Ety) == 8) + code_orrex(c, REX_W); + } + else if (I64) + { + c = genc2(c,0x81,modregrmx(3,0,reg),postinc); + if (tysize(e11->E1->Ety) == 8) + code_orrex(c, REX_W); + } + else + { + if (postinc == 1) + c = gen1(c,0x40 + reg); // INC reg + else if (postinc == -(targ_int)1) + c = gen1(c,0x48 + reg); // DEC reg + else + { + c = genc2(c,0x81,modregrm(3,0,reg),postinc); + } + } + } + freenode(e1); + return c; +} + + +/************************ + * Generate code for += -= &= |= ^= negass + */ + +code *cdaddass(elem *e,regm_t *pretregs) +{ regm_t retregs,forccs,forregs; + tym_t tyml; + unsigned reg,op,op1,op2,mode,wantres; + int byte; + code *cl,*cr,*c,*ce,cs; + elem *e1; + elem *e2; + unsigned opsize; + unsigned reverse; + int sz; + regm_t varregm; + unsigned varreg; + unsigned cflags; + + //printf("cdaddass(e=%p, *pretregs = x%x)\n",e,*pretregs); + op = e->Eoper; + retregs = 0; + reverse = 0; + e1 = e->E1; + tyml = tybasic(e1->Ety); // type of lvalue + sz = tysize[tyml]; + byte = (sz == 1); // 1 for byte operation, else 0 + + // See if evaluate in XMM registers + if (config.fpxmmregs && tyxmmreg(tyml) && op != OPnegass && !(*pretregs & mST0)) + return xmmopass(e,pretregs); + + if (tyfloating(tyml)) + { +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (op == OPnegass) + c = cdnegass87(e,pretregs); + else + c = opass87(e,pretregs); +#else + if (op == OPnegass) + c = opnegassdbl(e,pretregs); + else + c = opassdbl(e,pretregs,op); +#endif + return c; + } + opsize = (I16 && tylong(tyml) && config.target_cpu >= TARGET_80386) + ? CFopsize : 0; + cflags = 0; + forccs = *pretregs & mPSW; // return result in flags + forregs = *pretregs & ~mPSW; // return result in regs + /* TRUE if we want the result in a register */ + wantres = forregs || (e1->Ecount && EOP(e1)); + + switch (op) /* select instruction opcodes */ + { case OPpostinc: op = OPaddass; /* i++ => += */ + case OPaddass: op1 = 0x01; op2 = 0x11; + cflags = CFpsw; + mode = 0; break; /* ADD, ADC */ + case OPpostdec: op = OPminass; /* i-- => -= */ + case OPminass: op1 = 0x29; op2 = 0x19; + cflags = CFpsw; + mode = 5; break; /* SUB, SBC */ + case OPandass: op1 = op2 = 0x21; + mode = 4; break; /* AND, AND */ + case OPorass: op1 = op2 = 0x09; + mode = 1; break; /* OR , OR */ + case OPxorass: op1 = op2 = 0x31; + mode = 6; break; /* XOR, XOR */ + case OPnegass: op1 = 0xF7; // NEG + break; + default: + assert(0); + } + op1 ^= byte; /* bit 0 is 0 for byte operation */ + + if (op == OPnegass) + { + cl = getlvalue(&cs,e1,0); + cr = modEA(&cs); + cs.Irm |= modregrm(0,3,0); + cs.Iop = op1; + switch (tysize[tyml]) + { case CHARSIZE: + c = gen(CNIL,&cs); + break; + + case SHORTSIZE: + c = gen(CNIL,&cs); + if (!I16 && *pretregs & mPSW) + c->Iflags |= CFopsize | CFpsw; + break; + + case LONGSIZE: + if (!I16 || opsize) + { c = gen(CNIL,&cs); + c->Iflags |= opsize; + break; + } + neg_2reg: + getlvalue_msw(&cs); + c = gen(CNIL,&cs); // NEG EA+2 + getlvalue_lsw(&cs); + gen(c,&cs); // NEG EA + code_orflag(c,CFpsw); + cs.Iop = 0x81; + getlvalue_msw(&cs); + cs.IFL2 = FLconst; + cs.IEV2.Vuns = 0; + gen(c,&cs); // SBB EA+2,0 + break; + + case LLONGSIZE: + if (I16) + assert(0); // not implemented yet + goto neg_2reg; + + default: + assert(0); + } + c = cat3(cl,cr,c); + forccs = 0; // flags already set by NEG + *pretregs &= ~mPSW; + } + else if ((e2 = e->E2)->Eoper == OPconst && // if rvalue is a const + el_signx32(e2) && + // Don't evaluate e2 in register if we can use an INC or DEC + (((sz <= REGSIZE || tyfv(tyml)) && + (op == OPaddass || op == OPminass) && + (el_allbits(e2, 1) || el_allbits(e2, -1)) + ) || + (!evalinregister(e2) +#if TARGET_SEGMENTED + && tyml != TYhptr +#endif + ) + ) + ) + { + cl = getlvalue(&cs,e1,0); + cl = cat(cl,modEA(&cs)); + cs.IFL2 = FLconst; + cs.IEV2.Vint = e2->EV.Vint; + if (sz <= REGSIZE || tyfv(tyml) || opsize) + { + targ_int i = cs.IEV2.Vint; + + /* Handle shortcuts. Watch out for if result has */ + /* to be in flags. */ + + if (reghasvalue(ALLREGS,i,®) && i != 1 && i != -1 && + !opsize) + { + cs.Iop = op1; + cs.Irm |= modregrm(0,reg,0); + } + else + { + cs.Iop = 0x81; + cs.Irm |= modregrm(0,mode,0); + switch (op) + { case OPminass: /* convert to += */ + cs.Irm ^= modregrm(0,5,0); + i = -i; + cs.IEV2.Vsize_t = i; + /* FALL-THROUGH */ + case OPaddass: + if (i == 1) /* INC EA */ + goto L1; + else if (i == -1) /* DEC EA */ + { cs.Irm |= modregrm(0,1,0); + L1: cs.Iop = 0xFF; + } + break; + } + } + cs.Iop ^= byte; /* for byte operations */ + cs.Iflags |= opsize; + if (forccs) + cs.Iflags |= CFpsw; + else if (!I16 && cs.Iflags & CFopsize) + { + switch (op) + { case OPorass: + case OPxorass: + cs.IEV2.Vsize_t &= 0xFFFF; + cs.Iflags &= ~CFopsize; // don't worry about MSW + break; + case OPandass: + cs.IEV2.Vsize_t |= ~0xFFFFLL; + cs.Iflags &= ~CFopsize; // don't worry about MSW + break; + case OPminass: + case OPaddass: +#if 1 + if ((cs.Irm & 0xC0) == 0xC0) // EA is register + cs.Iflags &= ~CFopsize; +#else + if ((cs.Irm & 0xC0) == 0xC0 && // EA is register and + e1->Eoper == OPind) // not a register var + cs.Iflags &= ~CFopsize; +#endif + break; + default: + assert(0); + break; + } + } + + // For scheduling purposes, we wish to replace: + // OP EA + // with: + // MOV reg,EA + // OP reg + // MOV EA,reg + if (forregs && sz <= REGSIZE && (cs.Irm & 0xC0) != 0xC0 && + (config.target_cpu == TARGET_Pentium || + config.target_cpu == TARGET_PentiumMMX) && + config.flags4 & CFG4speed) + { regm_t sregm; + code cs2; + + // Determine which registers to use + sregm = allregs & ~idxregm(&cs); + if (byte) + sregm &= BYTEREGS; + if (sregm & forregs) + sregm &= forregs; + + cr = allocreg(&sregm,®,tyml); // allocate register + + cs2 = cs; + cs2.Iflags &= ~CFpsw; + cs2.Iop = 0x8B ^ byte; + code_newreg(&cs2, reg); + cr = gen(cr,&cs2); // MOV reg,EA + + cs.Irm = (cs.Irm & modregrm(0,7,0)) | modregrm(3,0,reg & 7); + if (reg & 8) + cs.Irex |= REX_B; + gen(cr,&cs); // OP reg + + cs2.Iop ^= 2; + gen(cr,&cs2); // MOV EA,reg + + c = cat(cl,cr); + retregs = sregm; + wantres = 0; + if (e1->Ecount) + cssave(e1,retregs,EOP(e1)); + } + else + { + c = gen(cl,&cs); + cs.Iflags &= ~opsize; + cs.Iflags &= ~CFpsw; + if (I16 && opsize) // if DWORD operand + cs.IEVoffset1 += 2; // compensate for wantres code + } + } + else if (sz == 2 * REGSIZE) + { targ_uns msw; + + cs.Iop = 0x81; + cs.Irm |= modregrm(0,mode,0); + c = cl; + cs.Iflags |= cflags; + c = gen(c,&cs); + cs.Iflags &= ~CFpsw; + + getlvalue_msw(&cs); // point to msw + msw = MSREG(e->E2->EV.Vllong); + cs.IEV2.Vuns = msw; /* msw of constant */ + switch (op) + { case OPminass: + cs.Irm ^= modregrm(0,6,0); /* SUB => SBB */ + break; + case OPaddass: + cs.Irm |= modregrm(0,2,0); /* ADD => ADC */ + break; + } + c = gen(c,&cs); + } + else + assert(0); + freenode(e->E2); /* don't need it anymore */ + } + else if (isregvar(e1,&varregm,&varreg) && + (e2->Eoper == OPvar || e2->Eoper == OPind) && + !evalinregister(e2) && + sz <= REGSIZE) // deal with later + { + cr = getlvalue(&cs,e2,0); + freenode(e2); + cl = getregs(varregm); + code_newreg(&cs, varreg); + if (I64 && sz == 1 && varreg >= 4) + cs.Irex |= REX; + cs.Iop = op1 ^ 2; // toggle direction bit + if (forccs) + cs.Iflags |= CFpsw; + reverse = 2; // remember we toggled it + cl = gen(cl,&cs); + c = cat(cr,cl); + retregs = 0; /* to trigger a bug if we attempt to use it */ + } + else // evaluate e2 into register + { + retregs = (byte) ? BYTEREGS : ALLREGS; // pick working reg +#if TARGET_SEGMENTED + if (tyml == TYhptr) + retregs &= ~mCX; // need CX for shift count +#endif + cr = scodelem(e->E2,&retregs,0,TRUE); // get rvalue + cl = getlvalue(&cs,e1,retregs); // get lvalue + cl = cat(cl,modEA(&cs)); + cs.Iop = op1; + if (sz <= REGSIZE || tyfv(tyml)) + { reg = findreg(retregs); + code_newreg(&cs, reg); // OP1 EA,reg + if (sz == 1 && reg >= 4 && I64) + cs.Irex |= REX; + } +#if TARGET_SEGMENTED + else if (tyml == TYhptr) + { unsigned mreg,lreg; + + mreg = findregmsw(retregs); + lreg = findreglsw(retregs); + cl = cat(cl,getregs(retregs | mCX)); + + // If h -= l, convert to h += -l + if (e->Eoper == OPminass) + { + cl = gen2(cl,0xF7,modregrm(3,3,mreg)); // NEG mreg + gen2(cl,0xF7,modregrm(3,3,lreg)); // NEG lreg + code_orflag(cl,CFpsw); + genc2(cl,0x81,modregrm(3,3,mreg),0); // SBB mreg,0 + } + cs.Iop = 0x01; + cs.Irm |= modregrm(0,lreg,0); + cl = gen(cl,&cs); // ADD EA,lreg + code_orflag(cl,CFpsw); + genc2(cl,0x81,modregrm(3,2,mreg),0); // ADC mreg,0 + genshift(cl); // MOV CX,offset __AHSHIFT + gen2(cl,0xD3,modregrm(3,4,mreg)); // SHL mreg,CL + NEWREG(cs.Irm,mreg); // ADD EA+2,mreg + getlvalue_msw(&cs); + } +#endif + else if (sz == 2 * REGSIZE) + { + cs.Irm |= modregrm(0,findreglsw(retregs),0); + cl = gen(cl,&cs); /* OP1 EA,reg+1 */ + code_orflag(cl,cflags); + cs.Iop = op2; + NEWREG(cs.Irm,findregmsw(retregs)); /* OP2 EA+1,reg */ + getlvalue_msw(&cs); + } + else + assert(0); + cl = gen(cl,&cs); + c = cat(cr,cl); + retregs = 0; /* to trigger a bug if we attempt to use it */ + } + + /* See if we need to reload result into a register. */ + /* Need result in registers in case we have a 32 bit */ + /* result and we want the flags as a result. */ + if (wantres || (sz > REGSIZE && forccs)) + { + if (sz <= REGSIZE) + { regm_t possregs; + + possregs = ALLREGS; + if (byte) + possregs = BYTEREGS; + retregs = forregs & possregs; + if (!retregs) + retregs = possregs; + + // If reg field is destination + if (cs.Iop & 2 && cs.Iop < 0x40 && (cs.Iop & 7) <= 5) + { + reg = (cs.Irm >> 3) & 7; + if (cs.Irex & REX_R) + reg |= 8; + retregs = mask[reg]; + ce = allocreg(&retregs,®,tyml); + } + // If lvalue is a register, just use that register + else if ((cs.Irm & 0xC0) == 0xC0) + { + reg = cs.Irm & 7; + if (cs.Irex & REX_B) + reg |= 8; + retregs = mask[reg]; + ce = allocreg(&retregs,®,tyml); + } + else + { + ce = allocreg(&retregs,®,tyml); + cs.Iop = 0x8B ^ byte ^ reverse; + code_newreg(&cs, reg); + if (I64 && byte && reg >= 4) + cs.Irex |= REX_W; + ce = gen(ce,&cs); // MOV reg,EA + } + } +#if TARGET_SEGMENTED + else if (tyfv(tyml) || tyml == TYhptr) + { regm_t idxregs; + + if (tyml == TYhptr) + getlvalue_lsw(&cs); + idxregs = idxregm(&cs); + retregs = forregs & ~idxregs; + if (!(retregs & IDXREGS)) + retregs |= IDXREGS & ~idxregs; + if (!(retregs & mMSW)) + retregs |= mMSW & ALLREGS; + ce = allocreg(&retregs,®,tyml); + NEWREG(cs.Irm,findreglsw(retregs)); + if (retregs & mES) /* if want ES loaded */ + { cs.Iop = 0xC4; + ce = gen(ce,&cs); /* LES lreg,EA */ + } + else + { cs.Iop = 0x8B; + ce = gen(ce,&cs); /* MOV lreg,EA */ + getlvalue_msw(&cs); + if (I32) + cs.Iflags |= CFopsize; + NEWREG(cs.Irm,reg); + gen(ce,&cs); /* MOV mreg,EA+2 */ + } + } +#endif + else if (sz == 2 * REGSIZE) + { regm_t idx; + code *cm,*cl; + + idx = idxregm(&cs); + retregs = forregs; + if (!retregs) + retregs = ALLREGS; + ce = allocreg(&retregs,®,tyml); + cs.Iop = 0x8B; + NEWREG(cs.Irm,reg); + cm = gen(NULL,&cs); // MOV reg,EA+2 + NEWREG(cs.Irm,findreglsw(retregs)); + getlvalue_lsw(&cs); + cl = gen(NULL,&cs); // MOV reg+1,EA + if (mask[reg] & idx) + ce = cat3(ce,cl,cm); + else + ce = cat3(ce,cm,cl); + } + else + assert(0); + c = cat(c,ce); + if (e1->Ecount) /* if we gen a CSE */ + cssave(e1,retregs,EOP(e1)); + } + freenode(e1); + if (sz <= REGSIZE) + *pretregs &= ~mPSW; // flags are already set + return cat(c,fixresult(e,retregs,pretregs)); +} + +/******************************** + * Generate code for *= /= %= + */ + +code *cdmulass(elem *e,regm_t *pretregs) +{ + code *cr,*cl,*cg,*c,cs; + regm_t retregs; + unsigned resreg,reg,opr,lib,byte; + + //printf("cdmulass(e=%p, *pretregs = %s)\n",e,regm_str(*pretregs)); + elem *e1 = e->E1; + elem *e2 = e->E2; + unsigned op = e->Eoper; // OPxxxx + + tym_t tyml = tybasic(e1->Ety); // type of lvalue + char uns = tyuns(tyml) || tyuns(e2->Ety); + unsigned sz = tysize[tyml]; + + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + unsigned grex = rex << 16; // 64 bit operands + + // See if evaluate in XMM registers + if (config.fpxmmregs && tyxmmreg(tyml) && op != OPmodass && !(*pretregs & mST0)) + return xmmopass(e,pretregs); + + if (tyfloating(tyml)) + { +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + return opass87(e,pretregs); +#else + return opassdbl(e,pretregs,op); +#endif + } + + if (sz <= REGSIZE) /* if word or byte */ + { byte = (sz == 1); /* 1 for byte operation */ + resreg = AX; /* result register for * or / */ + if (uns) /* if unsigned operation */ + opr = 4; /* MUL */ + else /* else signed */ + opr = 5; /* IMUL */ + if (op != OPmulass) /* if /= or %= */ + { opr += 2; /* MUL => DIV, IMUL => IDIV */ + if (op == OPmodass) + resreg = DX; /* remainder is in DX */ + } + if (op == OPmulass) /* if multiply */ + { + if (config.target_cpu >= TARGET_80286 && + e2->Eoper == OPconst && !byte) + { + targ_size_t e2factor = el_tolong(e2); + if (I64 && sz == 8 && e2factor != (int)e2factor) + goto L1; + freenode(e2); + cr = CNIL; + cl = getlvalue(&cs,e1,0); /* get EA */ + regm_t idxregs = idxregm(&cs); + retregs = *pretregs & (ALLREGS | mBP) & ~idxregs; + if (!retregs) + retregs = ALLREGS & ~idxregs; + cg = allocreg(&retregs,&resreg,tyml); + cs.Iop = 0x69; /* IMUL reg,EA,e2value */ + cs.IFL2 = FLconst; + cs.IEV2.Vint = e2factor; + opr = resreg; + } + else if (!I16 && !byte) + { + L1: + retregs = *pretregs & (ALLREGS | mBP); + if (!retregs) + retregs = ALLREGS; + cr = codelem(e2,&retregs,FALSE); /* load rvalue in reg */ + cl = getlvalue(&cs,e1,retregs); /* get EA */ + cg = getregs(retregs); /* destroy these regs */ + cs.Iop = 0x0FAF; // IMUL resreg,EA + resreg = findreg(retregs); + opr = resreg; + } + else + { + retregs = mAX; + cr = codelem(e2,&retregs,FALSE); // load rvalue in AX + cl = getlvalue(&cs,e1,mAX); // get EA + cg = getregs(byte ? mAX : mAX | mDX); // destroy these regs + cs.Iop = 0xF7 ^ byte; // [I]MUL EA + } + code_newreg(&cs,opr); + c = gen(CNIL,&cs); + } + else // /= or %= + { targ_size_t e2factor; + int pow2; + + assert(!byte); // should never happen + assert(I16 || sz != SHORTSIZE); + if (config.flags4 & CFG4speed && + e2->Eoper == OPconst && !uns && + (sz == REGSIZE || (I64 && sz == 4)) && + (pow2 = ispow2(e2factor = el_tolong(e2))) != -1 && + e2factor == (int)e2factor && + !(config.target_cpu < TARGET_80286 && pow2 != 1 && op == OPdivass) + ) + { + // Signed divide or modulo by power of 2 + cr = NULL; + c = NULL; + cl = getlvalue(&cs,e1,mAX | mDX); + cs.Iop = 0x8B; + code_newreg(&cs, AX); + cl = gen(cl,&cs); // MOV AX,EA + freenode(e2); + cg = getregs(mAX | mDX); // trash these regs + cg = gen1(cg,0x99); // CWD + code_orrex(cg, rex); + if (pow2 == 1) + { + if (op == OPdivass) + { gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + gen2(cg,0xD1,grex | modregrm(3,7,AX)); // SAR AX,1 + resreg = AX; + } + else // OPmod + { gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + genc2(cg,0x81,grex | modregrm(3,4,AX),1); // AND AX,1 + gen2(cg,0x03,grex | modregrm(3,DX,AX)); // ADD DX,AX + resreg = DX; + } + } + else + { + assert(pow2 < 32); + targ_ulong m = (1 << pow2) - 1; + if (op == OPdivass) + { genc2(cg,0x81,grex | modregrm(3,4,DX),m); // AND DX,m + gen2(cg,0x03,grex | modregrm(3,AX,DX)); // ADD AX,DX + // Be careful not to generate this for 8088 + assert(config.target_cpu >= TARGET_80286); + genc2(cg,0xC1,grex | modregrm(3,7,AX),pow2); // SAR AX,pow2 + resreg = AX; + } + else // OPmodass + { gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + genc2(cg,0x81,grex | modregrm(3,4,AX),m); // AND AX,m + gen2(cg,0x33,grex | modregrm(3,AX,DX)); // XOR AX,DX + gen2(cg,0x2B,grex | modregrm(3,AX,DX)); // SUB AX,DX + resreg = AX; + } + } + } + else + { + retregs = ALLREGS & ~(mAX|mDX); // DX gets sign extension + cr = codelem(e2,&retregs,FALSE); // load rvalue in retregs + reg = findreg(retregs); + cl = getlvalue(&cs,e1,mAX | mDX | retregs); // get EA + cg = getregs(mAX | mDX); // destroy these regs + cs.Irm |= modregrm(0,AX,0); + cs.Iop = 0x8B; + c = gen(CNIL,&cs); // MOV AX,EA + if (uns) // if unsigned + movregconst(c,DX,0,0); // CLR DX + else // else signed + { gen1(c,0x99); // CWD + code_orrex(c,rex); + } + c = cat(c,getregs(mDX | mAX)); // DX and AX will be destroyed + genregs(c,0xF7,opr,reg); // OPR reg + code_orrex(c,rex); + } + } + cs.Iop = 0x89 ^ byte; + code_newreg(&cs,resreg); + c = gen(c,&cs); // MOV EA,resreg + if (e1->Ecount) // if we gen a CSE + cssave(e1,mask[resreg],EOP(e1)); + freenode(e1); + c = cat(c,fixresult(e,mask[resreg],pretregs)); + return cat4(cr,cl,cg,c); + } + else if (sz == 2 * REGSIZE) + { + lib = CLIBlmul; + if (op == OPdivass || op == OPmodass) + { lib = (uns) ? CLIBuldiv : CLIBldiv; + if (op == OPmodass) + lib++; + } + retregs = mCX | mBX; + cr = codelem(e2,&retregs,FALSE); + cl = getlvalue(&cs,e1,mDX|mAX | mCX|mBX); + cl = cat(cl,getregs(mDX | mAX)); + cs.Iop = 0x8B; + cl = gen(cl,&cs); /* MOV AX,EA */ + getlvalue_msw(&cs); + cs.Irm |= modregrm(0,DX,0); + gen(cl,&cs); /* MOV DX,EA+2 */ + getlvalue_lsw(&cs); + retregs = 0; + if (config.target_cpu >= TARGET_PentiumPro && op == OPmulass) + { + /* IMUL ECX,EAX + IMUL EDX,EBX + ADD ECX,EDX + MUL EBX + ADD EDX,ECX + */ + c = getregs(mAX|mDX|mCX); + c = gen2(c,0x0FAF,modregrm(3,CX,AX)); + gen2(c,0x0FAF,modregrm(3,DX,BX)); + gen2(c,0x03,modregrm(3,CX,DX)); + gen2(c,0xF7,modregrm(3,4,BX)); + gen2(c,0x03,modregrm(3,DX,CX)); + retregs = mDX | mAX; + } + else + c = callclib(e,lib,&retregs,idxregm(&cs)); + reg = (op == OPmodass) ? BX : AX; + retregs = mask[reg]; + cs.Iop = 0x89; + NEWREG(cs.Irm,reg); + gen(c,&cs); /* MOV EA,lsreg */ + reg = (op == OPmodass) ? CX : DX; + retregs |= mask[reg]; + NEWREG(cs.Irm,reg); + getlvalue_msw(&cs); + gen(c,&cs); /* MOV EA+2,msreg */ + if (e1->Ecount) /* if we gen a CSE */ + cssave(e1,retregs,EOP(e1)); + freenode(e1); + cg = fixresult(e,retregs,pretregs); + return cat4(cr,cl,c,cg); + } + else + { assert(0); + /* NOTREACHED */ + return 0; + } +} + + +/******************************** + * Generate code for <<= and >>= + */ + +code *cdshass(elem *e,regm_t *pretregs) +{ elem *e1,*e2; + code *cr,*cl,*cg,*c,cs,*ce; + tym_t tym,tyml; + regm_t retregs; + unsigned shiftcnt,op1,op2,reg,v,oper,byte,conste2; + unsigned loopcnt; + unsigned sz; + + e1 = e->E1; + e2 = e->E2; + + tyml = tybasic(e1->Ety); /* type of lvalue */ + sz = tysize[tyml]; + byte = tybyte(e->Ety) != 0; /* 1 for byte operations */ + tym = tybasic(e->Ety); /* type of result */ + oper = e->Eoper; + assert(tysize(e2->Ety) <= REGSIZE); + + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + + // if our lvalue is a cse, make sure we evaluate for result in register + if (e1->Ecount && !(*pretregs & (ALLREGS | mBP)) && !isregvar(e1,&retregs,®)) + *pretregs |= ALLREGS; + +#if SCPP + // Do this until the rest of the compiler does OPshr/OPashr correctly + if (oper == OPshrass) + oper = tyuns(tyml) ? OPshrass : OPashrass; +#endif + + // Select opcodes. op2 is used for msw for long shifts. + + switch (oper) + { case OPshlass: + op1 = 4; // SHL + op2 = 2; // RCL + break; + case OPshrass: + op1 = 5; // SHR + op2 = 3; // RCR + break; + case OPashrass: + op1 = 7; // SAR + op2 = 3; // RCR + break; + default: + assert(0); + } + + + v = 0xD3; /* for SHIFT xx,CL cases */ + loopcnt = 1; + conste2 = FALSE; + cr = CNIL; + shiftcnt = 0; // avoid "use before initialized" warnings + if (cnst(e2)) + { + conste2 = TRUE; /* e2 is a constant */ + shiftcnt = e2->EV.Vint; /* byte ordering of host */ + if (config.target_cpu >= TARGET_80286 && + sz <= REGSIZE && + shiftcnt != 1) + v = 0xC1; // SHIFT xx,shiftcnt + else if (shiftcnt <= 3) + { loopcnt = shiftcnt; + v = 0xD1; // SHIFT xx,1 + } + } + if (v == 0xD3) /* if COUNT == CL */ + { retregs = mCX; + cr = codelem(e2,&retregs,FALSE); + } + else + freenode(e2); + cl = getlvalue(&cs,e1,mCX); /* get lvalue, preserve CX */ + cl = cat(cl,modEA(&cs)); // check for modifying register + + if (*pretregs == 0 || /* if don't return result */ + (*pretregs == mPSW && conste2 && tysize[tym] <= REGSIZE) || + sz > REGSIZE + ) + { retregs = 0; // value not returned in a register + cs.Iop = v ^ byte; + c = CNIL; + while (loopcnt--) + { + NEWREG(cs.Irm,op1); /* make sure op1 is first */ + if (sz <= REGSIZE) + { + if (conste2) + { cs.IFL2 = FLconst; + cs.IEV2.Vint = shiftcnt; + } + c = gen(c,&cs); /* SHIFT EA,[CL|1] */ + if (*pretregs & mPSW && !loopcnt && conste2) + code_orflag(c,CFpsw); + } + else /* TYlong */ + { cs.Iop = 0xD1; /* plain shift */ + ce = gennop(CNIL); /* ce: NOP */ + if (v == 0xD3) + { c = getregs(mCX); + if (!conste2) + { assert(loopcnt == 0); + c = genjmp(c,JCXZ,FLcode,(block *) ce); /* JCXZ ce */ + } + } + if (oper == OPshlass) + { cg = gen(CNIL,&cs); // cg: SHIFT EA + c = cat(c,cg); + getlvalue_msw(&cs); + NEWREG(cs.Irm,op2); + gen(c,&cs); /* SHIFT EA */ + getlvalue_lsw(&cs); + } + else + { getlvalue_msw(&cs); + cg = gen(CNIL,&cs); + c = cat(c,cg); + NEWREG(cs.Irm,op2); + getlvalue_lsw(&cs); + gen(c,&cs); + } + if (v == 0xD3) /* if building a loop */ + { genjmp(c,LOOP,FLcode,(block *) cg); /* LOOP cg */ + regimmed_set(CX,0); /* note that now CX == 0 */ + } + c = cat(c,ce); + } + } + + /* If we want the result, we must load it from the EA */ + /* into a register. */ + + if (sz == 2 * REGSIZE && *pretregs) + { retregs = *pretregs & (ALLREGS | mBP); + if (retregs) + { ce = allocreg(&retregs,®,tym); + cs.Iop = 0x8B; + + /* be careful not to trash any index regs */ + /* do MSW first (which can't be an index reg) */ + getlvalue_msw(&cs); + NEWREG(cs.Irm,reg); + cg = gen(CNIL,&cs); + getlvalue_lsw(&cs); + reg = findreglsw(retregs); + NEWREG(cs.Irm,reg); + gen(cg,&cs); + if (*pretregs & mPSW) + cg = cat(cg,tstresult(retregs,tyml,TRUE)); + } + else /* flags only */ + { retregs = ALLREGS & ~idxregm(&cs); + ce = allocreg(&retregs,®,TYint); + cs.Iop = 0x8B; + NEWREG(cs.Irm,reg); + cg = gen(CNIL,&cs); /* MOV reg,EA */ + cs.Iop = 0x0B; /* OR reg,EA+2 */ + cs.Iflags |= CFpsw; + getlvalue_msw(&cs); + gen(cg,&cs); + } + c = cat3(c,ce,cg); + } + cg = CNIL; + } + else /* else must evaluate in register */ + { + if (sz <= REGSIZE) + { + regm_t possregs = ALLREGS & ~mCX & ~idxregm(&cs); + if (byte) + possregs &= BYTEREGS; + retregs = *pretregs & possregs; + if (retregs == 0) + retregs = possregs; + cg = allocreg(&retregs,®,tym); + cs.Iop = 0x8B ^ byte; + code_newreg(&cs, reg); + if (byte && I64 && (reg >= 4)) + cs.Irex |= REX; + c = ce = gen(CNIL,&cs); /* MOV reg,EA */ + if (!I16) + { + assert(!byte || (mask[reg] & BYTEREGS)); + ce = genc2(CNIL,v ^ byte,modregrmx(3,op1,reg),shiftcnt); + if (byte && I64 && (reg >= 4)) + ce->Irex |= REX; + code_orrex(ce, rex); + /* We can do a 32 bit shift on a 16 bit operand if */ + /* it's a left shift and we're not concerned about */ + /* the flags. Remember that flags are not set if */ + /* a shift of 0 occurs. */ + if (tysize[tym] == SHORTSIZE && + (oper == OPshrass || oper == OPashrass || + (*pretregs & mPSW && conste2))) + ce->Iflags |= CFopsize; /* 16 bit operand */ + cat(c,ce); + } + else + { + while (loopcnt--) + { /* Generate shift instructions. */ + genc2(ce,v ^ byte,modregrm(3,op1,reg),shiftcnt); + } + } + if (*pretregs & mPSW && conste2) + { assert(shiftcnt); + *pretregs &= ~mPSW; // result is already in flags + code_orflag(ce,CFpsw); + } + + cs.Iop = 0x89 ^ byte; + if (byte && I64 && (reg >= 4)) + cs.Irex |= REX; + gen(ce,&cs); /* MOV EA,reg */ + + // If result is not in correct register + cat(ce,fixresult(e,retregs,pretregs)); + retregs = *pretregs; + } + else + assert(0); + } + if (e1->Ecount && !(retregs & regcon.mvar)) // if lvalue is a CSE + cssave(e1,retregs,EOP(e1)); + freenode(e1); + *pretregs = retregs; + return cat4(cr,cl,cg,c); +} + + +/********************************** + * Generate code for compares. + * Handles lt,gt,le,ge,eqeq,ne for all data types. + */ + +code *cdcmp(elem *e,regm_t *pretregs) +{ regm_t retregs,rretregs; + unsigned reg,rreg,op,jop,byte; + tym_t tym; + code *cl,*cr,*c,cs,*ce,*cg; + elem *e1,*e2; + bool eqorne; + unsigned reverse; + unsigned sz; + int fl; + int flag; + + //printf("cdcmp(e = %p, retregs = %s)\n",e,regm_str(*pretregs)); + // Collect extra parameter. This is pretty ugly... + flag = cdcmp_flag; + cdcmp_flag = 0; + + e1 = e->E1; + e2 = e->E2; + if (*pretregs == 0) /* if don't want result */ + { cl = codelem(e1,pretregs,FALSE); + *pretregs = 0; /* in case e1 changed it */ + cr = codelem(e2,pretregs,FALSE); + return cat(cl,cr); + } + + jop = jmpopcode(e); // must be computed before + // leaves are free'd + reverse = 0; + cl = cr = CNIL; + op = e->Eoper; + assert(OTrel(op)); + eqorne = (op == OPeqeq) || (op == OPne); + + tym = tybasic(e1->Ety); + sz = tysize[tym]; + byte = sz == 1; + + unsigned rex = (I64 && sz == 8) ? REX_W : 0; + unsigned grex = rex << 16; // 64 bit operands + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (tyfloating(tym)) /* if floating operation */ + { + retregs = mPSW; + if (tyxmmreg(tym) && config.fpxmmregs) + c = orthxmm(e,&retregs); + else + c = orth87(e,&retregs); + goto L3; + } +#else + if (tyfloating(tym)) /* if floating operation */ + { + if (config.inline8087) + { retregs = mPSW; + c = orth87(e,&retregs); + } + else + { int clib; + + retregs = 0; /* skip result for now */ + if (iffalse(e2)) /* second operand is constant 0 */ + { assert(!eqorne); /* should be OPbool or OPnot */ + if (tym == TYfloat) + { retregs = FLOATREGS; + clib = CLIBftst0; + } + else + { retregs = DOUBLEREGS; + clib = CLIBdtst0; + } + if (rel_exception(op)) + clib += CLIBdtst0exc - CLIBdtst0; + cl = codelem(e1,&retregs,FALSE); + retregs = 0; + c = callclib(e,clib,&retregs,0); + freenode(e2); + } + else + { clib = CLIBdcmp; + if (rel_exception(op)) + clib += CLIBdcmpexc - CLIBdcmp; + c = opdouble(e,&retregs,clib); + } + } + goto L3; + } +#endif + + /* If it's a signed comparison of longs, we have to call a library */ + /* routine, because we don't know the target of the signed branch */ + /* (have to set up flags so that jmpopcode() will do it right) */ + if (!eqorne && + (I16 && tym == TYlong && tybasic(e2->Ety) == TYlong || + I32 && tym == TYllong && tybasic(e2->Ety) == TYllong) + ) + { retregs = mDX | mAX; + cl = codelem(e1,&retregs,FALSE); + retregs = mCX | mBX; + cr = scodelem(e2,&retregs,mDX | mAX,FALSE); + + if (I16) + { + retregs = 0; + c = callclib(e,CLIBlcmp,&retregs,0); /* gross, but it works */ + } + else + { + /* Generate: + * CMP EDX,ECX + * JNE C1 + * XOR EDX,EDX + * CMP EAX,EBX + * JZ C1 + * JA C3 + * DEC EDX + * JMP C1 + * C3: INC EDX + * C1: + */ + c = getregs(mDX); + c = genregs(c,0x39,CX,DX); // CMP EDX,ECX + code *c1 = gennop(CNIL); + genjmp(c,JNE,FLcode,(block *)c1); // JNE C1 + movregconst(c,DX,0,0); // XOR EDX,EDX + genregs(c,0x39,BX,AX); // CMP EAX,EBX + genjmp(c,JE,FLcode,(block *)c1); // JZ C1 + code *c3 = gen1(CNIL,0x40 + DX); // INC EDX + genjmp(c,JA,FLcode,(block *)c3); // JA C3 + gen1(c,0x48 + DX); // DEC EDX + genjmp(c,JMPS,FLcode,(block *)c1); // JMP C1 + c = cat4(c,c3,c1,getregs(mDX)); + retregs = mPSW; + } + goto L3; + } + + /* See if we should swap operands */ + if (e1->Eoper == OPvar && e2->Eoper == OPvar && evalinregister(e2)) + { e1 = e->E2; + e2 = e->E1; + reverse = 2; + } + + retregs = allregs; + if (byte) + retregs = BYTEREGS; + + c = CNIL; + ce = CNIL; + cs.Iflags = (!I16 && sz == SHORTSIZE) ? CFopsize : 0; + cs.Irex = rex; + if (sz > REGSIZE) + ce = gennop(ce); + + switch (e2->Eoper) + { + default: + L2: + cl = scodelem(e1,&retregs,0,TRUE); /* compute left leaf */ + L1: + rretregs = allregs & ~retregs; + if (byte) + rretregs &= BYTEREGS; + cr = scodelem(e2,&rretregs,retregs,TRUE); /* get right leaf */ + if (sz <= REGSIZE) /* CMP reg,rreg */ + { reg = findreg(retregs); /* get reg that e1 is in */ + rreg = findreg(rretregs); + c = genregs(CNIL,0x3B ^ byte ^ reverse,reg,rreg); + code_orrex(c, rex); + if (!I16 && sz == SHORTSIZE) + c->Iflags |= CFopsize; /* compare only 16 bits */ + if (I64 && byte && (reg >= 4 || rreg >= 4)) + c->Irex |= REX; // address byte registers + } + else + { assert(sz <= 2 * REGSIZE); + + /* Compare MSW, if they're equal then compare the LSW */ + reg = findregmsw(retregs); + rreg = findregmsw(rretregs); + c = genregs(CNIL,0x3B ^ reverse,reg,rreg); /* CMP reg,rreg */ + if (I32 && sz == 6) + c->Iflags |= CFopsize; /* seg is only 16 bits */ + else if (I64) + code_orrex(c, REX_W); + genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop */ + + reg = findreglsw(retregs); + rreg = findreglsw(rretregs); + genregs(c,0x3B ^ reverse,reg,rreg); /* CMP reg,rreg */ + if (I64) + code_orrex(c, REX_W); + } + break; + case OPrelconst: + if (I64 && config.flags3 & CFG3pic) + goto L2; + fl = el_fl(e2); + switch (fl) + { case FLfunc: + fl = FLextern; // so it won't be self-relative + break; + case FLdata: + case FLudata: + case FLextern: + if (sz > REGSIZE) // compare against DS, not DGROUP + goto L2; + break; +#if TARGET_SEGMENTED + case FLfardata: + break; +#endif + default: + goto L2; + } + cs.IFL2 = fl; + cs.IEVsym2 = e2->EV.sp.Vsym; + if (sz > REGSIZE) + { cs.Iflags |= CFseg; + cs.IEVoffset2 = 0; + } + else + { cs.Iflags |= CFoff; + cs.IEVoffset2 = e2->EV.sp.Voffset; + } + goto L4; + + case OPconst: + // If compare against 0 + if (sz <= REGSIZE && *pretregs == mPSW && !boolres(e2) && + isregvar(e1,&retregs,®) + ) + { // Just do a TEST instruction + c = genregs(NULL,0x85 ^ byte,reg,reg); // TEST reg,reg + c->Iflags |= (cs.Iflags & CFopsize) | CFpsw; + code_orrex(c, rex); + if (I64 && byte && reg >= 4) + c->Irex |= REX; // address byte registers + retregs = mPSW; + break; + } + + if (!tyuns(tym) && !tyuns(e2->Ety) && + !boolres(e2) && !(*pretregs & mPSW) && + (sz == REGSIZE || (I64 && sz == 4)) && + (!I16 || op == OPlt || op == OPge)) + { + assert(*pretregs & (allregs)); + cl = codelem(e1,pretregs,FALSE); + reg = findreg(*pretregs); + c = getregs(mask[reg]); + switch (op) + { case OPle: + c = genc2(c,0x81,grex | modregrmx(3,0,reg & 7),(unsigned)-1); // ADD reg,-1 + code_orflag(c, CFpsw); + genc2(c,0x81,grex | modregrmx(3,2,reg & 7),0); // ADC reg,0 + goto oplt; + case OPgt: + c = gen2(c,0xF7,grex | modregrmx(3,3,reg & 7)); // NEG reg +#if TARGET_WINDOS + // What does the Windows platform do? + // lower INT_MIN by 1? See test exe9.c + // BUG: fix later + code_orflag(c, CFpsw); + genc2(c,0x81,grex | modregrmx(3,3,reg),0); // SBB reg,0 +#endif + goto oplt; + case OPlt: + oplt: + if (!I16) + c = genc2(c,0xC1,grex | modregrmx(3,5,reg),sz * 8 - 1); // SHR reg,31 + else + { /* 8088-286 do not have a barrel shifter, so use this + faster sequence + */ + c = genregs(c,0xD1,0,reg); /* ROL reg,1 */ + unsigned regi; + if (reghasvalue(allregs,1,®i)) + c = genregs(c,0x23,reg,regi); /* AND reg,regi */ + else + c = genc2(c,0x81,modregrm(3,4,reg),1); /* AND reg,1 */ + } + break; + case OPge: + c = genregs(c,0xD1,4,reg); /* SHL reg,1 */ + code_orrex(c,rex); + code_orflag(c, CFpsw); + genregs(c,0x19,reg,reg); /* SBB reg,reg */ + code_orrex(c,rex); + if (I64) + { + c = gen2(c,0xFF,modregrmx(3,0,reg)); // INC reg + code_orrex(c, rex); + } + else + c = gen1(c,0x40 + reg); // INC reg + break; + + default: + assert(0); + } + freenode(e2); + goto ret; + } + + cs.IFL2 = FLconst; + if (sz == 16) + cs.IEV2.Vsize_t = e2->EV.Vcent.msw; + else if (sz > REGSIZE) + cs.IEV2.Vint = MSREG(e2->EV.Vllong); + else + cs.IEV2.Vsize_t = e2->EV.Vllong; + + // The cmp immediate relies on sign extension of the 32 bit immediate value + if (I64 && sz >= REGSIZE && cs.IEV2.Vsize_t != (int)cs.IEV2.Vint) + goto L2; + L4: + cs.Iop = 0x81 ^ byte; + + /* if ((e1 is data or a '*' reference) and it's not a + * common subexpression + */ + + if ((e1->Eoper == OPvar && datafl[el_fl(e1)] || + e1->Eoper == OPind) && + !evalinregister(e1)) + { cl = getlvalue(&cs,e1,RMload); + freenode(e1); + if (evalinregister(e2)) + { + retregs = idxregm(&cs); + if ((cs.Iflags & CFSEG) == CFes) + retregs |= mES; /* take no chances */ + rretregs = allregs & ~retregs; + if (byte) + rretregs &= BYTEREGS; + cr = scodelem(e2,&rretregs,retregs,TRUE); + cs.Iop = 0x39 ^ byte ^ reverse; + if (sz > REGSIZE) + { + rreg = findregmsw(rretregs); + cs.Irm |= modregrm(0,rreg,0); + getlvalue_msw(&cs); + c = gen(CNIL,&cs); /* CMP EA+2,rreg */ + if (I32 && sz == 6) + c->Iflags |= CFopsize; /* seg is only 16 bits */ + if (I64 && byte && rreg >= 4) + c->Irex |= REX; + genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop */ + rreg = findreglsw(rretregs); + NEWREG(cs.Irm,rreg); + getlvalue_lsw(&cs); + } + else + { + rreg = findreg(rretregs); + code_newreg(&cs, rreg); + if (I64 && byte && rreg >= 4) + cs.Irex |= REX; + } + } + else + { + cs.Irm |= modregrm(0,7,0); + if (sz > REGSIZE) + { +#if !TARGET_SEGMENTED + if (sz == 6) + assert(0); +#endif + if (e2->Eoper == OPrelconst) + { cs.Iflags = (cs.Iflags & ~(CFoff | CFseg)) | CFseg; + cs.IEVoffset2 = 0; + } + getlvalue_msw(&cs); + c = gen(CNIL,&cs); /* CMP EA+2,const */ + if (!I16 && sz == 6) + c->Iflags |= CFopsize; /* seg is only 16 bits */ + genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop */ + if (e2->Eoper == OPconst) + cs.IEV2.Vint = e2->EV.Vllong; + else if (e2->Eoper == OPrelconst) + { /* Turn off CFseg, on CFoff */ + cs.Iflags ^= CFseg | CFoff; + cs.IEVoffset2 = e2->EV.sp.Voffset; + } + else + assert(0); + getlvalue_lsw(&cs); + } + freenode(e2); + } + c = gen(c,&cs); + break; + } + + if (evalinregister(e2) && !OTassign(e1->Eoper) && + !isregvar(e1,NULL,NULL)) + { regm_t m; + + m = allregs & ~regcon.mvar; + if (byte) + m &= BYTEREGS; + if (m & (m - 1)) // if more than one free register + goto L2; + } + if ((e1->Eoper == OPstrcmp || (OTassign(e1->Eoper) && sz <= REGSIZE)) && + !boolres(e2) && !evalinregister(e1)) + { + retregs = mPSW; + cl = scodelem(e1,&retregs,0,FALSE); + freenode(e2); + break; + } + if (sz <= REGSIZE && !boolres(e2) && e1->Eoper == OPadd && *pretregs == mPSW) + { + retregs |= mPSW; + cl = scodelem(e1,&retregs,0,FALSE); + freenode(e2); + break; + } + cl = scodelem(e1,&retregs,0,TRUE); /* compute left leaf */ + if (sz == 1) + { + reg = findreg(retregs & allregs); // get reg that e1 is in + cs.Irm = modregrm(3,7,reg & 7); + if (reg & 8) + cs.Irex |= REX_B; + if (e1->Eoper == OPvar && e1->EV.sp.Voffset == 1 && e1->EV.sp.Vsym->Sfl == FLreg) + { assert(reg < 4); + cs.Irm |= 4; // use upper register half + } + if (I64 && reg >= 4) + cs.Irex |= REX; // address byte registers + } + else if (sz <= REGSIZE) + { /* CMP reg,const */ + reg = findreg(retregs & allregs); // get reg that e1 is in + rretregs = allregs & ~retregs; + if (cs.IFL2 == FLconst && reghasvalue(rretregs,cs.IEV2.Vint,&rreg)) + { + code *cc = genregs(CNIL,0x3B,reg,rreg); + code_orrex(cc, rex); + if (!I16) + cc->Iflags |= cs.Iflags & CFopsize; + c = cat(c,cc); + freenode(e2); + break; + } + cs.Irm = modregrm(3,7,reg & 7); + if (reg & 8) + cs.Irex |= REX_B; + } + else if (sz <= 2 * REGSIZE) + { + reg = findregmsw(retregs); // get reg that e1 is in + cs.Irm = modregrm(3,7,reg); + c = gen(CNIL,&cs); /* CMP reg,MSW */ + if (I32 && sz == 6) + c->Iflags |= CFopsize; /* seg is only 16 bits */ + genjmp(c,JNE,FLcode,(block *) ce); /* JNE ce */ + + reg = findreglsw(retregs); + cs.Irm = modregrm(3,7,reg); + if (e2->Eoper == OPconst) + cs.IEV2.Vint = e2->EV.Vlong; + else if (e2->Eoper == OPrelconst) + { /* Turn off CFseg, on CFoff */ + cs.Iflags ^= CFseg | CFoff; + cs.IEVoffset2 = e2->EV.sp.Voffset; + } + else + assert(0); + } + else + assert(0); + c = gen(c,&cs); /* CMP sucreg,LSW */ + freenode(e2); + break; + + case OPind: + if (e2->Ecount) + goto L2; + goto L5; + + case OPvar: +#if TARGET_OSX + if (movOnly(e2)) + goto L2; +#endif + if ((e1->Eoper == OPvar && + isregvar(e2,&rretregs,®) && + sz <= REGSIZE + ) || + (e1->Eoper == OPind && + isregvar(e2,&rretregs,®) && + !evalinregister(e1) && + sz <= REGSIZE + ) + ) + { + // CMP EA,e2 + cl = getlvalue(&cs,e1,RMload); + freenode(e1); + cs.Iop = 0x39 ^ byte ^ reverse; + code_newreg(&cs,reg); + if (I64 && byte && reg >= 4) + cs.Irex |= REX; // address byte registers + c = gen(c,&cs); + freenode(e2); + break; + } + L5: + cl = scodelem(e1,&retregs,0,TRUE); /* compute left leaf */ + if (sz <= REGSIZE) /* CMP reg,EA */ + { + reg = findreg(retregs & allregs); // get reg that e1 is in + unsigned opsize = cs.Iflags & CFopsize; + c = cat(c,loadea(e2,&cs,0x3B ^ byte ^ reverse,reg,0,RMload | retregs,0)); + code_orflag(c,opsize); + } + else if (sz <= 2 * REGSIZE) + { + reg = findregmsw(retregs); /* get reg that e1 is in */ + // CMP reg,EA + c = loadea(e2,&cs,0x3B ^ reverse,reg,REGSIZE,RMload | retregs,0); + if (I32 && sz == 6) + c->Iflags |= CFopsize; /* seg is only 16 bits */ + genjmp(c,JNE,FLcode,(block *) ce); /* JNE ce */ + reg = findreglsw(retregs); + if (e2->Eoper == OPind) + { + NEWREG(cs.Irm,reg); + getlvalue_lsw(&cs); + c = gen(c,&cs); + } + else + c = cat(c,loadea(e2,&cs,0x3B ^ reverse,reg,0,RMload | retregs,0)); + } + else + assert(0); + freenode(e2); + break; + } + c = cat(c,ce); + +L3: + if ((retregs = (*pretregs & (ALLREGS | mBP))) != 0) // if return result in register + { code *nop = CNIL; + regm_t save = regcon.immed.mval; + cg = allocreg(&retregs,®,TYint); + regcon.immed.mval = save; + if ((*pretregs & mPSW) == 0 && + (jop == JC || jop == JNC)) + { + cg = cat(cg,getregs(retregs)); + cg = genregs(cg,0x19,reg,reg); /* SBB reg,reg */ + if (rex) + code_orrex(cg, rex); + if (flag) + ; // cdcond() will handle it + else if (jop == JNC) + { + if (I64) + { + cg = gen2(cg,0xFF,modregrmx(3,0,reg)); // INC reg + code_orrex(cg, rex); + } + else + gen1(cg,0x40 + reg); // INC reg + } + else + { gen2(cg,0xF7,modregrmx(3,3,reg)); /* NEG reg */ + code_orrex(cg, rex); + } + } + else if (I64 && sz == 8) + { + assert(!flag); + cg = movregconst(cg,reg,1,64|8); // MOV reg,1 + nop = gennop(nop); + cg = genjmp(cg,jop,FLcode,(block *) nop); // Jtrue nop + // MOV reg,0 + movregconst(cg,reg,0,(*pretregs & mPSW) ? 64|8 : 64); + regcon.immed.mval &= ~mask[reg]; + } + else + { + assert(!flag); + cg = movregconst(cg,reg,1,8); // MOV reg,1 + nop = gennop(nop); + cg = genjmp(cg,jop,FLcode,(block *) nop); // Jtrue nop + // MOV reg,0 + movregconst(cg,reg,0,(*pretregs & mPSW) ? 8 : 0); + regcon.immed.mval &= ~mask[reg]; + } + *pretregs = retregs; + c = cat3(c,cg,nop); + } +ret: + return cat3(cl,cr,c); +} + + +/********************************** + * Generate code for signed compare of longs. + * Input: + * targ block* or code* + */ + +code *longcmp(elem *e,bool jcond,unsigned fltarg,code *targ) +{ regm_t retregs,rretregs; + unsigned reg,rreg,op,jop; + code *cl,*cr,*c,cs,*ce; + code *cmsw,*clsw; + elem *e1,*e2; + /* <= > < >= */ + static const unsigned char jopmsw[4] = {JL, JG, JL, JG }; + static const unsigned char joplsw[4] = {JBE, JA, JB, JAE }; + + //printf("longcmp(e = %p)\n", e); + cr = CNIL; + e1 = e->E1; + e2 = e->E2; + op = e->Eoper; + + /* See if we should swap operands */ + if (e1->Eoper == OPvar && e2->Eoper == OPvar && evalinregister(e2)) + { e1 = e->E2; + e2 = e->E1; + op = swaprel(op); + } + + cs.Iflags = 0; + cs.Irex = 0; + + ce = gennop(CNIL); + retregs = ALLREGS; + + switch (e2->Eoper) + { + default: + L2: + cl = scodelem(e1,&retregs,0,TRUE); /* compute left leaf */ + rretregs = ALLREGS & ~retregs; + cr = scodelem(e2,&rretregs,retregs,TRUE); /* get right leaf */ + /* Compare MSW, if they're equal then compare the LSW */ + reg = findregmsw(retregs); + rreg = findregmsw(rretregs); + cmsw = genregs(CNIL,0x3B,reg,rreg); /* CMP reg,rreg */ + + reg = findreglsw(retregs); + rreg = findreglsw(rretregs); + clsw = genregs(CNIL,0x3B,reg,rreg); /* CMP reg,rreg */ + break; + case OPconst: + cs.IEV2.Vint = MSREG(e2->EV.Vllong); // MSW first + cs.IFL2 = FLconst; + cs.Iop = 0x81; + + /* if ((e1 is data or a '*' reference) and it's not a + * common subexpression + */ + + if ((e1->Eoper == OPvar && datafl[el_fl(e1)] || + e1->Eoper == OPind) && + !evalinregister(e1)) + { cl = getlvalue(&cs,e1,0); + freenode(e1); + if (evalinregister(e2)) + { + retregs = idxregm(&cs); + if ((cs.Iflags & CFSEG) == CFes) + retregs |= mES; /* take no chances */ + rretregs = ALLREGS & ~retregs; + cr = scodelem(e2,&rretregs,retregs,TRUE); + rreg = findregmsw(rretregs); + cs.Iop = 0x39; + cs.Irm |= modregrm(0,rreg,0); + getlvalue_msw(&cs); + cmsw = gen(CNIL,&cs); /* CMP EA+2,rreg */ + rreg = findreglsw(rretregs); + NEWREG(cs.Irm,rreg); + } + else + { cs.Irm |= modregrm(0,7,0); + getlvalue_msw(&cs); + cmsw = gen(CNIL,&cs); /* CMP EA+2,const */ + cs.IEV2.Vint = e2->EV.Vlong; + freenode(e2); + } + getlvalue_lsw(&cs); + clsw = gen(CNIL,&cs); /* CMP EA,rreg/const */ + break; + } + if (evalinregister(e2)) + goto L2; + + cl = scodelem(e1,&retregs,0,TRUE); /* compute left leaf */ + reg = findregmsw(retregs); /* get reg that e1 is in */ + cs.Irm = modregrm(3,7,reg); + + cmsw = gen(CNIL,&cs); /* CMP reg,MSW */ + reg = findreglsw(retregs); + cs.Irm = modregrm(3,7,reg); + cs.IEV2.Vint = e2->EV.Vlong; + clsw = gen(CNIL,&cs); /* CMP sucreg,LSW */ + freenode(e2); + break; + case OPvar: + if (!e1->Ecount && e1->Eoper == OPs32_64) + { unsigned msreg; + + retregs = allregs; + cl = scodelem(e1->E1,&retregs,0,TRUE); + freenode(e1); + reg = findreg(retregs); + retregs = allregs & ~retregs; + cr = allocreg(&retregs,&msreg,TYint); + cr = genmovreg(cr,msreg,reg); // MOV msreg,reg + cr = genc2(cr,0xC1,modregrm(3,7,msreg),REGSIZE * 8 - 1); // SAR msreg,31 + cmsw = loadea(e2,&cs,0x3B,msreg,REGSIZE,mask[reg],0); + clsw = loadea(e2,&cs,0x3B,reg,0,mask[reg],0); + freenode(e2); + } + else + { + cl = scodelem(e1,&retregs,0,TRUE); // compute left leaf + reg = findregmsw(retregs); // get reg that e1 is in + cmsw = loadea(e2,&cs,0x3B,reg,REGSIZE,retregs,0); + reg = findreglsw(retregs); + clsw = loadea(e2,&cs,0x3B,reg,0,retregs,0); + freenode(e2); + } + break; + } + + jop = jopmsw[op - OPle]; + if (!(jcond & 1)) jop ^= (JL ^ JG); // toggle jump condition + genjmp(cmsw,jop,fltarg,(block *) targ); /* Jx targ */ + genjmp(cmsw,jop ^ (JL ^ JG),FLcode,(block *) ce); /* Jy nop */ + + jop = joplsw[op - OPle]; + if (!(jcond & 1)) jop ^= 1; // toggle jump condition + genjmp(clsw,jop,fltarg,(block *) targ); /* Jcond targ */ + + c = cse_flush(1); // flush CSE's to memory + freenode(e); + return cat6(cl,cr,c,cmsw,clsw,ce); +} + +/***************************** + * Do conversions. + * Depends on OPd_s32 and CLIBdbllng being in sequence. + */ + +code *cdcnvt(elem *e, regm_t *pretregs) +{ regm_t retregs; + code *c1,*c2; + int i; + static unsigned char clib[][2] = + { OPd_s32, CLIBdbllng, + OPs32_d, CLIBlngdbl, + OPd_s16, CLIBdblint, + OPs16_d, CLIBintdbl, + OPd_u16, CLIBdbluns, + OPu16_d, CLIBunsdbl, + OPd_u32, CLIBdblulng, +#if TARGET_WINDOS + OPu32_d, CLIBulngdbl, +#endif + OPd_s64, CLIBdblllng, + OPs64_d, CLIBllngdbl, + OPd_u64, CLIBdblullng, + OPu64_d, CLIBullngdbl, + OPd_f, CLIBdblflt, + OPf_d, CLIBfltdbl, +#if TARGET_SEGMENTED + OPvp_fp, CLIBvptrfptr, + OPcvp_fp, CLIBcvptrfptr, +#endif + }; + +//printf("cdcnvt: *pretregs = %s\n", regm_str(*pretregs)); +//elem_print(e); + + if (!*pretregs) + return codelem(e->E1,pretregs,FALSE); + if (config.inline8087) + { switch (e->Eoper) + { + case OPld_d: + case OPd_ld: + if (tycomplex(e->E1->Ety)) + { + Lcomplex: + retregs = mST01 | (*pretregs & mPSW); + c1 = codelem(e->E1, &retregs, FALSE); + c2 = fixresult_complex87(e, retregs, pretregs); + return cat(c1, c2); + } + retregs = mST0 | (*pretregs & mPSW); + c1 = codelem(e->E1, &retregs, FALSE); + c2 = fixresult87(e, retregs, pretregs); + return cat(c1, c2); + + case OPf_d: + case OPd_f: + if (config.fpxmmregs && *pretregs & XMMREGS) + return xmmcnvt(e, pretregs); + + /* if won't do us much good to transfer back and */ + /* forth between 8088 registers and 8087 registers */ + if (OTcall(e->E1->Eoper) && !(*pretregs & allregs)) + { + retregs = regmask(e->E1->Ety, e->E1->E1->Ety); + if (retregs & (mXMM1 | mXMM0 |mST01 | mST0)) // if return in ST0 + { + c1 = codelem(e->E1,pretregs,FALSE); + if (*pretregs & mST0) + note87(e, 0, 0); + return c1; + } + else + break; + } + if (tycomplex(e->E1->Ety)) + goto Lcomplex; + goto Lload87; + + case OPs64_d: + if (!I64) + goto Lload87; + /* FALL-THROUGH */ + case OPs32_d: + if (config.fpxmmregs && *pretregs & XMMREGS) + return xmmcnvt(e, pretregs); + /* FALL-THROUGH */ + case OPs16_d: + case OPu16_d: + Lload87: + return load87(e,0,pretregs,NULL,-1); + case OPu32_d: + if (I64 && config.fpxmmregs && *pretregs & XMMREGS) + return xmmcnvt(e,pretregs); + else if (!I16) + { + unsigned retregs = ALLREGS; + c1 = codelem(e->E1, &retregs, FALSE); + unsigned reg = findreg(retregs); + c1 = genfltreg(c1, 0x89, reg, 0); + regwithvalue(c1,ALLREGS,0,®,0); + genfltreg(c1, 0x89, reg, 4); + + cat(c1, push87()); + genfltreg(c1,0xDF,5,0); // FILD m64int + + retregs = mST0 /*| (*pretregs & mPSW)*/; + c2 = fixresult87(e, retregs, pretregs); + return cat(c1, c2); + } + break; + case OPd_s64: + if (!I64) + goto Lcnvt87; + /* FALL-THROUGH */ + case OPd_s32: + if (config.fpxmmregs) + return xmmcnvt(e,pretregs); + /* FALL-THROUGH */ + case OPd_s16: + case OPd_u16: + Lcnvt87: + return cnvt87(e,pretregs); + case OPd_u32: // use subroutine, not 8087 +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + retregs = mST0; +#else + retregs = DOUBLEREGS; +#endif + goto L1; + + case OPd_u64: + retregs = DOUBLEREGS; + goto L1; + case OPu64_d: + if (*pretregs & mST0) + { + retregs = I64 ? mAX : mAX|mDX; + c1 = codelem(e->E1,&retregs,FALSE); + c2 = callclib(e,CLIBu64_ldbl,pretregs,0); + return cat(c1,c2); + } + break; + case OPld_u64: + retregs = mST0; + c1 = codelem(e->E1,&retregs,FALSE); + c2 = callclib(e,CLIBld_u64,pretregs,0); + return cat(c1,c2); + } + } + retregs = regmask(e->E1->Ety, TYnfunc); +L1: + c1 = codelem(e->E1,&retregs,FALSE); + for (i = 0; 1; i++) + { assert(i < arraysize(clib)); + if (clib[i][0] == e->Eoper) + { c2 = callclib(e,clib[i][1],pretregs,0); + break; + } + } + return cat(c1,c2); +} + + +/*************************** + * Convert short to long. + * For OPs16_32, OPu16_32, OPnp_fp, OPu32_64, OPs32_64 + */ + +code *cdshtlng(elem *e,regm_t *pretregs) +{ code *c,*ce,*c1,*c2,*c3,*c4; + unsigned reg; + regm_t retregs; + + //printf("cdshtlng(e = %p, *pretregs = %s)\n", e, regm_str(*pretregs)); + int e1comsub = e->E1->Ecount; + unsigned char op = e->Eoper; + if ((*pretregs & (ALLREGS | mBP)) == 0) // if don't need result in regs + c = codelem(e->E1,pretregs,FALSE); /* then conversion isn't necessary */ + + else if ( +#if TARGET_SEGMENTED + op == OPnp_fp || +#endif + (I16 && op == OPu16_32) || + (I32 && op == OPu32_64) + ) + { + regm_t regm; + tym_t tym1; + + retregs = *pretregs & mLSW; + assert(retregs); + tym1 = tybasic(e->E1->Ety); + c = codelem(e->E1,&retregs,FALSE); + + regm = *pretregs & (mMSW & ALLREGS); + if (regm == 0) /* *pretregs could be mES */ + regm = mMSW & ALLREGS; + ce = allocreg(®m,®,TYint); + if (e1comsub) + ce = cat(ce,getregs(retregs)); +#if TARGET_SEGMENTED + if (op == OPnp_fp) + { int segreg; + + /* BUG: what about pointers to functions? */ + switch (tym1) + { + case TYnptr: segreg = SEG_DS; break; + case TYcptr: segreg = SEG_CS; break; + case TYsptr: segreg = SEG_SS; break; + default: assert(0); + } + ce = gen2(ce,0x8C,modregrm(3,segreg,reg)); /* MOV reg,segreg */ + } + else +#endif + ce = movregconst(ce,reg,0,0); /* 0 extend */ + + c = cat3(c,ce,fixresult(e,retregs | regm,pretregs)); + } + else if (I64 && op == OPu32_64) + { + elem *e1 = e->E1; + retregs = *pretregs; + if (e1->Eoper == OPvar || (e1->Eoper == OPind && !e1->Ecount)) + { code cs; + + c1 = allocreg(&retregs,®,TYint); + c2 = NULL; + c3 = loadea(e1,&cs,0x8B,reg,0,retregs,retregs); // MOV Ereg,EA + freenode(e1); + } + else + { + *pretregs &= ~mPSW; // flags are set by eval of e1 + c1 = codelem(e1,&retregs,FALSE); + c2 = getregs(retregs); + reg = findreg(retregs); + c3 = genregs(NULL,0x89,reg,reg); // MOV Ereg,Ereg + } + c4 = fixresult(e,retregs,pretregs); + c = cat4(c1,c2,c3,c4); + } + else if (!I16 && (op == OPs16_32 || op == OPu16_32) || + I64 && op == OPs32_64) + { + elem *e11; + + elem *e1 = e->E1; + + if (e1->Eoper == OPu8_16 && !e1->Ecount && + ((e11 = e1->E1)->Eoper == OPvar || (e11->Eoper == OPind && !e11->Ecount)) + ) + { code cs; + + retregs = *pretregs & BYTEREGS; + if (!retregs) + retregs = BYTEREGS; + c1 = allocreg(&retregs,®,TYint); + c2 = movregconst(NULL,reg,0,0); // XOR reg,reg + c3 = loadea(e11,&cs,0x8A,reg,0,retregs,retregs); // MOV regL,EA + freenode(e11); + freenode(e1); + } + else if (e1->Eoper == OPvar || + (e1->Eoper == OPind && !e1->Ecount)) + { code cs; + unsigned opcode; + + if (op == OPu16_32 && config.flags4 & CFG4speed) + goto L2; + retregs = *pretregs; + c1 = allocreg(&retregs,®,TYint); + opcode = (op == OPu16_32) ? 0x0FB7 : 0x0FBF; /* MOVZX/MOVSX reg,EA */ + if (op == OPs32_64) + { + assert(I64); + // MOVSXD reg,e1 + c2 = loadea(e1,&cs,0x63,reg,0,0,retregs); + code_orrex(c2, REX_W); + } + else + c2 = loadea(e1,&cs,opcode,reg,0,0,retregs); + c3 = CNIL; + freenode(e1); + } + else + { + L2: + retregs = *pretregs; + if (op == OPs32_64) + retregs = mAX | (*pretregs & mPSW); + *pretregs &= ~mPSW; /* flags are already set */ + c1 = codelem(e1,&retregs,FALSE); + c2 = getregs(retregs); + if (op == OPu16_32 && c1) + { + code *cx = code_last(c1); + if (cx->Iop == 0x81 && (cx->Irm & modregrm(3,7,0)) == modregrm(3,4,0)) + { + // Convert AND of a word to AND of a dword, zeroing upper word + retregs = mask[cx->Irm & 7]; + if (cx->Irex & REX_B) + retregs = mask[8 | (cx->Irm & 7)]; + cx->Iflags &= ~CFopsize; + cx->IEV2.Vint &= 0xFFFF; + goto L1; + } + } + if (op == OPs16_32 && retregs == mAX) + c2 = gen1(c2,0x98); /* CWDE */ + else if (op == OPs32_64 && retregs == mAX) + { c2 = gen1(c2,0x98); /* CDQE */ + code_orrex(c2, REX_W); + } + else + { + reg = findreg(retregs); + if (config.flags4 & CFG4speed && op == OPu16_32) + { // AND reg,0xFFFF + c3 = genc2(NULL,0x81,modregrmx(3,4,reg),0xFFFFu); + } + else + { + unsigned iop = (op == OPu16_32) ? 0x0FB7 : 0x0FBF; /* MOVZX/MOVSX reg,reg */ + c3 = genregs(CNIL,iop,reg,reg); + } + c2 = cat(c2,c3); + } + L1: + c3 = e1comsub ? getregs(retregs) : CNIL; + } + c4 = fixresult(e,retregs,pretregs); + c = cat4(c1,c2,c3,c4); + } + else if (*pretregs & mPSW || config.target_cpu < TARGET_80286) + { + // OPs16_32, OPs32_64 + // CWD doesn't affect flags, so we can depend on the integer + // math to provide the flags. + retregs = mAX | mPSW; // want integer result in AX + *pretregs &= ~mPSW; // flags are already set + c1 = codelem(e->E1,&retregs,FALSE); + c2 = getregs(mDX); // sign extend into DX + c2 = gen1(c2,0x99); // CWD/CDQ + c3 = e1comsub ? getregs(retregs) : CNIL; + c4 = fixresult(e,mDX | retregs,pretregs); + c = cat4(c1,c2,c3,c4); + } + else + { + // OPs16_32, OPs32_64 + unsigned msreg,lsreg; + + retregs = *pretregs & mLSW; + assert(retregs); + c1 = codelem(e->E1,&retregs,FALSE); + retregs |= *pretregs & mMSW; + c2 = allocreg(&retregs,®,e->Ety); + msreg = findregmsw(retregs); + lsreg = findreglsw(retregs); + c3 = genmovreg(NULL,msreg,lsreg); // MOV msreg,lsreg + assert(config.target_cpu >= TARGET_80286); // 8088 can't handle SAR reg,imm8 + c3 = genc2(c3,0xC1,modregrm(3,7,msreg),REGSIZE * 8 - 1); // SAR msreg,31 + c4 = fixresult(e,retregs,pretregs); + c = cat4(c1,c2,c3,c4); + } + return c; +} + + +/*************************** + * Convert byte to int. + * For OPu8_16 and OPs8_16. + */ + +code *cdbyteint(elem *e,regm_t *pretregs) +{ code *c,*c0,*c1,*c2,*c3,*c4; + regm_t retregs; + unsigned reg; + char op; + char size; + elem *e1; + + + if ((*pretregs & (ALLREGS | mBP)) == 0) // if don't need result in regs + return codelem(e->E1,pretregs,FALSE); /* then conversion isn't necessary */ + + //printf("cdbyteint(e = %p, *pretregs = %s\n", e, regm_str(*pretregs)); + op = e->Eoper; + e1 = e->E1; + c0 = NULL; + if (e1->Eoper == OPcomma) + c0 = docommas(&e1); + if (!I16) + { + if (e1->Eoper == OPvar || (e1->Eoper == OPind && !e1->Ecount)) + { code cs; + unsigned opcode; + + retregs = *pretregs; + c1 = allocreg(&retregs,®,TYint); + if (config.flags4 & CFG4speed && + op == OPu8_16 && mask[reg] & BYTEREGS && + config.target_cpu < TARGET_PentiumPro) + { + c2 = movregconst(NULL,reg,0,0); // XOR reg,reg + c3 = loadea(e1,&cs,0x8A,reg,0,retregs,retregs); // MOV regL,EA + } + else + { + opcode = (op == OPu8_16) ? 0x0FB6 : 0x0FBE; // MOVZX/MOVSX reg,EA + c2 = loadea(e1,&cs,opcode,reg,0,0,retregs); + c3 = CNIL; + } + freenode(e1); + goto L2; + } + size = tysize(e->Ety); + retregs = *pretregs & BYTEREGS; + if (retregs == 0) + retregs = BYTEREGS; + retregs |= *pretregs & mPSW; + *pretregs &= ~mPSW; + } + else + { + if (op == OPu8_16) /* if unsigned conversion */ + { + retregs = *pretregs & BYTEREGS; + if (retregs == 0) + retregs = BYTEREGS; + } + else + { + /* CBW doesn't affect flags, so we can depend on the integer */ + /* math to provide the flags. */ + retregs = mAX | (*pretregs & mPSW); /* want integer result in AX */ + } + } + + c3 = CNIL; + c1 = codelem(e1,&retregs,FALSE); + reg = findreg(retregs); + if (!c1) + goto L1; + + for (c = c1; c->next; c = c->next) + ; /* find previous instruction */ + + /* If previous instruction is an AND bytereg,value */ + if (c->Iop == 0x80 && c->Irm == modregrm(3,4,reg & 7) && + (op == OPu8_16 || (c->IEV2.Vuns & 0x80) == 0)) + { + if (*pretregs & mPSW) + c->Iflags |= CFpsw; + c->Iop |= 1; /* convert to word operation */ + c->IEV2.Vuns &= 0xFF; /* dump any high order bits */ + *pretregs &= ~mPSW; /* flags already set */ + } + else + { + L1: + if (!I16) + { + if (op == OPs8_16 && reg == AX && size == 2) + { c3 = gen1(c3,0x98); /* CBW */ + c3->Iflags |= CFopsize; /* don't do a CWDE */ + } + else + { + /* We could do better by not forcing the src and dst */ + /* registers to be the same. */ + + if (config.flags4 & CFG4speed && op == OPu8_16) + { // AND reg,0xFF + c3 = genc2(c3,0x81,modregrmx(3,4,reg),0xFF); + } + else + { + unsigned iop = (op == OPu8_16) ? 0x0FB6 : 0x0FBE; // MOVZX/MOVSX reg,reg + c3 = genregs(c3,iop,reg,reg); + if (I64 && reg >= 4) + code_orrex(c3, REX); + } + } + } + else + { + if (op == OPu8_16) + c3 = genregs(c3,0x30,reg+4,reg+4); // XOR regH,regH + else + { + c3 = gen1(c3,0x98); /* CBW */ + *pretregs &= ~mPSW; /* flags already set */ + } + } + } + c2 = getregs(retregs); +L2: + c4 = fixresult(e,retregs,pretregs); + return cat6(c0,c1,c2,c3,c4,NULL); +} + + +/*************************** + * Convert long to short (OP32_16). + * Get offset of far pointer (OPoffset). + * Convert int to byte (OP16_8). + * Convert long long to long (OP64_32). + * OP128_64 + */ + +code *cdlngsht(elem *e,regm_t *pretregs) +{ regm_t retregs; + code *c; + +#ifdef DEBUG + switch (e->Eoper) + { + case OP32_16: +#if TARGET_SEGMENTED + case OPoffset: +#endif + case OP16_8: + case OP64_32: + case OP128_64: + break; + + default: + assert(0); + } +#endif + + if (e->Eoper == OP16_8) + { retregs = *pretregs ? BYTEREGS : 0; + c = codelem(e->E1,&retregs,FALSE); + } + else + { if (e->E1->Eoper == OPrelconst) + c = offsetinreg(e->E1,&retregs); + else + { retregs = *pretregs ? ALLREGS : 0; + c = codelem(e->E1,&retregs,FALSE); +#if TARGET_SEGMENTED + bool isOff = e->Eoper == OPoffset; +#else + bool isOff = false; +#endif + if (I16 || + I32 && (isOff || e->Eoper == OP64_32) || + I64 && (isOff || e->Eoper == OP128_64)) + retregs &= mLSW; /* want LSW only */ + } + } + + /* We "destroy" a reg by assigning it the result of a new e, even */ + /* though the values are the same. Weakness of our CSE strategy that */ + /* a register can only hold the contents of one elem at a time. */ + if (e->Ecount) + c = cat(c,getregs(retregs)); + else + useregs(retregs); + +#ifdef DEBUG + if (!(!*pretregs || retregs)) + WROP(e->Eoper), + printf(" *pretregs = x%x, retregs = x%x, e = %p\n",*pretregs,retregs,e); +#endif + assert(!*pretregs || retregs); + return cat(c,fixresult(e,retregs,pretregs)); /* lsw only */ +} + +/********************************************** + * Get top 32 bits of 64 bit value (I32) + * or top 16 bits of 32 bit value (I16) + * or top 64 bits of 128 bit value (I64). + * OPmsw + */ + +code *cdmsw(elem *e,regm_t *pretregs) +{ regm_t retregs; + code *c; + + //printf("cdmsw(e->Ecount = %d)\n", e->Ecount); + assert(e->Eoper == OPmsw); + + retregs = *pretregs ? ALLREGS : 0; + c = codelem(e->E1,&retregs,FALSE); + retregs &= mMSW; // want MSW only + + // We "destroy" a reg by assigning it the result of a new e, even + // though the values are the same. Weakness of our CSE strategy that + // a register can only hold the contents of one elem at a time. + if (e->Ecount) + c = cat(c,getregs(retregs)); + else + useregs(retregs); + +#ifdef DEBUG + if (!(!*pretregs || retregs)) + { WROP(e->Eoper); + printf(" *pretregs = %s, retregs = %s\n",regm_str(*pretregs),regm_str(retregs)); + elem_print(e); + } +#endif + assert(!*pretregs || retregs); + return cat(c,fixresult(e,retregs,pretregs)); // msw only +} + + + +/****************************** + * Handle operators OPinp and OPoutp. + */ + +code *cdport(elem *e,regm_t *pretregs) +{ regm_t retregs; + code *c1,*c2,*c3; + unsigned char op,port; + unsigned sz; + elem *e1; + + //printf("cdport\n"); + op = 0xE4; /* root of all IN/OUT opcodes */ + e1 = e->E1; + + // See if we can use immediate mode of IN/OUT opcodes + if (e1->Eoper == OPconst && e1->EV.Vuns <= 255 && + (!evalinregister(e1) || regcon.mvar & mDX)) + { port = e1->EV.Vuns; + freenode(e1); + c1 = CNIL; + } + else + { retregs = mDX; /* port number is always DX */ + c1 = codelem(e1,&retregs,FALSE); + op |= 0x08; /* DX version of opcode */ + port = 0; // not logically needed, but + // quiets "uninitialized var" complaints + } + + if (e->Eoper == OPoutp) + { + sz = tysize(e->E2->Ety); + retregs = mAX; /* byte/word to output is in AL/AX */ + c2 = scodelem(e->E2,&retregs,((op & 0x08) ? mDX : (regm_t) 0),TRUE); + op |= 0x02; /* OUT opcode */ + } + else // OPinp + { c2 = getregs(mAX); + sz = tysize(e->Ety); + } + + if (sz != 1) + op |= 1; /* word operation */ + c3 = genc2(CNIL,op,0,port); /* IN/OUT AL/AX,DX/port */ + if (op & 1 && sz != REGSIZE) // if need size override + c3->Iflags |= CFopsize; + retregs = mAX; + return cat4(c1,c2,c3,fixresult(e,retregs,pretregs)); +} + +/************************ + * Generate code for an asm elem. + */ + +code *cdasm(elem *e,regm_t *pretregs) +{ code *c; + +#if 1 + /* Assume only regs normally destroyed by a function are destroyed */ + c = getregs((ALLREGS | mES) & ~fregsaved); +#else + /* Assume all regs are destroyed */ + c = getregs(ALLREGS | mES); +#endif + c = genasm(c,e->EV.ss.Vstring,e->EV.ss.Vstrlen); + return cat(c,fixresult(e,(I16 ? mDX | mAX : mAX),pretregs)); +} + +#if TARGET_SEGMENTED +/************************ + * Generate code for OPnp_f16p and OPf16p_np. + */ + +code *cdfar16( elem *e, regm_t *pretregs) +{ code *c; + code *c1; + code *c3; + code *cnop; + code cs; + unsigned reg; + + assert(I32); + c = codelem(e->E1,pretregs,FALSE); + reg = findreg(*pretregs); + c = cat(c,getregs(*pretregs)); /* we will destroy the regs */ + + cs.Iop = 0xC1; + cs.Irm = modregrm(3,0,reg); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL2 = FLconst; + cs.IEV2.Vuns = 16; + + c3 = gen(CNIL,&cs); /* ROL ereg,16 */ + cs.Irm |= modregrm(0,1,0); + c1 = gen(CNIL,&cs); /* ROR ereg,16 */ + cs.IEV2.Vuns = 3; + cs.Iflags |= CFopsize; + + if (e->Eoper == OPnp_f16p) + { + /* OR ereg,ereg + JE L1 + ROR ereg,16 + SHL reg,3 + MOV rx,SS + AND rx,3 ;mask off CPL bits + OR rl,4 ;run on LDT bit + OR regl,rl + ROL ereg,16 + L1: NOP + */ + int jop; + int byte; + unsigned rx; + regm_t retregs; + + retregs = BYTEREGS & ~*pretregs; + c = cat(c,allocreg(&retregs,&rx,TYint)); + cnop = gennop(CNIL); + jop = JCXZ; + if (reg != CX) + { + c = gentstreg(c,reg); + jop = JE; + } + c = genjmp(c,jop,FLcode,(block *)cnop); /* Jop L1 */ + NEWREG(cs.Irm,4); + gen(c1,&cs); /* SHL reg,3 */ + genregs(c1,0x8C,2,rx); /* MOV rx,SS */ + byte = (mask[reg] & BYTEREGS) == 0; + genc2(c1,0x80 | byte,modregrm(3,4,rx),3); /* AND rl,3 */ + genc2(c1,0x80,modregrm(3,1,rx),4); /* OR rl,4 */ + genregs(c1,0x0A | byte,reg,rx); /* OR regl,rl */ + } + else /* OPf16p_np */ + { + /* ROR ereg,16 + SHR reg,3 + ROL ereg,16 + */ + + cs.Irm |= modregrm(0,5,0); + gen(c1,&cs); /* SHR reg,3 */ + cnop = NULL; + } + return cat4(c,c1,c3,cnop); +} +#endif + +/************************* + * Generate code for OPbt, OPbtc, OPbtr, OPbts + */ + +code *cdbt(elem *e, regm_t *pretregs) +{ + elem *e1; + elem *e2; + code *c; + code *c2; + code cs; + regm_t idxregs; + regm_t retregs; + unsigned reg; + unsigned char word; + tym_t ty1; + int op; + int mode; + + switch (e->Eoper) + { + case OPbt: op = 0xA3; mode = 4; break; + case OPbtc: op = 0xBB; mode = 7; break; + case OPbtr: op = 0xB3; mode = 6; break; + case OPbts: op = 0xAB; mode = 5; break; + + default: + assert(0); + } + + e1 = e->E1; + e2 = e->E2; + cs.Iflags = 0; + c = getlvalue(&cs, e, RMload); // get addressing mode + if (e->Eoper == OPbt && *pretregs == 0) + return cat(c, codelem(e2,pretregs,FALSE)); + + ty1 = tybasic(e1->Ety); + word = (!I16 && tysize[ty1] == SHORTSIZE) ? CFopsize : 0; + idxregs = idxregm(&cs); // mask if index regs used + +// if (e2->Eoper == OPconst && e2->EV.Vuns < 0x100) // should do this instead? + if (e2->Eoper == OPconst) + { + cs.Iop = 0x0FBA; // BT rm,imm8 + cs.Irm |= modregrm(0,mode,0); + cs.Iflags |= CFpsw | word; + cs.IFL2 = FLconst; + if (tysize[ty1] == SHORTSIZE) + { + cs.IEVoffset1 += (e2->EV.Vuns & ~15) >> 3; + cs.IEV2.Vint = e2->EV.Vint & 15; + } + else if (tysize[ty1] == 4) + { + cs.IEVoffset1 += (e2->EV.Vuns & ~31) >> 3; + cs.IEV2.Vint = e2->EV.Vint & 31; + } + else + { + cs.IEVoffset1 += (e2->EV.Vuns & ~63) >> 3; + cs.IEV2.Vint = e2->EV.Vint & 63; + if (I64) + cs.Irex |= REX_W; + } + c2 = gen(CNIL,&cs); + } + else + { + retregs = ALLREGS & ~idxregs; + c2 = scodelem(e2,&retregs,idxregs,TRUE); + reg = findreg(retregs); + + cs.Iop = 0x0F00 | op; // BT rm,reg + code_newreg(&cs,reg); + cs.Iflags |= CFpsw | word; + c2 = gen(c2,&cs); + } + + if ((retregs = (*pretregs & (ALLREGS | mBP))) != 0) // if return result in register + { + code *nop = CNIL; + regm_t save = regcon.immed.mval; + code *cg = allocreg(&retregs,®,TYint); + regcon.immed.mval = save; + if ((*pretregs & mPSW) == 0) + { + cg = cat(cg,getregs(retregs)); + cg = genregs(cg,0x19,reg,reg); // SBB reg,reg + } + else + { + cg = movregconst(cg,reg,1,8); // MOV reg,1 + nop = gennop(nop); + cg = genjmp(cg,JC,FLcode,(block *) nop); // Jtrue nop + // MOV reg,0 + movregconst(cg,reg,0,8); + regcon.immed.mval &= ~mask[reg]; + } + *pretregs = retregs; + c2 = cat3(c2,cg,nop); + } + + return cat(c,c2); +} + +/************************************* + * Generate code for OPbsf and OPbsr. + */ + +code *cdbscan(elem *e, regm_t *pretregs) +{ + regm_t retregs; + unsigned reg; + int sz; + tym_t tyml; + code *cl,*cg; + code cs; + + //printf("cdbscan()\n"); + //elem_print(e); + if (*pretregs == 0) + return codelem(e->E1,pretregs,FALSE); + tyml = tybasic(e->E1->Ety); + sz = tysize[tyml]; + assert(sz == 2 || sz == 4 || sz == 8); + + if ((e->E1->Eoper == OPind && !e->E1->Ecount) || e->E1->Eoper == OPvar) + { + cl = getlvalue(&cs, e->E1, RMload); // get addressing mode + } + else + { + retregs = allregs; + cl = codelem(e->E1, &retregs, FALSE); + reg = findreg(retregs); + cs.Irm = modregrm(3,0,reg & 7); + cs.Iflags = 0; + cs.Irex = 0; + if (reg & 8) + cs.Irex |= REX_B; + } + + retregs = *pretregs & allregs; + if (!retregs) + retregs = allregs; + cg = allocreg(&retregs, ®, e->Ety); + + cs.Iop = (e->Eoper == OPbsf) ? 0x0FBC : 0x0FBD; // BSF/BSR reg,EA + code_newreg(&cs, reg); + if (!I16 && sz == SHORTSIZE) + cs.Iflags |= CFopsize; + cg = gen(cg,&cs); + if (sz == 8) + code_orrex(cg, REX_W); + + return cat3(cl,cg,fixresult(e,retregs,pretregs)); +} + +/******************************************* + * Generate code for OPpair, OPrpair. + */ + +code *cdpair(elem *e, regm_t *pretregs) +{ + regm_t retregs; + regm_t regs1; + regm_t regs2; + code *cg; + code *c1; + code *c2; + + if (*pretregs == 0) // if don't want result + { c1 = codelem(e->E1,pretregs,FALSE); // eval left leaf + *pretregs = 0; // in case they got set + return cat(c1,codelem(e->E2,pretregs,FALSE)); + } + + //printf("\ncdpair(e = %p, *pretregs = x%x)\n", e, *pretregs); + //printf("Ecount = %d\n", e->Ecount); + retregs = *pretregs & allregs; + if (!retregs) + retregs = allregs; + regs1 = retregs & (mLSW | mBP); + regs2 = retregs & mMSW; + if (e->Eoper == OPrpair) + { + regs1 = regs2; + regs2 = retregs & (mLSW | mBP); + } + //printf("1: regs1 = x%x, regs2 = x%x\n", regs1, regs2); + c1 = codelem(e->E1, ®s1, FALSE); + c2 = scodelem(e->E2, ®s2, regs1, FALSE); + + cg = NULL; + if (e->E1->Ecount) + cg = getregs(regs1); + if (e->E2->Ecount) + cg = cat(cg, getregs(regs2)); + + //printf("regs1 = x%x, regs2 = x%x\n", regs1, regs2); + return cat4(c1,c2,cg,fixresult(e,regs1 | regs2,pretregs)); +} + +#endif // !SPP diff --git a/backend/cod5.c b/backend/cod5.c new file mode 100644 index 00000000..1acb2de8 --- /dev/null +++ b/backend/cod5.c @@ -0,0 +1,207 @@ +// Copyright (C) 1995-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "code.h" +#include "global.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +STATIC void pe_add(block *b); +STATIC int need_prolog(block *b); + +/******************************************************** + * Determine which blocks get the function prolog and epilog + * attached to them. + */ + +void cod5_prol_epi() +{ +#if 1 + cod5_noprol(); +#else + tym_t tym; + tym_t tyf; + block *b; + block *bp; + list_t bl; + int nepis; + + tyf = funcsym_p->ty(); + tym = tybasic(tyf); + + if (!(config.flags4 & CFG4optimized) || + anyiasm || + usedalloca || + usednteh || + tyf & (mTYnaked | mTYloadds) || + tym == TYifunc || + tym == TYmfunc || // can't yet handle ECX passed as parameter + tym == TYjfunc || // can't yet handle EAX passed as parameter + config.flags & (CFGalwaysframe | CFGtrace) || +// config.fulltypes || + (config.wflags & WFwindows && tyfarfunc(tym)) || + need_prolog(startblock) + ) + { // First block gets the prolog, all return blocks + // get the epilog. + //printf("not even a candidate\n"); + cod5_noprol(); + return; + } + + // Turn on BFLoutsideprolog for all blocks outside the ones needing the prolog. + + for (b = startblock; b; b = b->Bnext) + b->Bflags &= ~BFLoutsideprolog; // start with them all off + + pe_add(startblock); + + // Look for only one block (bp) that will hold the prolog + bp = NULL; + nepis = 0; + for (b = startblock; b; b = b->Bnext) + { int mark; + + if (b->Bflags & BFLoutsideprolog) + continue; + + // If all predecessors are marked + mark = 0; + assert(b->Bpred); + for (bl = b->Bpred; bl; bl = list_next(bl)) + { + if (list_block(bl)->Bflags & BFLoutsideprolog) + { + if (mark == 2) + goto L1; + mark = 1; + } + else + { + if (mark == 1) + goto L1; + mark = 2; + } + } + if (mark == 1) + { + if (bp) // if already have one + goto L1; + bp = b; + } + + // See if b is an epilog + mark = 0; + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { + if (list_block(bl)->Bflags & BFLoutsideprolog) + { + if (mark == 2) + goto L1; + mark = 1; + } + else + { + if (mark == 1) + goto L1; + mark = 2; + } + } + if (mark == 1 || b->BC == BCret || b->BC == BCretexp) + { b->Bflags |= BFLepilog; + nepis++; + if (nepis > 1 && config.flags4 & CFG4space) + goto L1; + } + } + if (bp) + { bp->Bflags |= BFLprolog; + //printf("=============== prolog opt\n"); + } +#endif +} + +/********************************************** + * No prolog/epilog optimization. + */ + +void cod5_noprol() +{ + block *b; + + //printf("no prolog optimization\n"); + startblock->Bflags |= BFLprolog; + for (b = startblock; b; b = b->Bnext) + { + b->Bflags &= ~BFLoutsideprolog; + switch (b->BC) + { case BCret: + case BCretexp: + b->Bflags |= BFLepilog; + break; + default: + b->Bflags &= ~BFLepilog; + } + } +} + +/********************************************* + * Add block b, and its successors, to those blocks outside those requiring + * the function prolog. + */ + +STATIC void pe_add(block *b) +{ list_t bl; + + if (b->Bflags & BFLoutsideprolog || + need_prolog(b)) + return; + + b->Bflags |= BFLoutsideprolog; + for (bl = b->Bsucc; bl; bl = list_next(bl)) + pe_add(list_block(bl)); +} + +/********************************************** + * Determine if block needs the function prolog to be set up. + */ + +STATIC int need_prolog(block *b) +{ + if (b->Bregcon.used & fregsaved) + goto Lneed; + + // If block referenced a param in 16 bit code + if (!I32 && b->Bflags & BFLrefparam) + goto Lneed; + + // If block referenced a stack local + if (b->Bflags & BFLreflocal) + goto Lneed; + + return 0; + +Lneed: + return 1; +} + +#endif diff --git a/backend/code.c b/backend/code.c new file mode 100644 index 00000000..d4bd41bc --- /dev/null +++ b/backend/code.c @@ -0,0 +1,136 @@ +// Copyright (C) 1987-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include "cc.h" +#include "el.h" +#include "code.h" +#include "global.h" + +static code *code_list; + +/***************** + * Allocate code + */ + +#if SCPP && __SC__ && __INTSIZE == 4 && TX86 && !_DEBUG_TRACE && !MEM_DEBUG + +__declspec(naked) code *code_calloc() +{ + if (sizeof(code) != 0x28) + util_assert("code",__LINE__); + __asm + { + mov EAX,code_list + test EAX,EAX + je L20 + mov ECX,[EAX] + mov code_list,ECX + jmp L29 + +L20: push sizeof(code) + call mem_fmalloc + ;add ESP,4 +L29: + xor ECX,ECX + mov DWORD PTR [EAX],0 + + mov 4[EAX],ECX ;these pair + mov 8[EAX],ECX + + mov 12[EAX],ECX + mov 16[EAX],ECX + + mov 20[EAX],ECX + mov 24[EAX],ECX + + mov 28[EAX],ECX + mov 32[EAX],ECX + + mov 36[EAX],ECX + + ret + } +} + +#else + +code *code_calloc() +{ code *c; + static code czero; + + //printf("code %x\n", sizeof(code)); + c = code_list; + if (c) + code_list = code_next(c); + else + c = (code *)mem_fmalloc(sizeof(*c)); + *c = czero; // zero it out + //dbg_printf("code_calloc: %p\n",c); + return c; +} + +#endif + +/***************** + * Free code + */ + +void code_free(code *cstart) +{ code **pc; + code *c; + + for (pc = &cstart; (c = *pc) != NULL; pc = &code_next(c)) + { + if (c->Iop == ASM) + { + mem_free(c->IEV1.as.bytes); + } + } + *pc = code_list; + code_list = cstart; +} + +/***************** + * Terminate code + */ + +void code_term() +{ +#if TERMCODE + code *cn; + int count = 0; + + while (code_list) + { cn = code_next(code_list); + mem_ffree(code_list); + code_list = cn; + count++; + } +#ifdef DEBUG + printf("Max # of codes = %d\n",count); +#endif +#else +#ifdef DEBUG + int count = 0; + + for (code *cn = code_list; cn; cn = code_next(cn)) + count++; + printf("Max # of codes = %d\n",count); +#endif +#endif +} + +#endif // !SPP diff --git a/backend/code.h b/backend/code.h new file mode 100644 index 00000000..8c79aef2 --- /dev/null +++ b/backend/code.h @@ -0,0 +1,1049 @@ +// Copyright (C) 1985-1996 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if __cplusplus && TX86 +extern "C" { +#endif + +#if MARS +struct LabelDsymbol; +struct Declaration; +#endif + +#define CNIL ((code *) NULL) + +/* Register definitions */ + +#define AX 0 +#define CX 1 +#define DX 2 +#define BX 3 +#define SP 4 +#define BP 5 +#define SI 6 +#define DI 7 + +#define R8 8 +#define R9 9 +#define R10 10 +#define R11 11 +#define R12 12 +#define R13 13 +#define R14 14 +#define R15 15 + +#define XMM0 16 +#define XMM1 17 +#define XMM2 18 +#define XMM3 19 +#define XMM4 20 +#define XMM5 21 +#define XMM6 22 +#define XMM7 23 +/* There are also XMM8..XMM14 */ +#define XMM15 31 + + +#define ES 24 +#define PSW 25 +#define STACK 26 // top of stack +#define ST0 27 // 8087 top of stack register +#define ST01 28 // top two 8087 registers; for complex types + +#define NOREG 29 // no register + +#define AL 0 +#define CL 1 +#define DL 2 +#define BL 3 +#define AH 4 +#define CH 5 +#define DH 6 +#define BH 7 + +#define mAX 1 +#define mCX 2 +#define mDX 4 +#define mBX 8 +#define mSP 0x10 +#define mBP 0x20 +#define mSI 0x40 +#define mDI 0x80 + +#define mR8 (1 << R8) +#define mR9 (1 << R9) +#define mR10 (1 << R10) +#define mR11 (1 << R11) +#define mR12 (1 << R12) +#define mR13 (1 << R13) +#define mR14 (1 << R14) +#define mR15 (1 << R15) + +#define mXMM0 (1 << XMM0) +#define mXMM1 (1 << XMM1) +#define mXMM2 (1 << XMM2) +#define mXMM3 (1 << XMM3) +#define mXMM4 (1 << XMM4) +#define mXMM5 (1 << XMM5) +#define mXMM6 (1 << XMM6) +#define mXMM7 (1 << XMM7) +#define XMMREGS (mXMM0 |mXMM1 |mXMM2 |mXMM3 |mXMM4 |mXMM5 |mXMM6 |mXMM7) + +#define mES (1 << ES) // 0x1000000 +#define mPSW (1 << PSW) // 0x2000000 + +#define mSTACK (1 << STACK) // 0x4000000 + +#define mST0 (1 << ST0) // 0x20000000 +#define mST01 (1 << ST01) // 0x40000000 + +// Flags for getlvalue (must fit in regm_t) +#define RMload (1 << 30) +#define RMstore (1 << 31) + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + // To support positional independent code, + // must be able to remove BX from available registers +extern regm_t ALLREGS; +#define ALLREGS_INIT (mAX|mBX|mCX|mDX|mSI|mDI) +#define ALLREGS_INIT_PIC (mAX|mCX|mDX|mSI|mDI) +extern regm_t BYTEREGS; +#define BYTEREGS_INIT (mAX|mBX|mCX|mDX) +#define BYTEREGS_INIT_PIC (mAX|mCX|mDX) +#else +#define ALLREGS (mAX|mBX|mCX|mDX|mSI|mDI) +#define ALLREGS_INIT ALLREGS +#undef BYTEREGS +#define BYTEREGS (mAX|mBX|mCX|mDX) +#endif + +/* We use the same IDXREGS for the 386 as the 8088, because if + we used ALLREGS, it would interfere with mMSW + */ +#define IDXREGS (mBX|mSI|mDI) + +#define FLOATREGS_64 mAX +#define FLOATREGS2_64 mDX +#define DOUBLEREGS_64 mAX +#define DOUBLEREGS2_64 mDX + +#define FLOATREGS_32 mAX +#define FLOATREGS2_32 mDX +#define DOUBLEREGS_32 (mAX|mDX) +#define DOUBLEREGS2_32 (mCX|mBX) + +#define FLOATREGS_16 (mDX|mAX) +#define FLOATREGS2_16 (mCX|mBX) +#define DOUBLEREGS_16 (mAX|mBX|mCX|mDX) + +/*#define _8087REGS (mST0|mST1|mST2|mST3|mST4|mST5|mST6|mST7)*/ + +/* Segment registers */ +#define SEG_ES 0 +#define SEG_CS 1 +#define SEG_SS 2 +#define SEG_DS 3 + +/********************* + * Masks for register pairs. + * Note that index registers are always LSWs. This is for the convenience + * of implementing far pointers. + */ + +#if 0 +// Give us an extra one so we can enregister a long +#define mMSW (mCX|mDX|mDI|mES) // most significant regs +#define mLSW (mAX|mBX|mSI) // least significant regs +#else +#define mMSW (mCX|mDX|mES) /* most significant regs */ +#define mLSW (mAX|mBX|mSI|mDI) /* least significant regs */ +#endif + +/* Return !=0 if there is a SIB byte */ +#define issib(rm) (((rm) & 7) == 4 && ((rm) & 0xC0) != 0xC0) + +#if 0 +// relocation field size is always 32bits +#define is32bitaddr(x,Iflags) (1) +#else +// +// is32bitaddr works correctly only when x is 0 or 1. This is +// true today for the current definition of I32, but if the definition +// of I32 changes, this macro will need to change as well +// +// Note: even for linux targets, CFaddrsize can be set by the inline +// assembler. +#define is32bitaddr(x,Iflags) (I64 || ((x) ^(((Iflags) & CFaddrsize) !=0))) +#endif + +/******************* + * Some instructions. + */ + +#define SEGES 0x26 +#define SEGCS 0x2E +#define SEGSS 0x36 +#define SEGDS 0x3E +#define SEGFS 0x64 +#define SEGGS 0x65 + +#define CALL 0xE8 +#define JMP 0xE9 /* Intra-Segment Direct */ +#define JMPS 0xEB /* JMP SHORT */ +#define JCXZ 0xE3 +#define LOOP 0xE2 +#define LES 0xC4 +#define LEA 0x8D + +#define JO 0x70 +#define JNO 0x71 +#define JC 0x72 +#define JB 0x72 +#define JNC 0x73 +#define JAE 0x73 +#define JE 0x74 +#define JNE 0x75 +#define JBE 0x76 +#define JA 0x77 +#define JS 0x78 +#define JNS 0x79 +#define JP 0x7A +#define JNP 0x7B +#define JL 0x7C +#define JGE 0x7D +#define JLE 0x7E +#define JG 0x7F + +/* NOP is used as a placeholder in the linked list of instructions, no */ +/* actual code will be generated for it. */ +#define NOP 0x2E /* actually CS: (we don't use 0x90 because the */ + /* silly Windows stuff wants to output 0x90's) */ + +#define ESCAPE 0x3E // marker that special information is here + // (Iop2 is the type of special information) + // (Same as DS:, but we will never generate + // a separate DS: opcode anyway) + #define ESClinnum (1 << 8) // line number information + #define ESCctor (2 << 8) // object is constructed + #define ESCdtor (3 << 8) // object is destructed + #define ESCmark (4 << 8) // mark eh stack + #define ESCrelease (5 << 8) // release eh stack + #define ESCoffset (6 << 8) // set code offset for eh + #define ESCadjesp (7 << 8) // adjust ESP by IEV2.Vint + #define ESCmark2 (8 << 8) // mark eh stack + #define ESCrelease2 (9 << 8) // release eh stack + #define ESCframeptr (10 << 8) // replace with load of frame pointer + #define ESCdctor (11 << 8) // D object is constructed + #define ESCddtor (12 << 8) // D object is destructed + #define ESCadjfpu (13 << 8) // adjust fpustackused by IEV2.Vint + +#define ASM 0x36 // string of asm bytes, actually an SS: opcode + +/********************************* + * Macros to ease generating code + * modregrm: generate mod reg r/m field + * modregxrm: reg could be R8..R15 + * modregrmx: rm could be R8..R15 + * modregxrmx: reg or rm could be R8..R15 + * NEWREG: change reg field of x to r + * genorreg: OR t,f + */ + +#define modregrm(m,r,rm) (((m)<<6)|((r)<<3)|(rm)) +#define modregxrm(m,r,rm) ((((r)&8)<<15)|modregrm((m),(r)&7,rm)) +#define modregrmx(m,r,rm) ((((rm)&8)<<13)|modregrm((m),r,(rm)&7)) +#define modregxrmx(m,r,rm) ((((r)&8)<<15)|(((rm)&8)<<13)|modregrm((m),(r)&7,(rm)&7)) + +#define NEWREXR(x,r) ((x)=((x)&~REX_R)|(((r)&8)>>1)) +#define NEWREG(x,r) ((x)=((x)&~(7<<3))|((r)<<3)) +#define code_newreg(c,r) (NEWREG((c)->Irm,(r)&7),NEWREXR((c)->Irex,(r))) + +#define genorreg(c,t,f) genregs((c),0x09,(f),(t)) + +#define REX 0x40 // REX prefix byte, OR'd with the following bits: +#define REX_W 8 // 0 = default operand size, 1 = 64 bit operand size +#define REX_R 4 // high bit of reg field of modregrm +#define REX_X 2 // high bit of sib index reg +#define REX_B 1 // high bit of rm field, sib base reg, or opcode reg + +#define VEX2_B1(ivex) \ + ( \ + ivex.r << 7 | \ + ivex.vvvv << 3 | \ + ivex.l << 2 | \ + ivex.pp \ + ) + +#define VEX3_B1(ivex) \ + ( \ + ivex.r << 7 | \ + ivex.x << 6 | \ + ivex.b << 5 | \ + ivex.mmmm \ + ) + +#define VEX3_B2(ivex) \ + ( \ + ivex.w << 7 | \ + ivex.vvvv << 3 | \ + ivex.l << 2 | \ + ivex.pp \ + ) + +/********************** + * C library routines. + * See callclib(). + */ + +enum CLIB +{ + CLIBlcmp, + CLIBlmul, + CLIBldiv, + CLIBlmod, + CLIBuldiv, + CLIBulmod, + +#if TARGET_WINDOS + CLIBdmul,CLIBddiv,CLIBdtst0,CLIBdtst0exc,CLIBdcmp,CLIBdcmpexc,CLIBdneg,CLIBdadd,CLIBdsub, + CLIBfmul,CLIBfdiv,CLIBftst0,CLIBftst0exc,CLIBfcmp,CLIBfcmpexc,CLIBfneg,CLIBfadd,CLIBfsub, +#endif + + CLIBdbllng,CLIBlngdbl,CLIBdblint,CLIBintdbl, + CLIBdbluns,CLIBunsdbl, + CLIBdblulng, +#if TARGET_WINDOS + // used the GNU way of converting unsigned long long to signed + CLIBulngdbl, +#endif + CLIBdblflt,CLIBfltdbl, + CLIBdblllng, + CLIBllngdbl, + CLIBdblullng, + CLIBullngdbl, + CLIBdtst, + CLIBvptrfptr,CLIBcvptrfptr, + + CLIB87topsw,CLIBfltto87,CLIBdblto87,CLIBdblint87,CLIBdbllng87, + CLIBftst, + CLIBfcompp, + CLIBftest, + CLIBftest0, + CLIBfdiv87, + + // Complex numbers + CLIBcmul, + CLIBcdiv, + CLIBccmp, + + CLIBu64_ldbl, + CLIBld_u64, + + CLIBMAX +}; + +/********************************** + * Code data type + */ + +union evc +{ + targ_int Vint; // also used for tmp numbers (FLtmp) + targ_uns Vuns; + targ_long Vlong; + targ_llong Vllong; + targ_size_t Vsize_t; + struct + { targ_size_t Vpointer; + int Vseg; // segment the pointer is in + }_EP; + Srcpos Vsrcpos; // source position for OPlinnum + struct elem *Vtor; // OPctor/OPdtor elem + struct block *Vswitch; // when FLswitch and we have a switch table + code *Vcode; // when code is target of a jump (FLcode) + struct block *Vblock; // when block " (FLblock) + struct + { + targ_size_t Voffset; // offset from symbol + symbol *Vsym; // pointer to symbol table (FLfunc,FLextern) + } sp; +#if MARS + struct + { + targ_size_t Voffset; // offset from symbol + Declaration *Vsym; // pointer to D symbol table + } dsp; + struct + { + targ_size_t Voffset; // offset from symbol + LabelDsymbol *Vsym; // pointer to Label + } lab; +#endif + struct + { size_t len; + char *bytes; + } as; // asm node (FLasm) +}; + +struct code +{ + code *next; + unsigned Iflags; +#define CFes 1 // generate an ES: segment override for this instr +#define CFjmp16 2 // need 16 bit jump offset (long branch) +#define CFtarg 4 // this code is the target of a jump +#define CFseg 8 // get segment of immediate value +#define CFoff 0x10 // get offset of immediate value +#define CFss 0x20 // generate an SS: segment override (not with + // CFes at the same time, though!) +#define CFpsw 0x40 // we need the flags result after this instruction +#define CFopsize 0x80 // prefix with operand size +#define CFaddrsize 0x100 // prefix with address size +#define CFds 0x200 // need DS override (not with es, ss, or cs ) +#define CFcs 0x400 // need CS override +#define CFfs 0x800 // need FS override +#define CFgs (CFcs | CFfs) // need GS override +#define CFwait 0x1000 // If I32 it indicates when to output a WAIT +#define CFselfrel 0x2000 // if self-relative +#define CFunambig 0x4000 // indicates cannot be accessed by other addressing + // modes +#define CFtarg2 0x8000 // like CFtarg, but we can't optimize this away +#define CFvolatile 0x10000 // volatile reference, do not schedule +#define CFclassinit 0x20000 // class init code +#define CFoffset64 0x40000 // offset is 64 bits +#define CFpc32 0x80000 // I64: PC relative 32 bit fixup + +#define CFvex 0x100000 // vex prefix +#define CFvex3 0x200000 // 3 byte vex prefix + +#define CFPREFIX (CFSEG | CFopsize | CFaddrsize) +#define CFSEG (CFes | CFss | CFds | CFcs | CFfs | CFgs) + + union { + unsigned _Iop; + struct { +#pragma pack(1) + unsigned char op; + unsigned short pp : 2; + unsigned short l : 1; + unsigned short vvvv : 4; + unsigned short w : 1; + unsigned short mmmm : 5; + unsigned short b : 1; + unsigned short x : 1; + unsigned short r : 1; + unsigned char pfx; // always 0xC4 +#pragma pack() + } _Ivex; + } _OP; + + /* The _EA is the "effective address" for the instruction, and consists of the modregrm byte, + * the sib byte, and the REX prefix byte. The 16 bit code generator just used the modregrm, + * the 32 bit x86 added the sib, and the 64 bit one added the rex. + */ + union + { unsigned _Iea; + struct + { + unsigned char _Irm; // reg/mode + unsigned char _Isib; // SIB byte + unsigned char _Irex; // REX prefix + } _ea; + } _EA; + +#define Iop _OP._Iop +#define Ivex _OP._Ivex +#define Iea _EA._Iea +#define Irm _EA._ea._Irm +#define Isib _EA._ea._Isib +#define Irex _EA._ea._Irex + + + /* IFL1 and IEV1 are the first operand, which usually winds up being the offset to the Effective + * Address. IFL1 is the tag saying which variant type is in IEV1. IFL2 and IEV2 is the second + * operand, usually for immediate instructions. + */ + + unsigned char IFL1,IFL2; // FLavors of 1st, 2nd operands + union evc IEV1; // 1st operand, if any + #define IEVpointer1 IEV1._EP.Vpointer + #define IEVseg1 IEV1._EP.Vseg + #define IEVsym1 IEV1.sp.Vsym + #define IEVdsym1 IEV1.dsp.Vsym + #define IEVoffset1 IEV1.sp.Voffset + #define IEVlsym1 IEV1.lab.Vsym + #define IEVint1 IEV1.Vint + union evc IEV2; // 2nd operand, if any + #define IEVpointer2 IEV2._EP.Vpointer + #define IEVseg2 IEV2._EP.Vseg + #define IEVsym2 IEV2.sp.Vsym + #define IEVdsym2 IEV2.dsp.Vsym + #define IEVoffset2 IEV2.sp.Voffset + #define IEVlsym2 IEV2.lab.Vsym + #define IEVint2 IEV2.Vint + #define IEVllong2 IEV2.Vllong + void print(); // pretty-printer + + code() { Irex = 0; Isib = 0; } // constructor + + void orReg(unsigned reg) + { if (reg & 8) + Irex |= REX_R; + Irm |= modregrm(0, reg & 7, 0); + } + + void setReg(unsigned reg) + { + Irex &= ~REX_R; + Irm &= ~modregrm(0, 7, 0); + orReg(reg); + } +}; + +// !=0 if we have to add FWAIT to floating point ops +#define ADDFWAIT() (config.target_cpu <= TARGET_80286) + +/********************** PUBLIC FUNCTIONS *******************/ + +code *code_calloc(void); +void code_free (code *); +void code_term(void); + +#define code_next(c) ((c)->next) + +//#define code_calloc() ((code *) mem_calloc(sizeof(code))) + +typedef code *code_p; + +/********************************** + * Set value in regimmed for reg. + * NOTE: For 16 bit generator, this is always a (targ_short) sign-extended + * value. + */ + +#define regimmed_set(reg,e) \ + (regcon.immed.value[reg] = (e),regcon.immed.mval |= 1 << (reg)) + +extern con_t regcon; + +/**************************** + * Table of common subexpressions stored on the stack. + * csextab[] array of info on saved CSEs + * CSEpe pointer to saved elem + * CSEregm mask of register that was saved (so for multi- + * register variables we know which part we have) + * cstop = # of entries in table + */ + +struct CSE +{ elem *e; // pointer to elem + code csimple; // if CSEsimple, this is the code to regenerate it + regm_t regm; // mask of register stored there + char flags; // flag bytes +#define CSEload 1 // set if the CSE was ever loaded +#define CSEsimple 2 // CSE can be regenerated easilly + +// != 0 if CSE was ever loaded +#define CSE_loaded(i) (csextab[i].flags & CSEload) +}; + +/************************************ + */ + +#if TX86 +struct NDP +{ + elem *e; // which elem is stored here (NULL if none) + unsigned offset; // offset from e (used for complex numbers) + + static NDP *save; + static int savemax; // # of entries in save[] + static int savetop; // # of entries used in save[] +}; + +extern NDP _8087elems[8]; +#endif + +/************************************ + * Register save state. + */ + +extern "C++" +{ +struct REGSAVE +{ + targ_size_t off; // offset on stack + unsigned top; // high water mark + unsigned idx; // current number in use + int alignment; // 8 or 16 + + void reset() { off = 0; top = 0; idx = 0; alignment = REGSIZE; } + code *save(code *c, int reg, unsigned *pidx); + code *restore(code *c, int reg, unsigned idx); +}; +} +extern REGSAVE regsave; + +/******************************* + * As we generate code, collect information about + * what parts of NT exception handling we need. + */ + +extern unsigned usednteh; + +#define NTEH_try 1 // used _try statement +#define NTEH_except 2 // used _except statement +#define NTEHexcspec 4 // had C++ exception specification +#define NTEHcleanup 8 // destructors need to be called +#define NTEHtry 0x10 // had C++ try statement +#define NTEHcpp (NTEHexcspec | NTEHcleanup | NTEHtry) +#define EHcleanup 0x20 +#define EHtry 0x40 +#define NTEHjmonitor 0x80 // uses Jupiter monitor +#define NTEHpassthru 0x100 + +/********************** Code Generator State ***************/ + +typedef struct CGstate +{ + int stackclean; // if != 0, then clean the stack after function call +} CGstate; + +extern CGstate cgstate; + +/***********************************************************/ + +extern regm_t msavereg,mfuncreg,allregs; + +/*long cxmalloc,cxcalloc,cx1;*/ + +typedef code *cd_t (elem *e , regm_t *pretregs ); + +extern int BPRM; +extern regm_t FLOATREGS; +extern regm_t FLOATREGS2; +extern regm_t DOUBLEREGS; +extern const char datafl[],stackfl[],segfl[],flinsymtab[]; +extern char needframe,usedalloca,gotref; +extern targ_size_t localsize,Toff,Poff,Aoff, + Poffset,funcoffset, + framehandleroffset, + Aoffset,Toffset,EEoffset; +extern int Aalign; +extern int cseg; +extern int STACKALIGN; +#if TARGET_OSX +extern targ_size_t localgotoffset; +#endif + +/* cgcod.c */ +extern int pass; +#define PASSinit 0 // initial pass through code generator +#define PASSreg 1 // register assignment pass +#define PASSfinal 2 // final pass + +extern int dfoidx; +extern struct CSE *csextab; +extern unsigned cstop; +#if TX86 +extern bool floatreg; +#endif +extern targ_size_t retoffset; +extern unsigned stackpush; +extern int stackchanged; +extern int refparam; +extern int reflocal; +extern char anyiasm; +extern char calledafunc; +extern code *(*cdxxx[])(elem *,regm_t *); + +void stackoffsets(int); +void codgen (void ); +#ifdef DEBUG +unsigned findreg (regm_t regm , int line , const char *file ); +#define findreg(regm) findreg((regm),__LINE__,__FILE__) +#else +unsigned findreg (regm_t regm ); +#endif +#define findregmsw(regm) findreg((regm) & mMSW) +#define findreglsw(regm) findreg((regm) & (mLSW | mBP)) +void freenode (elem *e ); +int isregvar (elem *e , regm_t *pregm , unsigned *preg ); +#ifdef DEBUG +code *allocreg (regm_t *pretregs , unsigned *preg , tym_t tym , int line , const char *file ); +#define allocreg(a,b,c) allocreg((a),(b),(c),__LINE__,__FILE__) +#else +code *allocreg (regm_t *pretregs , unsigned *preg , tym_t tym ); +#endif +void useregs (regm_t regm ); +code *getregs (regm_t r ); +code *getregs_imm (regm_t r ); +code *cse_flush(int); +void cssave (elem *e , regm_t regm , unsigned opsflag ); +bool evalinregister (elem *e ); +regm_t getscratch(); +code *codelem (elem *e , regm_t *pretregs , bool constflag ); +code *scodelem (elem *e , regm_t *pretregs , regm_t keepmsk , bool constflag ); +const char *regm_str(regm_t rm); +int numbitsset(regm_t); + +/* cod1.c */ +extern int clib_inited; + +int isscaledindex(elem *); +int ssindex(int op,targ_uns product); +void buildEA(code *c,int base,int index,int scale,targ_size_t disp); +unsigned buildModregrm(int mod, int reg, int rm); +void andregcon (con_t *pregconsave); +void genEEcode(); +code *docommas (elem **pe ); +void gensaverestore(regm_t, code **, code **); +void gensaverestore2(regm_t regm,code **csave,code **crestore); +code *genstackclean(code *c,unsigned numpara,regm_t keepmsk); +code *logexp (elem *e , int jcond , unsigned fltarg , code *targ ); +code *loadea (elem *e , code *cs , unsigned op , unsigned reg , targ_size_t offset , regm_t keepmsk , regm_t desmsk ); +unsigned getaddrmode (regm_t idxregs ); +void setaddrmode(code *c, regm_t idxregs); +void getlvalue_msw(code *); +void getlvalue_lsw(code *); +code *getlvalue (code *pcs , elem *e , regm_t keepmsk ); +code *fltregs (code *pcs , tym_t tym ); +code *tstresult (regm_t regm , tym_t tym , unsigned saveflag ); +code *fixresult (elem *e , regm_t retregs , regm_t *pretregs ); +code *callclib (elem *e , unsigned clib , regm_t *pretregs , regm_t keepmask ); +cd_t cdfunc; +cd_t cdstrthis; +code *params(elem *, unsigned); +code *offsetinreg (elem *e , regm_t *pretregs ); +code *loaddata (elem *e , regm_t *pretregs ); + +/* cod2.c */ +int movOnly(elem *e); +regm_t idxregm(code *c); +#if TARGET_WINDOS +code *opdouble (elem *e , regm_t *pretregs , unsigned clib ); +#endif +cd_t cdorth; +cd_t cdmul; +cd_t cdnot; +cd_t cdcom; +cd_t cdbswap; +cd_t cdcond; +void WRcodlst (code *c ); +cd_t cdcomma; +cd_t cdloglog; +cd_t cdshift; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +cd_t cdindpic; +#endif +cd_t cdind; +cd_t cdstrlen; +cd_t cdstrcmp; +cd_t cdstrcpy; +cd_t cdmemchr; +cd_t cdmemcmp; +cd_t cdmemcpy; +cd_t cdmemset; +cd_t cdstreq; +cd_t cdrelconst; +code *getoffset (elem *e , unsigned reg ); +cd_t cdneg; +cd_t cdabs; +cd_t cdpost; +cd_t cderr; +cd_t cdinfo; +cd_t cddctor; +cd_t cdddtor; +cd_t cdctor; +cd_t cddtor; +cd_t cdmark; +cd_t cdnullcheck; +cd_t cdclassinit; + +/* cod3.c */ +extern int BPoff; + +int cod3_EA(code *c); +regm_t cod3_useBP(); +void cod3_set32 (void ); +void cod3_set64 (void ); +void cod3_align (void ); +regm_t regmask(tym_t tym, tym_t tyf); +void outblkexitcode(block *bl, code*& c, int& anyspill, const char* sflsave, symbol** retsym, const regm_t mfuncregsave ); +void doswitch (block *b ); +void outjmptab (block *b ); +void outswitab (block *b ); +int jmpopcode (elem *e ); +void cod3_ptrchk(code **pc,code *pcs,regm_t keepmsk); +code *genregs (code *c , unsigned op , unsigned dstreg , unsigned srcreg ); +code *gentstreg (code *c , unsigned reg ); +code *genpush (code *c , unsigned reg ); +code *genpop (code *c , unsigned reg ); +code* gensavereg(unsigned& reg, targ_uns slot); +code *genmovreg (code *c , unsigned to , unsigned from ); +code *genmulimm(code *c,unsigned r1,unsigned r2,targ_int imm); +code *genshift(code *); +code *movregconst (code *c , unsigned reg , targ_size_t value , regm_t flags ); +code *genjmp (code *c , unsigned op , unsigned fltarg , block *targ ); +code *prolog (void ); +void epilog (block *b); +code *gen_spill_reg(Symbol *s, bool toreg); +cd_t cdframeptr; +cd_t cdgot; +code *load_localgot(); +targ_size_t cod3_spoff(); +code *cod3_load_got(); +void makeitextern (symbol *s ); +void fltused(void); +int branch(block *bl, int flag); +void cod3_adjSymOffsets(); +void assignaddr (block *bl ); +void assignaddrc (code *c ); +targ_size_t cod3_bpoffset(symbol *s); +void pinholeopt (code *c , block *bn ); +void jmpaddr (code *c ); +int code_match(code *c1,code *c2); +unsigned calcblksize (code *c); +unsigned calccodsize(code *c); +unsigned codout (code *c ); +void addtofixlist (symbol *s , targ_size_t soffset , int seg , targ_size_t val , int flags ); +void searchfixlist (symbol *s ); +void outfixlist (void ); +void code_hydrate(code **pc); +void code_dehydrate(code **pc); + +/* cod4.c */ +extern const unsigned dblreg[]; +extern int cdcmp_flag; + +int doinreg(symbol *s, elem *e); +code *modEA(code *c); +cd_t cdeq; +cd_t cdaddass; +cd_t cdmulass; +cd_t cdshass; +cd_t cdcmp; +cd_t cdcnvt; +cd_t cdshtlng; +cd_t cdbyteint; +cd_t cdlngsht; +cd_t cdmsw; +cd_t cdport; +cd_t cdasm; +cd_t cdsetjmp; +cd_t cdvoid; +cd_t cdhalt; +cd_t cdfar16; +cd_t cdbt; +cd_t cdbscan; +cd_t cdpair; +code *longcmp (elem *,bool,unsigned,code *); + +/* cod5.c */ +void cod5_prol_epi(); +void cod5_noprol(); + +/* cgxmm.c */ +code *movxmmconst(unsigned reg, unsigned sz, targ_size_t value, regm_t flags); +code *orthxmm(elem *e, regm_t *pretregs); +code *xmmeq(elem *e, regm_t *pretregs); +code *xmmcnvt(elem *e,regm_t *pretregs); +code *xmmopass(elem *e, regm_t *pretregs); +code *xmmneg(elem *e, regm_t *pretregs); +unsigned xmmload(tym_t tym); +unsigned xmmstore(tym_t tym); +code *cdvector(elem *e, regm_t *pretregs); + +/* cg87.c */ +void note87(elem *e, unsigned offset, int i); +#ifdef DEBUG +void pop87(int, const char *); +#else +void pop87(); +#endif +code *push87 (void ); +code *save87 (void ); +code *save87regs(unsigned n); +void gensaverestore87(regm_t, code **, code **); +code *genfltreg(code *c,unsigned opcode,unsigned reg,targ_size_t offset); +code *genfwait(code *c); +code *comsub87(elem *e, regm_t *pretregs); +code *fixresult87 (elem *e , regm_t retregs , regm_t *pretregs ); +code *fixresult_complex87(elem *e,regm_t retregs,regm_t *pretregs); +code *orth87 (elem *e , regm_t *pretregs ); +code *load87(elem *e, unsigned eoffset, regm_t *pretregs, elem *eleft, int op); +int cmporder87 (elem *e ); +code *eq87 (elem *e , regm_t *pretregs ); +code *complex_eq87 (elem *e , regm_t *pretregs ); +code *opass87 (elem *e , regm_t *pretregs ); +code *cdnegass87 (elem *e , regm_t *pretregs ); +code *post87 (elem *e , regm_t *pretregs ); +code *cnvt87 (elem *e , regm_t *pretregs ); +code *cnvteq87 (elem *e , regm_t *pretregs ); +cd_t cdrndtol; +cd_t cdscale; +code *neg87 (elem *e , regm_t *pretregs ); +code *neg_complex87(elem *e, regm_t *pretregs); +code *cdind87(elem *e,regm_t *pretregs); +#if TX86 +extern int stackused; +#endif +code *cdconvt87(elem *e, regm_t *pretregs); +code *cload87(elem *e, regm_t *pretregs); + +#ifdef DEBUG +#define pop87() pop87(__LINE__,__FILE__) +#endif + +/* iasm.c */ +void iasm_term( void ); +regm_t iasm_regs( block *bp ); + +// nteh.c +code *nteh_prolog(void); +code *nteh_epilog(void); +void nteh_usevars(void); +void nteh_filltables(void); +void nteh_gentables(void); +code *nteh_setsp(int op); +code *nteh_filter(block *b); +void nteh_framehandler(symbol *); +code *nteh_gensindex(int); +#define GENSINDEXSIZE 7 +code *nteh_monitor_prolog(Symbol *shandle); +code *nteh_monitor_epilog(regm_t retregs); + +// cgen.c +code *code_last(code *c); +void code_orflag(code *c,unsigned flag); +void code_orrex(code *c,unsigned rex); +code *setOpcode(code *c, code *cs, unsigned op); +code * __pascal cat (code *c1 , code *c2 ); +code * cat3 (code *c1 , code *c2 , code *c3 ); +code * cat4 (code *c1 , code *c2 , code *c3 , code *c4 ); +code * cat6 (code *c1 , code *c2 , code *c3 , code *c4 , code *c5 , code *c6 ); +code *gen (code *c , code *cs ); +code *gen1 (code *c , unsigned op ); +code *gen2 (code *c , unsigned op , unsigned rm ); +code *gen2sib(code *c,unsigned op,unsigned rm,unsigned sib); +code *genasm (code *c , char *s , unsigned slen ); +code *gencsi (code *c , unsigned op , unsigned rm , unsigned FL2 , SYMIDX si ); +code *gencs (code *c , unsigned op , unsigned rm , unsigned FL2 , symbol *s ); +code *genc2 (code *c , unsigned op , unsigned rm , targ_size_t EV2 ); +code *genc1 (code *c , unsigned op , unsigned rm , unsigned FL1 , targ_size_t EV1 ); +code *genc (code *c , unsigned op , unsigned rm , unsigned FL1 , targ_size_t EV1 , unsigned FL2 , targ_size_t EV2 ); +code *genlinnum(code *,Srcpos); +void cgen_linnum(code **pc,Srcpos srcpos); +void cgen_prelinnum(code **pc,Srcpos srcpos); +code *genadjesp(code *c, int offset); +code *genadjfpu(code *c, int offset); +code *gennop(code *); +code *gencodelem(code *c,elem *e,regm_t *pretregs,bool constflag); +bool reghasvalue (regm_t regm , targ_size_t value , unsigned *preg ); +code *regwithvalue (code *c , regm_t regm , targ_size_t value , unsigned *preg , regm_t flags ); + +// cgreg.c +void cgreg_init(); +void cgreg_term(); +void cgreg_reset(); +void cgreg_used(unsigned bi,regm_t used); +void cgreg_spillreg_prolog(block *b,Symbol *s,code **pcstore,code **pcload); +void cgreg_spillreg_epilog(block *b,Symbol *s,code **pcstore,code **pcload); +int cgreg_assign(Symbol *retsym); +void cgreg_unregister(regm_t conflict); + +// cgsched.c +void cgsched_block(block *b); + +// Data and code can be in any number of sections +// +// Generalize the Windows platform concept of CODE,DATA,UDATA,etc +// into multiple segments + +#if OMFOBJ + +struct Ledatarec; + +struct seg_data +{ + int SDseg; // index into SegData[] + targ_size_t SDoffset; // starting offset for data + + bool isfarseg; + int segidx; // internal object file segment number + int lnameidx; // lname idx of segment name + int classidx; // lname idx of class name + unsigned attr; // segment attribute + targ_size_t origsize; // original size + long seek; // seek position in output file + Ledatarec *ledata; // current one we're filling in +}; + +//extern targ_size_t Coffset; + +#endif + +#if ELFOBJ || MACHOBJ + +typedef unsigned int IDXSTR; +typedef unsigned int IDXSEC; +typedef unsigned int IDXSYM; + +struct linnum_data +{ + const char *filename; + unsigned filenumber; // corresponding file number for DW_LNS_set_file + + unsigned linoff_count; + unsigned linoff_max; + unsigned (*linoff)[2]; // [0] = line number, [1] = offset +}; + +struct seg_data +{ + int SDseg; // segment index into SegData[] + IDXSEC SDshtidx; // section header table index + targ_size_t SDoffset; // starting offset for data + Outbuffer *SDbuf; // buffer to hold data + Outbuffer *SDrel; // buffer to hold relocation info +#if ELFOBJ + IDXSYM SDsymidx; // each section is in the symbol table + IDXSEC SDrelidx; // section header for relocation info + targ_size_t SDrelmaxoff; // maximum offset encountered + int SDrelindex; // maximum offset encountered + int SDrelcnt; // number of relocations added + IDXSEC SDshtidxout; // final section header table index + Symbol *SDsym; // if !=NULL, comdat symbol +#endif + + unsigned SDaranges_offset; // if !=0, offset in .debug_aranges + + unsigned SDlinnum_count; + unsigned SDlinnum_max; + linnum_data *SDlinnum_data; // array of line number / offset data + + int isCode(); +}; + + +#endif + +extern seg_data **SegData; +#define Offset(seg) SegData[seg]->SDoffset +#define Doffset SegData[DATA]->SDoffset +#define CDoffset SegData[CDATA]->SDoffset +#define Coffset SegData[cseg]->SDoffset + +#if __cplusplus && TX86 +} +#endif + diff --git a/backend/cppman.c b/backend/cppman.c new file mode 100644 index 00000000..bcb82357 --- /dev/null +++ b/backend/cppman.c @@ -0,0 +1,746 @@ +// Copyright (C) 1987-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/* C++ name mangling routines */ + +#include +#include +#include +#include "cc.h" + +#if !NEWMANGLE + +#define NEW_UNMANGLER 1 + +#include "parser.h" +#include "token.h" +#include "global.h" +#include "oper.h" +#include "el.h" +#include "type.h" +#include "cpp.h" +#include "filespec.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +//char *cpp_name = NULL; +char cpp_name[2 * IDMAX + 1] = { 0 }; + +/* Names for special variables */ +char cpp_name_new[] = "__nw"; +char cpp_name_delete[] = "__dl"; +char cpp_name_ct[] = "__ct"; +char cpp_name_dt[] = "__dt"; +char cpp_name_as[] = "__as"; +char cpp_name_vc[] = "__vc"; +char cpp_name_primdt[] = "__pd"; +char cpp_name_scaldeldt[] = "__sd"; +static symbol *ssymbol; + +/**************************** + */ + +struct OPTABLE oparray[] = +{ + { TKnew, OPnew, cpp_name_new, "new" }, + { TKdelete, OPdelete, cpp_name_delete,"del" }, + { TKadd, OPadd, "__pl", "+" }, + { TKadd, OPuadd, "__pl", "+" }, + { TKmin, OPmin, "__mi", "-" }, + { TKmin, OPneg, "__mi", "-" }, + { TKstar, OPmul, "__ml", "*" }, + { TKstar, OPind, "__ml", "*" }, + { TKdiv, OPdiv, "__dv", "/" }, + { TKmod, OPmod, "__md", "%" }, + { TKxor, OPxor, "__er", "^" }, + { TKand, OPand, "__ad", "&" }, + { TKand, OPaddr, "__ad", "&" }, + { TKor, OPor, "__or", "|" }, + { TKcom, OPcom, "__co", "~" }, + { TKnot, OPnot, "__nt", "!" }, + { TKeq, OPeq, "__as", "=" }, + { TKeq, OPstreq, "__as", "=" }, + { TKlt, OPlt, "__lt", "<" }, + { TKgt, OPgt, "__gt", ">" }, + { TKunord, OPunord, "__uno", "!<>=" }, + { TKlg, OPlg, "__lg", "<>" }, + { TKleg, OPleg, "__leg", "<>=" }, + { TKule, OPule, "__ule", "!>" }, + { TKul, OPul, "__ul", "!>=" }, + { TKuge, OPuge, "__uge", "!<" }, + { TKug, OPug, "__ug", "!<=" }, + { TKue, OPue, "__ue", "!<>" }, + { TKaddass, OPaddass, "__apl", "+=" }, + { TKminass, OPminass, "__ami", "-=" }, + { TKmulass, OPmulass, "__amu", "*=" }, + { TKdivass, OPdivass, "__adv", "/=" }, + { TKmodass, OPmodass, "__amd", "%=" }, + { TKxorass, OPxorass, "__aer", "^=" }, + { TKandass, OPandass, "__aad", "&=" }, + { TKorass, OPorass, "__aor", "|=" }, + { TKshl, OPshl, "__ls", "<<" }, + { TKshr, OPshr, "__rs", ">>" }, + { TKshrass, OPshrass, "__ars", "<<=" }, + { TKshlass, OPshlass, "__als", ">>=" }, + { TKeqeq, OPeqeq, "__eq", "==" }, + { TKne, OPne, "__ne", "!=" }, + { TKle, OPle, "__le", "<=" }, + { TKge, OPge, "__ge", ">=" }, + { TKandand, OPandand, "__aa", "&&" }, + { TKoror, OPoror, "__oo", "||" }, + { TKplpl, OPpostinc, "__pp", "++" }, + { TKplpl, OPpreinc, "__pp", "++" }, + { TKmimi, OPpostdec, "__mm", "--" }, + { TKmimi, OPpredec, "__mm", "--" }, + { TKlpar, OPcall, "__cl", "()" }, + { TKlbra, OPbrack, "__vc", "[]" }, + { TKarrow, OParrow, "__rf", "->" }, + { TKcomma, OPcomma, "__cm", "," }, + { TKarrowstar, OParrowstar, "__rm", "->*" }, +}; + +/*********************************** + * Cat together two names into a static buffer. + * n1 can be the same as the static buffer. + */ + + +char *cpp_catname(char *n1,char *n2) +{ + static char cpp_name[IDMAX + 1]; + +#ifdef DEBUG + assert(n1 && n2); +#endif + if (strlen(n1) + strlen(n2) >= sizeof(cpp_name)) + { +#if SCPP + lexerr(EM_ident2big); // identifier is too long +#else + assert(0); +#endif + cpp_name[0] = 0; + } + else + strcat(strcpy(cpp_name,n1),n2); + return cpp_name; +} + +/*********************************** + * 'Combine' a class and a member name into one name. + */ + +char *cpp_genname(char *cl_name,char *mem_name) +{ +#if NEWMANGLE + return cpp_catname(alloca_strdup2(mem_name,cl_name),"@"); +#else + char format[2 + 3 + 1]; + + sprintf(format,"__%d",strlen(cl_name)); + return cpp_catname(cpp_catname(mem_name,format),cl_name); +#endif +} + +/**************************************** + * Convert from identifier to operator + */ + +char *cpp_unmangleident(const char *p) +{ int i; + + for (i = 0; i < arraysize(oparray); i++) + { if (strcmp(p,oparray[i].string) == 0) + { + strcpy(cpp_name,"operator "); + strcat(cpp_name,oparray[i].pretty); + p = cpp_name; + break; + } + } + return (char *)p; +} + +/**************************************** + * Find index in oparray[] for operator. + * Returns: + * index or -1 if not found + */ + +int cpp_opidx(int op) +{ int i; + + for (i = 0; i < arraysize(oparray); i++) + if (oparray[i].oper == (char) op) + return i; + return -1; +} + +/*************************************** + * Find identifier string associated with operator. + * Returns: + * NULL if not found + */ + +char *cpp_opident(int op) +{ int i; + + i = cpp_opidx(op); + return (i == -1) ? NULL : oparray[i].string; +} + +/******************************** + * 'Mangle' a name for output. + * Returns: + * pointer to mangled name (a static buffer) + */ + +char *cpp_mangle(symbol *s) +{ char *p; + symbol *sclass; + + if (!CPP) + return s->Sident; + + ssymbol = s; + + symbol_debug(s); + //dbg_printf("cpp_mangle(%s)\n",s->Sident); + p = symbol_ident(s); + sclass = s->Sscope; + if (sclass) + { symbol_debug(sclass); + p = cpp_genname(symbol_ident(sclass),p); + while (1) + { + char format[10 + 1]; + char *cl_name; + + sclass = sclass->Sscope; + if (!sclass) + break; + + cl_name = symbol_ident(sclass); + sprintf(format,"%d",strlen(cl_name)); + p = cpp_catname(cpp_catname(p,format),cl_name); + } + } + type_debug(s->Stype); + // Function symbols defined statically don't have Sfunc + if (tyfunc(s->Stype->Tty) && + s->Sfunc && s->Sfunc->Fflags & Ftypesafe) + { if (!s->Sscope) + p = cpp_catname(p,"__"); + p = cpp_typetostring(s->Stype,p); + } + /*dbg_printf("cpp_mangle(%s)\n",p);*/ + ssymbol = NULL; + return p; +} + +/********************************** + * Convert from operator token to name. + * Returns: + * pointer to corresponding name + */ + +#if SCPP + +char *cpp_operator(int *poper,type **pt) +{ + int i; + type *typ_spec; + + *pt = NULL; + stoken(); /* skip over operator keyword */ + for (i = 0; i < arraysize(oparray); i++) + { if (oparray[i].tokn == tok.TKval) + goto L1; + } + + /* Look for type conversion */ + if (type_specifier(&typ_spec,NULL ARG_FALSE)) + { type *t; + + t = ptr_operator(typ_spec); // parse ptr-operator + fixdeclar(t); + type_free(typ_spec); + *pt = t; + return cpp_typetostring(t,"__op"); + } + + cpperr(EM_not_overloadable); // that token cannot be overloaded + stoken(); + return "_"; + +L1: + *poper = oparray[i].oper; + switch (*poper) + { case OPcall: + if (stoken() != TKrpar) + synerr(EM_rpar); /* ')' expected */ + break; + case OPbrack: + if (stoken() != TKrbra) + synerrEM_rbra); /* ']' expected */ + break; + } + stoken(); + return oparray[i].string; +} + +#endif + +/*********************************** + * Generate and return a pointer to a string constructed from + * the type, appended to the prefix. + * Since these generated strings determine the uniqueness of names, + * they are also used to determine if two types are the same. + * Returns: + * pointer to static name[] + */ + +char *cpp_typetostring(type *t,char *prefix) +{ int i; + param_t *p; + type *tstart; + bool dofuncret = FALSE; /* BUG: this should be passed in */ + static int nest = 0; + symbol *s; + + if (prefix) + { strcpy(cpp_name, prefix); + i = strlen(prefix); + } + else + i = 0; + /*dbg_printf("cpp_typetostring:\n"); + type_print(t);*/ + tstart = t; + for (; t; t = t->Tnext, dofuncret = TRUE) + { char c1,c2; + int nestclass; + + type_debug(t); + if (i > IDMAX - 4) /* if not room for 4 more + 0 */ + { //cpperr(EM_type_complex); // type is too complex + assert(0); + i = 0; + } + + if (t->Tty & mTYconst) + cpp_name[i++] = 'C'; + if (t->Tty & mTYvolatile) + cpp_name[i++] = 'V'; + c1 = 0; + nestclass = 0; + /* Function return types are ignored */ + switch (tybasic(t->Tty)) + { + case TYschar: c1 = 'S'; goto L2; + case TYuchar: c1 = 'U'; goto L2; + case TYchar: L2: c2 = 'c'; break; + case TYushort: c1 = 'U'; + case TYshort: c2 = 's'; break; + case TYuint: c1 = 'U'; + case TYint: c2 = 'i'; break; +#if LONGLONG && __INTSIZE == 4 // DJB + case TYullong: c1 = 'U'; + case TYllong: c2 = 'x'; break; +#endif + case TYulong: c1 = 'U'; + case TYlong: c2 = 'l'; break; +#if M_UNIX || M_XENIX + case TYnptr: // For Gnu gdb and ARM compatibility +#endif + case TYfptr: c2 = 'P'; break; + case TYvptr: c2 = 'h'; break; + case TYfloat: c2 = 'f'; break; + case TYldouble: c2 = 'r'; break; + case TYdouble: c2 = 'd'; break; + case TYvoid: c2 = 'v'; break; +#if TX86 + case TYnref: + case TYfref: +#endif + case TYref: c2 = 'R'; break; +#if M_UNIX || M_XENIX + case TYmfunc: + case TYnfunc: + case TYnpfunc: // Near functions under Unix are coded as F + case TYnsysfunc: // see ARM page 124 +#endif + case TYfpfunc: c2 = 'F'; goto L4; +#if TX86 + case TYfsysfunc: +#endif + case TYffunc: c2 = 'D'; goto L4; +#if TX86 + case TYsptr: c2 = 'b'; break; +#if !(M_UNIX || M_XENIX) + case TYnptr: c2 = 'p'; break; +#endif + case TYcptr: c2 = 'E'; break; + case TYf16ptr: c2 = 'g'; break; + case TYf16func: c2 = 'G'; goto L4; + case TYhptr: c2 = 'H'; break; +#if !(M_UNIX || M_XENIX) + case TYnpfunc: c2 = 'N'; goto L4; + case TYmfunc: + case TYnsysfunc: + case TYnfunc: c2 = 'B'; goto L4; +#endif + case TYfsfunc: c2 = 'I'; goto L4; + case TYnsfunc: c2 = 'j'; goto L4; +#else + case TYpsfunc: c2 = 'F'; goto L4; + case TYcomp: c2 = 'o'; break; + case TYmemptr: c2 = 'm'; break; +#endif + L4: + cpp_name[i++] = c2; + if (i > IDMAX - 2) + { //cpperr(EM_type_complex); + assert(0); + i = 0; + } + /* Append the types of the parameters to the name */ + { int n; + int paramidx[10]; /* previous parameter indices */ + + n = 1; /* parameter number */ + for (p = t->Tparamtypes; p; p = p->Pnext) + { int len; + + cpp_name[i] = 0; + nest++; + cpp_typetostring(p->Ptype,cpp_name); + nest--; + len = strlen(cpp_name); + if (n < arraysize(paramidx)) + { paramidx[n] = i; + if (len - i > 2) /* only if we get real savings */ + { int j; + + /* 'common subexpression' with any previous */ + /* matching type, if match, replace with */ + /* 'T' parameter_number */ + for (j = 1; j < n; j++) + if (memcmp(&cpp_name[paramidx[j]],&cpp_name[i],len - i) == 0) + { sprintf(cpp_name + i,"T%d",j); + len = i + 2; + break; + } + } + } + if (len > IDMAX - 2) + { //cpperr(EM_type_complex); + assert(0); + len = 0; + n = 0; + } + i = len; + n++; + } + } + if (variadic(t)) + cpp_name[i++] = 'e'; + else if (t->Tflags & TFfixed && !t->Tparamtypes) + cpp_name[i++] = 'v'; /* func(void) */ + + /* Determine if function return types should be considered */ + if (dofuncret || nest) + { cpp_name[i++] = '_'; + continue; + } + else + goto L1; /* ignore what the function returns */ + +#if TX86 + case TYmemptr: + cpp_name[i++] = 'm'; +#endif + case TYstruct: + s = t->Ttag; + L6: + if (s->Sstruct->Sflags & STRnotagname) + { + s->Sstruct->Sflags &= ~STRnotagname; +#if SCPP + warerr(WM_notagname,ssymbol ? (char *)ssymbol->Sident : "Unknown" ); /* no tag name for struct */ +#endif + } + goto L5; + case TYenum: + s = t->Ttag; + if (s->Senum->SEflags & SENnotagname) + { + s->Senum->SEflags &= ~SENnotagname; +#if SCPP + warerr(WM_notagname, ssymbol ? (char *)ssymbol->Sident : "Unknown" ); /* no tag name for struct */ +#endif + } + L5: + { int len; + char *p; + + /* Append the tag to the name */ + p = symbol_ident(s); + len = strlen(p); + if (i + len + nestclass > IDMAX - sizeof(len) * 3) + { //cpperr(EM_type_complex); /* type is too complex */ + assert(0); + goto L1; + } + sprintf(cpp_name + i,("X%d%s" + 1 - nestclass),len,p); + + /* Handle nested classes */ + s = s->Sscope; + if (s) + { nestclass = 1; + i = strlen(cpp_name); + goto L6; + } + + goto L3; + } + case TYarray: + if (i > IDMAX - 1 - sizeof(t->Tdim) * 3) + { //cpperr(EM_type_complex); // type is too complex + assert(0); + goto L1; + } + sprintf(cpp_name + i,"A%d",t->Tdim); + L3: i = strlen(cpp_name); + continue; + default: + debug(type_print(t)); + assert(0); + } + if (c1) + cpp_name[i++] = c1; + cpp_name[i++] = c2; + } +L1: + cpp_name[i] = 0; // terminate the string + return cpp_name; +} + +/*********************************** + * Create mangled name for template instantiation. + */ + +#if SCPP + +char *template_mangle(symbol *s,param_t *arglist) +{ + /* mangling ::= "__PT" N template_name { type | expr } + N ::= number of characters in template_name + type ::= mangled type + expr ::= "V" value + value ::= integer | string | address | float | double | long_double | numeric  + integer ::= digit { digit } + string ::= "S" integer "_" { char } + address ::= "R" integer "_" { char } + float ::= "F" hex_digits + double ::= "D" hex_digits + long_double ::= "L" hex_digits + */ + char *n; + param_t *p; + + ssymbol = s; + + assert(s); + symbol_debug(s); + assert(s->Sclass == SCtemplate); + n = cpp_catname("__PT",unsstr(strlen((char *)s->Sident))); + n = cpp_catname(n,(char *)s->Sident); + for (p = arglist; p; p = p->Pnext) + { + if (p->Ptype) + { /* Argument is a type */ + n = cpp_typetostring(p->Ptype,n); + } + else + { /* Argument is an expression */ + elem *e = p->Pelem; + tym_t ty = tybasic(e->ET->Tty); + char *p; + char a[2]; + int ni; +#if NEW_UNMANGLER + double d; +#endif + + n = cpp_catname(n,"V"); + /*n = cpp_typetostring(e->ET,n);*/ + switch (e->Eoper) + { case OPconst: + switch (ty) + { +#if !(NEW_UNMANGLER) + case TYfloat: ni = FLOATSIZE; a[0] = 'F'; goto L1; + case TYdouble: ni = DOUBLESIZE; a[0] = 'D'; goto L1; + case TYldouble: ni = LNGDBLSIZE; a[0] = 'L'; goto L1; + L1: + a[1] = 0; + n = cpp_catname(n,a); + p = (char *)&e->EV.Vdouble; + +#elif !NEW_UNMANGLER + case TYfloat: + float f; + ni = FLOATSIZE; + a[0] = 'F'; + f = e->EV.Vfloat; + p = (char *)&f; + goto L1; + case TYdouble: + double d; + ni = tysize[TYdouble]; + a[0] = 'D'; + d = e->EV.Vdouble; + p = (char *)&d; + goto L1; + case TYldouble: + ni = tysize[TYldouble]; + a[0] = 'L'; + if (config.flags & CFGldblisdbl) + p = (char *)&e->EV.Vdouble; + else + { + d = e->EV.Vldouble; + } + p = (char *)&d; +// ni = tysize[TYdouble]; + ni = sizeof(long double); // just until new unmangler is in + L1: + a[1] = 0; + n = cpp_catname(n,a); +#endif +#if !NEW_UNMANGLER + while (ni--) + { char c; + static char hex[17] = "0123456789ABCDEF"; + static char buf[3]; + + c = *p++; + buf[0] = hex[c & 15]; + buf[1] = hex[(c >> 4) & 15]; + n = cpp_catname(n,buf); + } + break; +#else // NEW_UNMANGLER + case TYfloat: d = e->EV.Vfloat; goto L1; + case TYdouble: d = e->EV.Vdouble; goto L1; + case TYldouble: if (config.flags & CFGldblisdbl) + d = e->EV.Vdouble; + else + d = e->EV.Vldouble; + L1: char buf[32]; + n = cpp_catname(n,"N"); + ni = sprintf(buf, "%g", d); + p = buf-1; + while (ni--) + { char c; + c = *++p; + if (c == '-') + *p = 'n'; + else if (c == '+') + *p = 'p'; + else if (c == '.') + *p = 'd'; + } + p = buf; + goto L2; +#endif // NEW_UNMANGLER + default: + if (tyintegral(ty)) + { char buf[sizeof(long) * 3 + 1]; + sprintf(buf,"%lu",el_tolong(e)); + cpp_catname(n,buf); + break; + } + assert(0); + } + break; + case OPstring: + p = e->EV.ss.Vstring; + n = cpp_catname(n,"S"); + goto L2; + case OPrelconst: + p = (char *)e->EV.sp.Vsym->Sident; + n = cpp_catname(n,"R"); + L2: + n = cpp_catname(n,unsstr(strlen(p))); + n = cpp_catname(n,"_"); + n = cpp_catname(n,p); + break; + default: + assert(errcnt); + break; + } + } + } /* for */ + ssymbol = NULL; + return n; +} + +#endif + +/********************************* + * Mangle a vtbl or vbtbl name. + * Returns: + * pointer to generated symbol with mangled name + */ + +#if SCPP + +symbol *mangle_tbl( + int flag, // 0: vtbl, 1: vbtbl + type *t, // type for symbol + Classsym *stag, // class we're putting tbl in + Classsym *sbase) // base class (NULL if none) +{ const char *id; + symbol *s; + + if (flag == 0) + id = config.flags3 & CFG3rtti ? "rttivtbl" : "vtbl"; + else + id = "vbtbl"; + if (sbase) + id = cpp_genname((char *)stag->Sident,cpp_genname((char *)sbase->Sident,id)); + else + id = cpp_genname((char *)stag->Sident,id); + +// +// This can happen for MI cases, the virtual table could already be defined +// + + s = scope_search( id, SCTglobal | SCTnspace | SCTlocal ); + if (s) + return(s); + s = scope_define(id,SCTglobal | SCTnspace | SCTlocal, SCunde); + s->Stype = t; + t->Tcount++; +#if XCOFF_OBJ || CFM68K || CFMV2 + if (config.CFMOption && config.CFMxf) // cross fragment C++ + s->Scfmflags = stag->Scfmflags; // Copy the flags from the stag +#endif + return s; +} + +#endif + +#endif diff --git a/backend/cv4.h b/backend/cv4.h new file mode 100644 index 00000000..f19eeeb9 --- /dev/null +++ b/backend/cv4.h @@ -0,0 +1,126 @@ +//_ cv4.h +// Codeview 4 stuff +// See "Microsoft Symbol and Type OMF" document + +#define OEM 0x42 // Digital Mars OEM number (picked at random) + +// Symbol Indices +#define S_COMPILE 1 +#define S_REGISTER 2 +#define S_CONST 3 +#define S_UDT 4 +#define S_SSEARCH 5 +#define S_END 6 +#define S_SKIP 7 +#define S_CVRESERVE 8 +#define S_OBJNAME 9 +#define S_ENDARG 0x0A +#define S_COBOLUDT 0x0B +#define S_MANYREG 0x0C +#define S_RETURN 0x0D +#define S_ENTRYTHIS 0x0E +#define S_TDBNAME 0x0F + +#define S_BPREL16 0x100 +#define S_LDATA16 0x101 +#define S_GDATA16 0x102 +#define S_PUB16 0x103 +#define S_LPROC16 0x104 +#define S_GPROC16 0x105 +#define S_THUNK16 0x106 +#define S_BLOCK16 0x107 +#define S_WITH16 0x108 +#define S_LABEL16 0x109 +#define S_CEXMODEL16 0x10A +#define S_VFTPATH16 0x10B + +#define S_BPREL32 0x200 +#define S_LDATA32 0x201 +#define S_GDATA32 0x202 +#define S_PUB32 0x203 +#define S_LPROC32 0x204 +#define S_GPROC32 0x205 +#define S_THUNK32 0x206 +#define S_BLOCK32 0x207 +#define S_WITH32 0x208 +#define S_LABEL32 0x209 +#define S_CEXMODEL32 0x20A +#define S_VFTPATH32 0x20B + +// Leaf Indices +#define LF_MODIFIER 1 +#define LF_POINTER 2 +#define LF_ARRAY 3 +#define LF_CLASS 4 +#define LF_STRUCTURE 5 +#define LF_UNION 6 +#define LF_ENUM 7 +#define LF_PROCEDURE 8 +#define LF_MFUNCTION 9 +#define LF_VTSHAPE 0x0A +#define LF_COBOL0 0x0B +#define LF_COBOL1 0x0C +#define LF_BARRAY 0x0D +#define LF_LABEL 0x0E +#define LF_NULL 0x0F +#define LF_NOTTRAN 0x10 +#define LF_DIMARRAY 0x11 +#define LF_VFTPATH 0x12 +#define LF_PRECOMP 0x13 +#define LF_ENDPRECOMP 0x14 +#define LF_OEM 0x15 +#define LF_TYPESERVER 0x16 + +// D extensions (not used, causes linker to fail) +#define LF_DYN_ARRAY 0x17 +#define LF_ASSOC_ARRAY 0x18 +#define LF_DELEGATE 0x19 + +#define LF_SKIP 0x200 +#define LF_ARGLIST 0x201 +#define LF_DEFARG 0x202 +#define LF_LIST 0x203 +#define LF_FIELDLIST 0x204 +#define LF_DERIVED 0x205 +#define LF_BITFIELD 0x206 +#define LF_METHODLIST 0x207 +#define LF_DIMCONU 0x208 +#define LF_DIMCONLU 0x209 +#define LF_DIMVARU 0x20A +#define LF_DIMVARLU 0x20B +#define LF_REFSYM 0x20C + +#define LF_BCLASS 0x400 +#define LF_VBCLASS 0x401 +#define LF_IVBCLASS 0x402 +#define LF_ENUMERATE 0x403 +#define LF_FRIENDFCN 0x404 +#define LF_INDEX 0x405 +#define LF_MEMBER 0x406 +#define LF_STMEMBER 0x407 +#define LF_METHOD 0x408 +#define LF_NESTTYPE 0x409 +#define LF_VFUNCTAB 0x40A +#define LF_FRIENDCLS 0x40B + +#define LF_NUMERIC 0x8000 +#define LF_CHAR 0x8000 +#define LF_SHORT 0x8001 +#define LF_USHORT 0x8002 +#define LF_LONG 0x8003 +#define LF_ULONG 0x8004 +#define LF_REAL32 0x8005 +#define LF_REAL64 0x8006 +#define LF_REAL80 0x8007 +#define LF_REAL128 0x8008 +#define LF_QUADWORD 0x8009 +#define LF_UQUADWORD 0x800A +#define LF_REAL48 0x800B + +#define LF_COMPLEX32 0x800C +#define LF_COMPLEX64 0x800D +#define LF_COMPLEX80 0x800E +#define LF_COMPLEX128 0x800F + +#define LF_VARSTRING 0x8010 + diff --git a/backend/debug.c b/backend/debug.c new file mode 100644 index 00000000..f46390e1 --- /dev/null +++ b/backend/debug.c @@ -0,0 +1,415 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#ifdef DEBUG +#if !SPP + +#include +#include + +#include "cc.h" +#include "oper.h" +#include "type.h" +#include "el.h" +#include "token.h" +#include "global.h" +#include "vec.h" +#include "go.h" +#include "code.h" +#include "debtab.c" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +#define ferr(p) dbg_printf("%s",(p)) + +/******************************* + * Write out storage class. + */ + +char *str_class(enum SC c) +{ static char sc[SCMAX][10] = + { + #define X(a,b) #a, + ENUMSCMAC + #undef X + }; + static char buffer[9 + 3]; + + (void) assert(arraysize(sc) == SCMAX); + if ((unsigned) c < (unsigned) SCMAX) + sprintf(buffer,"SC%s",sc[(int) c]); + else + sprintf(buffer,"SC%u",(unsigned)c); + return buffer; +} + +void WRclass(enum SC c) +{ + dbg_printf("%11s ",str_class(c)); +} + +/*************************** + * Write out oper numbers. + */ + +void WROP(unsigned oper) +{ + if (oper >= OPMAX) + { dbg_printf("op = x%x, OPMAX = %d\n",oper,OPMAX); + assert(0); + } + ferr(debtab[oper]); + ferr(" "); +} + +/******************************* + * Write TYxxxx + */ + +void WRTYxx(tym_t t) +{ +#if TX86 + if (t & mTYnear) + dbg_printf("mTYnear|"); +#if TARGET_SEGMENTED + if (t & mTYfar) + dbg_printf("mTYfar|"); + if (t & mTYcs) + dbg_printf("mTYcs|"); +#endif +#endif + if (t & mTYconst) + dbg_printf("mTYconst|"); + if (t & mTYvolatile) + dbg_printf("mTYvolatile|"); +#if !MARS && (linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4) + if (t & mTYtransu) + dbg_printf("mTYtransu|"); +#endif + t = tybasic(t); + if (t >= TYMAX) + { dbg_printf("TY %lx\n",(long)t); + assert(0); + } + dbg_printf("TY%s ",tystring[tybasic(t)]); +} + +void WRBC(unsigned bc) +{ static char bcs[][7] = + {"unde ","goto ","true ","ret ","retexp", + "exit ","asm ","switch","ifthen","jmptab", + "try ","catch ","jump ", + "_try ","_filte","_final","_ret ","_excep", + "jcatch", + "jplace", + }; + + assert(sizeof(bcs) / sizeof(bcs[0]) == BCMAX); + assert(bc < BCMAX); + dbg_printf("BC%s",bcs[bc]); +} + +/************************ + * Write arglst + */ + +void WRarglst(list_t a) +{ int n = 1; + + if (!a) dbg_printf("0 args\n"); + while (a) + { const char* c = (const char*)list_ptr(a); + dbg_printf("arg %d: '%s'\n", n, c ? c : "NULL"); + a = a->next; + n++; + } +} + +/*************************** + * Write out equation elem. + */ + +void WReqn(elem *e) +{ static int nest; + + if (!e) + return; + if (OTunary(e->Eoper)) + { + WROP(e->Eoper); + if (OTbinary(e->E1->Eoper)) + { nest++; + ferr("("); + WReqn(e->E1); + ferr(")"); + nest--; + } + else + WReqn(e->E1); + } + else if (e->Eoper == OPcomma && !nest) + { WReqn(e->E1); + dbg_printf(";\n\t"); + WReqn(e->E2); + } + else if (OTbinary(e->Eoper)) + { + if (OTbinary(e->E1->Eoper)) + { nest++; + ferr("("); + WReqn(e->E1); + ferr(")"); + nest--; + } + else + WReqn(e->E1); + ferr(" "); + WROP(e->Eoper); + if (e->Eoper == OPstreq) + dbg_printf("%ld",(long)type_size(e->ET)); + ferr(" "); + if (OTbinary(e->E2->Eoper)) + { nest++; + ferr("("); + WReqn(e->E2); + ferr(")"); + nest--; + } + else + WReqn(e->E2); + } + else + { + switch (e->Eoper) + { case OPconst: + switch (tybasic(e->Ety)) + { + case TYfloat: + dbg_printf("%g ",e->EV.Vfloat); + break; + case TYdouble: + dbg_printf("%g ",e->EV.Vdouble); + break; + case TYldouble: + dbg_printf("%Lg ",e->EV.Vldouble); + break; + case TYcent: + case TYucent: + dbg_printf("%lld+%lld ", e->EV.Vcent.msw, e->EV.Vcent.lsw); + break; + default: + dbg_printf("%lld ",el_tolong(e)); + break; + } + break; + case OPrelconst: + ferr("#"); + /* FALL-THROUGH */ + case OPvar: + dbg_printf("%s",e->EV.sp.Vsym->Sident); + if (e->EV.sp.Vsym->Ssymnum != -1) + dbg_printf("(%d)",e->EV.sp.Vsym->Ssymnum); + if (e->Eoffset != 0) + { + if (sizeof(e->Eoffset) == 8) + dbg_printf(".x%llx", e->Eoffset); + else + dbg_printf(".%ld",(long)e->Eoffset); + } + break; + case OPasm: + case OPstring: + dbg_printf("\"%s\"",e->EV.ss.Vstring); + if (e->EV.ss.Voffset) + dbg_printf("+%ld",(long)e->EV.ss.Voffset); + break; + case OPmark: + case OPgot: + case OPframeptr: + case OPhalt: + WROP(e->Eoper); + break; + case OPstrthis: + break; + default: + WROP(e->Eoper); + assert(0); + } + } +} + +void WRblocklist(list_t bl) +{ + for (; bl; bl = list_next(bl)) + { register block *b = list_block(bl); + + if (b && b->Bweight) + dbg_printf("B%d (%p) ",b->Bdfoidx,b); + else + dbg_printf("%p ",b); + } + ferr("\n"); +} + +void WRdefnod() +{ register int i; + + for (i = 0; i < deftop; i++) + { dbg_printf("defnod[%d] in B%d = (",defnod[i].DNblock->Bdfoidx,i); + WReqn(defnod[i].DNelem); + dbg_printf(");\n"); + } +} + +void WRFL(enum FL fl) +{ static char fls[FLMAX][7] = + {"unde ","const ","oper ","func ","data ", + "reg ", + "pseudo", + "auto ","para ","extrn ","tmp ", + "code ","block ","udata ","cs ","swit ", + "fltrg ","offst ","datsg ", + "ctor ","dtor ","regsav","asm ", +#if TX86 + "ndp ", +#endif +#if TARGET_SEGMENTED + "farda ","csdat ", +#endif + "local ","tlsdat", + "bprel ","frameh","blocko","alloca", + "stack ","dsym ", +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + "got ","gotoff", +#endif + }; + + if ((unsigned)fl >= (unsigned)FLMAX) + dbg_printf("FL%d",fl); + else + dbg_printf("FL%s",fls[fl]); +} + +/*********************** + * Write out block. + */ + +void WRblock(block *b) +{ + if (OPTIMIZER) + { + if (b && b->Bweight) + dbg_printf("B%d: (%p), weight=%d",b->Bdfoidx,b,b->Bweight); + else + dbg_printf("block %p",b); + if (!b) + { ferr("\n"); + return; + } + dbg_printf(" flags=x%x weight=%d",b->Bflags,b->Bweight); +#if 0 + dbg_printf("\tfile %p, line %d",b->Bfilptr,b->Blinnum); +#endif + dbg_printf(" "); + WRBC(b->BC); + dbg_printf(" Btry=%p Bindex=%d",b->Btry,b->Bindex); +#if SCPP + if (b->BC == BCtry) + dbg_printf(" catchvar = %p",b->catchvar); +#endif + dbg_printf("\n"); + dbg_printf("\tBpred: "); WRblocklist(b->Bpred); + dbg_printf("\tBsucc: "); WRblocklist(b->Bsucc); + if (b->Belem) + { if (debugf) /* if full output */ + elem_print(b->Belem); + else + { ferr("\t"); + WReqn(b->Belem); + dbg_printf(";\n"); + } + } + if (b->Bcode) + b->Bcode->print(); + ferr("\n"); + } + else + { + targ_llong *pu; + int ncases; + list_t bl; + + assert(b); + dbg_printf("********* Basic Block %p ************\n",b); + if (b->Belem) elem_print(b->Belem); + dbg_printf("block: "); + WRBC(b->BC); + dbg_printf(" Btry=%p Bindex=%d",b->Btry,b->Bindex); + dbg_printf("\n"); + dbg_printf("\tBpred:\n"); + for (bl = b->Bpred; bl; bl = list_next(bl)) + dbg_printf("\t%p\n",list_block(bl)); + bl = b->Bsucc; + switch (b->BC) + { + case BCswitch: + pu = b->BS.Bswitch; + assert(pu); + ncases = *pu; + dbg_printf("\tncases = %d\n",ncases); + dbg_printf("\tdefault: %p\n",list_block(bl)); + while (ncases--) + { bl = list_next(bl); + dbg_printf("\tcase %lld: %p\n",*++pu,list_block(bl)); + } + break; + case BCiftrue: + case BCgoto: + case BCasm: +#if SCPP + case BCtry: + case BCcatch: +#endif + case BCjcatch: + case BC_try: + case BC_filter: + case BC_finally: + case BC_ret: + case BC_except: + + Lsucc: + dbg_printf("\tBsucc:\n"); + for ( ; bl; bl = list_next(bl)) + dbg_printf("\t%p\n",list_block(bl)); + break; + case BCret: + case BCretexp: + case BCexit: + break; + default: + assert(0); + } + } +} + +void WRfunc() +{ + block *b; + + dbg_printf("func: '%s'\n",funcsym_p->Sident); + for (b = startblock; b; b = b->Bnext) + WRblock(b); +} + +#endif /* DEBUG */ +#endif /* !SPP */ diff --git a/backend/dt.c b/backend/dt.c new file mode 100644 index 00000000..6b67386e --- /dev/null +++ b/backend/dt.c @@ -0,0 +1,383 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include "cc.h" +#include "oper.h" +#include "global.h" +#include "el.h" +#include "type.h" +#include "dt.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +static dt_t *dt_freelist; + +/********************************************** + * Allocate a data definition struct. + */ + +dt_t *dt_calloc(char dtx) +{ + dt_t *dt; + static dt_t dtzero; + + if (dt_freelist) + { + dt = dt_freelist; + dt_freelist = dt->DTnext; + *dt = dtzero; + } + else + dt = (dt_t *) mem_fcalloc(sizeof(dt_t)); + dt->dt = dtx; + return dt; +} + +/********************************************** + * Free a data definition struct. + */ + +void dt_free(dt_t *dt) +{ dt_t *dtn; + + for (; dt; dt = dtn) + { + switch (dt->dt) + { + case DT_abytes: + case DT_nbytes: + mem_free(dt->DTpbytes); + break; + } + dtn = dt->DTnext; + dt->DTnext = dt_freelist; + dt_freelist = dt; + } +} + +/********************************* + * Free free list. + */ + +void dt_term() +{ +#if TERMCODE + dt_t *dtn; + + while (dt_freelist) + { dtn = dt_freelist->DTnext; + mem_ffree(dt_freelist); + dt_freelist = dtn; + } +#endif +} + + +/********************** + * Construct a DT_azeros record, and return it. + * Increment dsout. + */ + +dt_t **dtnzeros(dt_t **pdtend,targ_size_t size) +{ dt_t *dt; + + //printf("dtnzeros(x%x)\n",size); + assert((long) size >= 0); + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + if (size) + { dt = dt_calloc(DT_azeros); + dt->DTazeros = size; + *pdtend = dt; + pdtend = &dt->DTnext; +#if SCPP + dsout += size; +#endif + } + return pdtend; +} + +/********************** + * Construct a DTsymsize record. + */ + +void dtsymsize(symbol *s) +{ + symbol_debug(s); + s->Sdt = dt_calloc(DT_symsize); +} + +/********************** + * Construct a DTnbytes record, and return it. + */ + +dt_t ** dtnbytes(dt_t **pdtend,targ_size_t size,const char *ptr) +{ dt_t *dt; + + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + if (size) + { if (size == 1) + { dt = dt_calloc(DT_1byte); + dt->DTonebyte = *ptr; + } + else if (size <= 7) + { dt = dt_calloc(DT_ibytes); + dt->DTn = size; + memcpy(dt->DTdata,ptr,size); + } + else + { + dt = dt_calloc(DT_nbytes); + dt->DTnbytes = size; + dt->DTpbytes = (char *) MEM_PH_MALLOC(size); + memcpy(dt->DTpbytes,ptr,size); + } + *pdtend = dt; + pdtend = &dt->DTnext; + } + return pdtend; +} + +/********************** + * Construct a DTabytes record, and return it. + */ + +dt_t **dtabytes(dt_t **pdtend,tym_t ty, targ_size_t offset, targ_size_t size, const char *ptr) +{ dt_t *dt; + + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + + dt = dt_calloc(DT_abytes); + dt->DTnbytes = size; + dt->DTpbytes = (char *) MEM_PH_MALLOC(size); + dt->Dty = ty; + dt->DTabytes = offset; + memcpy(dt->DTpbytes,ptr,size); + + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +/********************** + * Construct a DTibytes record, and return it. + */ + +dt_t ** dtdword(dt_t **pdtend, int value) +{ dt_t *dt; + + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + dt = dt_calloc(DT_ibytes); + dt->DTn = 4; + + union { char* cp; int* lp; } u; + u.cp = dt->DTdata; + *u.lp = value; + + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +dt_t ** dtsize_t(dt_t **pdtend, targ_size_t value) +{ dt_t *dt; + + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + dt = dt_calloc(DT_ibytes); + dt->DTn = NPTRSIZE; + + union { char* cp; int* lp; } u; + u.cp = dt->DTdata; + *u.lp = value; + if (NPTRSIZE == 8) + u.lp[1] = value >> 32; + + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +/********************** + * Concatenate two dt_t's. + */ + +dt_t ** dtcat(dt_t **pdtend,dt_t *dt) +{ + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +/********************** + * Construct a DTcoff record, and return it. + */ + +dt_t ** dtcoff(dt_t **pdtend,targ_size_t offset) +{ dt_t *dt; + + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + dt = dt_calloc(DT_coff); +#if TARGET_SEGMENTED + dt->Dty = TYcptr; +#else + dt->Dty = TYnptr; +#endif + dt->DToffset = offset; + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +/********************** + * Construct a DTxoff record, and return it. + */ + +dt_t ** dtxoff(dt_t **pdtend,symbol *s,targ_size_t offset,tym_t ty) +{ dt_t *dt; + + symbol_debug(s); + while (*pdtend) + pdtend = &((*pdtend)->DTnext); + dt = dt_calloc(DT_xoff); + dt->DTsym = s; + dt->DToffset = offset; + dt->Dty = ty; + *pdtend = dt; + pdtend = &dt->DTnext; + return pdtend; +} + +/************************** + * 'Optimize' a list of dt_t's. + * (Try to collapse it into one DT_azeros object.) + */ + +void dt_optimize(dt_t *dt) +{ dt_t *dtn; + + if (dt) + { for (; 1; dt = dtn) + { + dtn = dt->DTnext; + if (!dtn) + break; + switch (dt->dt) + { + case DT_azeros: + if (dtn->dt == DT_1byte && dtn->DTonebyte == 0) + { + dt->DTazeros += 1; + goto L1; + } + else if (dtn->dt == DT_azeros) + { + dt->DTazeros += dtn->DTazeros; + goto L1; + } + break; + + case DT_1byte: + if (dt->DTonebyte == 0) + { + if (dtn->dt == DT_1byte && dtn->DTonebyte == 0) + { + dt->DTazeros = 2; + goto L1; + } + else if (dtn->dt == DT_azeros) + { + dt->DTazeros = 1 + dtn->DTazeros; + L1: + dt->dt = DT_azeros; + dt->DTnext = dtn->DTnext; + dtn->DTnext = NULL; + dt_free(dtn); + dtn = dt; + } + } + break; + } + } + } +} + +/************************** + * Make a common block for s. + */ + +void init_common(symbol *s) +{ + //printf("init_common('%s')\n", s->Sident); + dtnzeros(&s->Sdt,type_size(s->Stype)); + if (s->Sdt) + s->Sdt->dt = DT_common; +} + +/********************************** + * Compute size of a dt + */ + +unsigned dt_size(dt_t *dtstart) +{ dt_t *dt; + unsigned datasize; + + datasize = 0; + for (dt = dtstart; dt; dt = dt->DTnext) + { + switch (dt->dt) + { case DT_abytes: + datasize += size(dt->Dty); + break; + case DT_ibytes: + datasize += dt->DTn; + break; + case DT_nbytes: + datasize += dt->DTnbytes; + break; + case DT_symsize: + case DT_azeros: + datasize += dt->DTazeros; + break; + case DT_common: + break; + case DT_xoff: + case DT_coff: + datasize += size(dt->Dty); + break; + case DT_1byte: + datasize++; + break; + default: +#ifdef DEBUG + dbg_printf("dt = %p, dt = %d\n",dt,dt->dt); +#endif + assert(0); + } + } + return datasize; +} + +#endif /* !SPP */ diff --git a/backend/dt.h b/backend/dt.h new file mode 100644 index 00000000..99e722ae --- /dev/null +++ b/backend/dt.h @@ -0,0 +1,114 @@ +// Copyright (C) 1984-1995 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +//#pragma once +#ifndef DT_H +#define DT_H 1 + +/********************************** + * Data definitions + * DTibytes 1..7 bytes + * DT1byte one byte of data follows + * n + * DTabytes offset of bytes of data + * a { a data bytes } + * DTnbytes bytes of data + * a { a data bytes } + * a = offset + * DTazeros # of 0 bytes + * a + * DTsymsize same as DTazeros, but the type of the symbol gives + * the size + * DTcommon # of 0 bytes (in a common block) + * a + * DTxoff offset from symbol + * w a + * w = symbol number (pointer for CPP) + * a = offset + * DTcoff offset into code segment + * DTend mark end of list + */ + +struct dt_t +{ dt_t *DTnext; // next in list + char dt; // type (DTxxxx) + unsigned char Dty; // pointer type + union + { + struct // DTibytes + { char DTn_; // number of bytes + #define DTn _DU._DI.DTn_ + char DTdata_[8]; // data + #define DTdata _DU._DI.DTdata_ + }_DI; + char DTonebyte_; // DT1byte + #define DTonebyte _DU.DTonebyte_ + targ_size_t DTazeros_; // DTazeros,DTcommon,DTsymsize + #define DTazeros _DU.DTazeros_ + struct // DTabytes + { + char *DTpbytes_; // pointer to the bytes + #define DTpbytes _DU._DN.DTpbytes_ + unsigned DTnbytes_; // # of bytes + #define DTnbytes _DU._DN.DTnbytes_ +#if TX86 + int DTseg_; // segment it went into + #define DTseg _DU._DN.DTseg_ +#endif + targ_size_t DTabytes_; // offset of abytes for DTabytes + #define DTabytes _DU._DN.DTabytes_ + }_DN; + struct // DTxoff + { + symbol *DTsym_; // symbol pointer + #define DTsym _DU._DS.DTsym_ + targ_size_t DToffset_; // offset from symbol + #define DToffset _DU._DS.DToffset_ + }_DS; + }_DU; +}; + +enum +{ + DT_abytes, + DT_azeros, // 1 + DT_xoff, + DT_1byte, + DT_nbytes, + DT_common, + DT_symsize, + DT_coff, + DT_ibytes, // 8 +}; + +#if TX86 +dt_t *dt_calloc(char dtx); +void dt_free(dt_t *); +void dt_term(void); +#endif + +dt_t **dtnbytes(dt_t **,targ_size_t,const char *); +dt_t **dtabytes(dt_t **pdtend,tym_t ty, targ_size_t offset, targ_size_t size, const char *ptr); +dt_t **dtdword(dt_t **, int value); +dt_t **dtsize_t(dt_t **, targ_size_t value); +dt_t **dtnzeros(dt_t **pdtend,targ_size_t size); +dt_t **dtxoff(dt_t **pdtend,symbol *s,targ_size_t offset,tym_t ty); +dt_t **dtselfoff(dt_t **pdtend,targ_size_t offset,tym_t ty); +dt_t **dtcoff(dt_t **pdtend,targ_size_t offset); +dt_t ** dtcat(dt_t **pdtend,dt_t *dt); +void dt_optimize(dt_t *dt); +void dtsymsize(symbol *); +void init_common(symbol *); +unsigned dt_size(dt_t *dtstart); + +#endif /* DT_H */ + diff --git a/backend/dwarf.c b/backend/dwarf.c new file mode 100644 index 00000000..c3a473a3 --- /dev/null +++ b/backend/dwarf.c @@ -0,0 +1,2531 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + +// Emit Dwarf symbolic debug info + +#if !SPP +#include +#include +#include +#include +#include +#include +#include + +#if __DMC__ || linux +#include +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#include +#endif + +#include "cc.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "outbuf.h" +#include "filespec.h" +#include "cv4.h" +#include "cgcv.h" +#include "dt.h" + +#include "aa.h" +#include "tinfo.h" + +#if ELFOBJ +#include "melf.h" +#endif +#if MACHOBJ +#include "mach.h" +#endif + +#if ELFOBJ || MACHOBJ + +#if MARS +#include "mars.h" +#endif + +#include "dwarf.h" +#include "dwarf2.h" + +extern int seg_count; + +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" + +#if ELFOBJ +#define MAP_SEG2SYMIDX(seg) (SegData[seg]->SDsymidx) +#else +#define MAP_SEG2SYMIDX(seg) (assert(0)) +#endif + +#define OFFSET_FAC REGSIZE + +int dwarf_getsegment(const char *name, int align) +{ +#if ELFOBJ + return elf_getsegment(name, NULL, SHT_PROGDEF, 0, align * 4); +#elif MACHOBJ + return mach_getsegment(name, "__DWARF", align * 2, S_ATTR_DEBUG); +#else + assert(0); + return 0; +#endif +} + +// machobj.c +#define RELaddr 0 // straight address +#define RELrel 1 // relative to location to be fixed up + +void dwarf_addrel(int seg, targ_size_t offset, int targseg, targ_size_t val = 0) +{ +#if ELFOBJ + elf_addrel(seg, offset, I64 ? R_X86_64_32 : RI_TYPE_SYM32, MAP_SEG2SYMIDX(targseg), val); +#elif MACHOBJ + mach_addrel(seg, offset, NULL, targseg, RELaddr, val); +#else + assert(0); +#endif +} + +void dwarf_addrel64(int seg, targ_size_t offset, int targseg, targ_size_t val) +{ +#if ELFOBJ + elf_addrel(seg, offset, R_X86_64_64, MAP_SEG2SYMIDX(targseg), val); +#elif MACHOBJ + mach_addrel(seg, offset, NULL, targseg, RELaddr, val); +#else + assert(0); +#endif +} + +void dwarf_appreladdr(int seg, Outbuffer *buf, int targseg, targ_size_t val) +{ + if (I64) + { + dwarf_addrel64(seg, buf->size(), targseg, val); + buf->write64(0); + } + else + { + dwarf_addrel(seg, buf->size(), targseg, 0); + buf->write32(val); + } +} + +void append_addr(Outbuffer *buf, targ_size_t addr) +{ + if (I64) + buf->write64(addr); + else + buf->write32(addr); +} + + +/************************ DWARF DEBUG OUTPUT ********************************/ + +// Dwarf Symbolic Debugging Information + +struct CFA_reg +{ + int offset; // offset from CFA +}; + +// Current CFA state for .debug_frame +struct CFA_state +{ + size_t location; + int reg; // CFA register number + int offset; // CFA register offset + CFA_reg regstates[17]; // register states +}; + +int dwarf_regno(int reg) +{ + assert(reg <= R15); + if (I16 || I32) + return reg; + else + { + static const int to_amd64_reg_map[8] = + { 0 /*AX*/, 2 /*CX*/, 3 /*DX*/, 1 /*BX*/, + 7 /*SP*/, 6 /*BP*/, 4 /*SI*/, 5 /*DI*/ }; + return reg < 8 ? to_amd64_reg_map[reg] : reg; + } +} + +static CFA_state CFA_state_init_32 = // initial CFA state as defined by CIE +{ 0, // location + dwarf_regno(SP), // register + 4, // offset + { { 0 }, // 0: EAX + { 0 }, // 1: ECX + { 0 }, // 2: EDX + { 0 }, // 3: EBX + { 0 }, // 4: ESP + { 0 }, // 5: EBP + { 0 }, // 6: ESI + { 0 }, // 7: EDI + { -4 }, // 8: EIP + } +}; + +static CFA_state CFA_state_init_64 = // initial CFA state as defined by CIE +{ 0, // location + dwarf_regno(SP), // register + 8, // offset + { { 0 }, // 0: RAX + { 0 }, // 1: RBX + { 0 }, // 2: RCX + { 0 }, // 3: RDX + { 0 }, // 4: RSI + { 0 }, // 5: RDI + { 0 }, // 6: RBP + { 0 }, // 7: RSP + { 0 }, // 8: R8 + { 0 }, // 9: R9 + { 0 }, // 10: R10 + { 0 }, // 11: R11 + { 0 }, // 12: R12 + { 0 }, // 13: R13 + { 0 }, // 14: R14 + { 0 }, // 15: R15 + { -8 }, // 16: RIP + } +}; + +static CFA_state CFA_state_current; // current CFA state +static Outbuffer cfa_buf; // CFA instructions + +void dwarf_CFA_set_loc(size_t location) +{ + assert(location >= CFA_state_current.location); + size_t inc = location - CFA_state_current.location; + if (inc <= 63) + cfa_buf.writeByte(DW_CFA_advance_loc + inc); + else if (inc <= 255) + { cfa_buf.writeByte(DW_CFA_advance_loc1); + cfa_buf.writeByte(inc); + } + else if (inc <= 0xFFFF) + { cfa_buf.writeByte(DW_CFA_advance_loc2); + cfa_buf.writeWord(inc); + } + else + { cfa_buf.writeByte(DW_CFA_advance_loc4); + cfa_buf.write32(inc); + } + CFA_state_current.location = location; +} + +void dwarf_CFA_set_reg_offset(int reg, int offset) +{ + int dw_reg = dwarf_regno(reg); + if (dw_reg != CFA_state_current.reg) + { + if (offset == CFA_state_current.offset) + { + cfa_buf.writeByte(DW_CFA_def_cfa_register); + cfa_buf.writeuLEB128(dw_reg); + } + else if (offset < 0) + { + cfa_buf.writeByte(DW_CFA_def_cfa_sf); + cfa_buf.writeuLEB128(dw_reg); + cfa_buf.writesLEB128(offset / -OFFSET_FAC); + } + else + { + cfa_buf.writeByte(DW_CFA_def_cfa); + cfa_buf.writeuLEB128(dw_reg); + cfa_buf.writeuLEB128(offset); + } + } + else if (offset < 0) + { + cfa_buf.writeByte(DW_CFA_def_cfa_offset_sf); + cfa_buf.writesLEB128(offset / -OFFSET_FAC); + } + else + { + cfa_buf.writeByte(DW_CFA_def_cfa_offset); + cfa_buf.writeuLEB128(offset); + } + CFA_state_current.reg = dw_reg; + CFA_state_current.offset = offset; +} + +void dwarf_CFA_offset(int reg, int offset) +{ + int dw_reg = dwarf_regno(reg); + if (CFA_state_current.regstates[dw_reg].offset != offset) + { + if (offset <= 0) + { + cfa_buf.writeByte(DW_CFA_offset + dw_reg); + cfa_buf.writeuLEB128(offset / -OFFSET_FAC); + } + else + { + cfa_buf.writeByte(DW_CFA_offset_extended_sf); + cfa_buf.writeuLEB128(dw_reg); + cfa_buf.writesLEB128(offset / -OFFSET_FAC); + } + } + CFA_state_current.regstates[dw_reg].offset = offset; +} + +void dwarf_CFA_args_size(size_t sz) +{ + cfa_buf.writeByte(DW_CFA_GNU_args_size); + cfa_buf.writeuLEB128(sz); +} + +// .debug_frame +static IDXSEC debug_frame_secidx; + +// .debug_str +static IDXSEC debug_str_secidx; +static Outbuffer *debug_str_buf; + +// .debug_pubnames +static IDXSEC debug_pubnames_secidx; +static Outbuffer *debug_pubnames_buf; + +// .debug_aranges +static IDXSEC debug_aranges_seg; +static IDXSEC debug_aranges_secidx; +static Outbuffer *debug_aranges_buf; + +// .debug_ranges +static IDXSEC debug_ranges_seg; +static IDXSEC debug_ranges_secidx; +static Outbuffer *debug_ranges_buf; + +// .debug_loc +static IDXSEC debug_loc_seg; +static IDXSEC debug_loc_secidx; +static Outbuffer *debug_loc_buf; + +// .debug_abbrev +static IDXSEC abbrevseg; +static Outbuffer *abbrevbuf; + +/* DWARF 7.5.3: "Each declaration begins with an unsigned LEB128 number + * representing the abbreviation code itself." + */ +static unsigned abbrevcode = 1; +static AArray *abbrev_table; +static int hasModname; // 1 if has DW_TAG_module + +// .debug_info +static IDXSEC infoseg; +static Outbuffer *infobuf; +static AArray *infoFileName_table; + +static AArray *type_table; +static AArray *functype_table; // not sure why this cannot be combined with type_table +static Outbuffer *functypebuf; + +// typeinfo declarations for hash of char* + +struct Abuf +{ + const unsigned char *buf; + size_t length; +}; + +struct TypeInfo_Abuf : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +TypeInfo_Abuf ti_abuf; + +const char* TypeInfo_Abuf::toString() +{ + return "Abuf"; +} + +hash_t TypeInfo_Abuf::getHash(void *p) +{ + Abuf a = *(Abuf *)p; + + hash_t hash = 0; + for (size_t i = 0; i < a.length; i++) + hash = hash * 11 + a.buf[i]; + + return hash; +} + +int TypeInfo_Abuf::equals(void *p1, void *p2) +{ + Abuf a1 = *(Abuf*)p1; + Abuf a2 = *(Abuf*)p2; + + return a1.length == a2.length && + memcmp(a1.buf, a2.buf, a1.length) == 0; +} + +int TypeInfo_Abuf::compare(void *p1, void *p2) +{ + Abuf a1 = *(Abuf*)p1; + Abuf a2 = *(Abuf*)p2; + + if (a1.length == a2.length) + return memcmp(a1.buf, a2.buf, a1.length); + else if (a1.length < a2.length) + return -1; + else + return 1; +} + +size_t TypeInfo_Abuf::tsize() +{ + return sizeof(Abuf); +} + +void TypeInfo_Abuf::swap(void *p1, void *p2) +{ + assert(0); +} + +#pragma pack(1) +struct DebugInfoHeader +{ unsigned total_length; + unsigned short version; + unsigned abbrev_offset; + unsigned char address_size; +}; +#pragma pack() + +static DebugInfoHeader debuginfo_init = +{ 0, // total_length + 2, // version + 0, // abbrev_offset + 4 // address_size +}; + +static DebugInfoHeader debuginfo; + +// .debug_line +static IDXSEC lineseg; +static Outbuffer *linebuf; +static size_t linebuf_filetab_end; + +#pragma pack(1) +struct DebugLineHeader +{ unsigned total_length; + unsigned short version; + unsigned prologue_length; + unsigned char minimum_instruction_length; + unsigned char default_is_stmt; + signed char line_base; + unsigned char line_range; + unsigned char opcode_base; + unsigned char standard_opcode_lengths[9]; +}; +#pragma pack() + +static DebugLineHeader debugline_init = +{ 0, // total_length + 2, // version + 0, // prologue_length + 1, // minimum_instruction_length + TRUE, // default_is_stmt + -5, // line_base + 14, // line_range + 10, // opcode_base + { 0,1,1,1,1,0,0,0,1 } +}; + +static DebugLineHeader debugline; + +unsigned typidx_tab[TYMAX]; + +#if MACHOBJ +const char* debug_frame = "__debug_frame"; +const char* debug_str = "__debug_str"; +const char* debug_ranges = "__debug_ranges"; +const char* debug_loc = "__debug_loc"; +const char* debug_line = "__debug_line"; +const char* debug_abbrev = "__debug_abbrev"; +const char* debug_info = "__debug_info"; +const char* debug_pubnames = "__debug_pubnames"; +const char* debug_aranges = "__debug_aranges"; +#elif ELFOBJ +const char* debug_frame = ".debug_frame"; +const char* debug_str = ".debug_str"; +const char* debug_ranges = ".debug_ranges"; +const char* debug_loc = ".debug_loc"; +const char* debug_line = ".debug_line"; +const char* debug_abbrev = ".debug_abbrev"; +const char* debug_info = ".debug_info"; +const char* debug_pubnames = ".debug_pubnames"; +const char* debug_aranges = ".debug_aranges"; +#endif + +void dwarf_initfile(const char *filename) +{ + #pragma pack(1) + struct DebugFrameHeader + { + unsigned length; + unsigned CIE_id; + unsigned char version; + unsigned char augmentation; + unsigned char code_alignment_factor; + unsigned char data_alignment_factor; + unsigned char return_address_register; + unsigned char opcodes[11]; + }; + #pragma pack() + static DebugFrameHeader debugFrameHeader = + { 16, // length + 0xFFFFFFFF, // CIE_id + 1, // version + 0, // augmentation + 1, // code alignment factor + 0x7C, // data alignment factor (-4) + 8, // return address register + { + DW_CFA_def_cfa, 4,4, // r4,4 [r7,8] + DW_CFA_offset +8,1, // r8,1 [r16,1] + DW_CFA_nop, DW_CFA_nop, + DW_CFA_nop, DW_CFA_nop, // 64 padding + DW_CFA_nop, DW_CFA_nop, // 64 padding + } + }; + if (I64) + { debugFrameHeader.length = 20; + debugFrameHeader.data_alignment_factor = 0x78; // (-8) + debugFrameHeader.return_address_register = 16; + debugFrameHeader.opcodes[1] = 7; // RSP + debugFrameHeader.opcodes[2] = 8; + debugFrameHeader.opcodes[3] = DW_CFA_offset + 16; // RIP + } + assert(debugFrameHeader.data_alignment_factor == 0x80 - OFFSET_FAC); + + int seg = dwarf_getsegment(debug_frame, 1); + debug_frame_secidx = SegData[seg]->SDshtidx; + Outbuffer *debug_frame_buf = SegData[seg]->SDbuf; + debug_frame_buf->reserve(1000); + + debug_frame_buf->writen(&debugFrameHeader,debugFrameHeader.length + 4); + + /* ======================================== */ + + seg = dwarf_getsegment(debug_str, 0); + debug_str_secidx = SegData[seg]->SDshtidx; + debug_str_buf = SegData[seg]->SDbuf; + debug_str_buf->reserve(1000); + + /* ======================================== */ + + debug_ranges_seg = dwarf_getsegment(debug_ranges, 0); + debug_ranges_secidx = SegData[debug_ranges_seg]->SDshtidx; + debug_ranges_buf = SegData[debug_ranges_seg]->SDbuf; + debug_ranges_buf->reserve(1000); + + /* ======================================== */ + + debug_loc_seg = dwarf_getsegment(debug_loc, 0); + debug_loc_secidx = SegData[debug_loc_seg]->SDshtidx; + debug_loc_buf = SegData[debug_loc_seg]->SDbuf; + debug_loc_buf->reserve(1000); + + /* ======================================== */ + + if (infoFileName_table) + { delete infoFileName_table; + infoFileName_table = NULL; + } + + lineseg = dwarf_getsegment(debug_line, 0); + linebuf = SegData[lineseg]->SDbuf; + + debugline = debugline_init; + + linebuf->write(&debugline, sizeof(debugline)); + + // include_directories +#if SCPP + list_t pl; + for (pl = pathlist; pl; pl = list_next(pl)) + { + linebuf->writeString((char *)list_ptr(pl)); + linebuf->writeByte(0); + } +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + for (pl = pathsyslist; pl; pl = list_next(pl)) + { + linebuf->writeString((char *)list_ptr(pl)); + linebuf->writeByte(0); + } +#endif +#endif +#if 0 && MARS + for (int i = 0; i < global.params.imppath->dim; i++) + { + linebuf->writeString(global.params.imppath->tdata()[i]); + linebuf->writeByte(0); + } +#endif + linebuf->writeByte(0); // terminated with 0 byte + + /* ======================================== */ + + abbrevseg = dwarf_getsegment(debug_abbrev, 0); + abbrevbuf = SegData[abbrevseg]->SDbuf; + abbrevcode = 1; + + // Free only if starting another file. Waste of time otherwise. + if (abbrev_table) + { delete abbrev_table; + abbrev_table = NULL; + } + + static unsigned char abbrevHeader[] = + { + 1, // abbreviation code + DW_TAG_compile_unit, + 1, + DW_AT_producer, DW_FORM_string, + DW_AT_language, DW_FORM_data1, + DW_AT_name, DW_FORM_string, + DW_AT_comp_dir, DW_FORM_string, + DW_AT_low_pc, DW_FORM_addr, + DW_AT_entry_pc, DW_FORM_addr, + DW_AT_ranges, DW_FORM_data4, + DW_AT_stmt_list, DW_FORM_data4, + 0, 0, + }; + + abbrevbuf->write(abbrevHeader,sizeof(abbrevHeader)); + + /* ======================================== */ + + infoseg = dwarf_getsegment(debug_info, 0); + infobuf = SegData[infoseg]->SDbuf; + + debuginfo = debuginfo_init; + if (I64) + debuginfo.address_size = 8; + + infobuf->write(&debuginfo, sizeof(debuginfo)); +#if ELFOBJ + dwarf_addrel(infoseg,6,abbrevseg); +#endif + + infobuf->writeuLEB128(1); // abbreviation code +#if MARS + infobuf->write("Digital Mars D "); + infobuf->writeString(global.version); // DW_AT_producer + // DW_AT_language + infobuf->writeByte((config.fulltypes == CVDWARF_D) ? DW_LANG_D : DW_LANG_C89); +#elif SCPP + infobuf->write("Digital Mars C "); + infobuf->writeString(global.version); // DW_AT_producer + infobuf->writeByte(DW_LANG_C89); // DW_AT_language +#else + assert(0); +#endif + infobuf->writeString(filename); // DW_AT_name +#if 0 + // This relies on an extension to POSIX.1 not always implemented + char *cwd = getcwd(NULL, 0); +#else + char *cwd; + size_t sz = 80; + while (1) + { + errno = 0; + cwd = (char *)malloc(sz + 1); + if (!cwd) + err_nomem(); + char *buf = getcwd(cwd, sz); + if (buf) + { cwd[sz] = 0; // man page doesn't say if always 0 terminated + break; + } + if (errno == ERANGE) + { + sz += 80; + free(cwd); + continue; + } + cwd[0] = 0; + break; + } +#endif + //infobuf->write32(elf_addstr(debug_str_buf, cwd)); // DW_AT_comp_dir as DW_FORM_strp, doesn't work on some systems + infobuf->writeString(cwd); // DW_AT_comp_dir as DW_FORM_string + free(cwd); + + append_addr(infobuf, 0); // DW_AT_low_pc + append_addr(infobuf, 0); // DW_AT_entry_pc + +#if ELFOBJ + dwarf_addrel(infoseg,infobuf->size(),debug_ranges_seg); +#endif + infobuf->write32(0); // DW_AT_ranges + +#if ELFOBJ + dwarf_addrel(infoseg,infobuf->size(),lineseg); +#endif + infobuf->write32(0); // DW_AT_stmt_list + + memset(typidx_tab, 0, sizeof(typidx_tab)); + + /* ======================================== */ + + seg = dwarf_getsegment(debug_pubnames, 0); + debug_pubnames_secidx = SegData[seg]->SDshtidx; + debug_pubnames_buf = SegData[seg]->SDbuf; + debug_pubnames_buf->reserve(1000); + + debug_pubnames_buf->write32(0); // unit_length + debug_pubnames_buf->writeWord(2); // version +#if ELFOBJ + dwarf_addrel(seg,debug_pubnames_buf->size(),infoseg); +#endif + debug_pubnames_buf->write32(0); // debug_info_offset + debug_pubnames_buf->write32(0); // debug_info_length + + /* ======================================== */ + + debug_aranges_seg = dwarf_getsegment(debug_aranges, 0); + debug_aranges_secidx = SegData[debug_aranges_seg]->SDshtidx; + debug_aranges_buf = SegData[debug_aranges_seg]->SDbuf; + debug_aranges_buf->reserve(1000); + + debug_aranges_buf->write32(0); // unit_length + debug_aranges_buf->writeWord(2); // version +#if ELFOBJ + dwarf_addrel(debug_aranges_seg,debug_aranges_buf->size(),infoseg); +#endif + debug_aranges_buf->write32(0); // debug_info_offset + debug_aranges_buf->writeByte(I64 ? 8 : 4); // address_size + debug_aranges_buf->writeByte(0); // segment_size + debug_aranges_buf->write32(0); // pad to 16 +} + + +/************************************* + * Add a file to the .debug_line header + */ +int dwarf_line_addfile(const char* filename) +{ + if (!infoFileName_table) { + infoFileName_table = new AArray(&ti_abuf, sizeof(unsigned)); + linebuf_filetab_end = linebuf->size(); + } + + Abuf abuf; + abuf.buf = (const unsigned char*)filename; + abuf.length = strlen(filename)-1; + + unsigned *pidx = (unsigned *)infoFileName_table->get(&abuf); + if (!*pidx) // if no idx assigned yet + { + *pidx = infoFileName_table->length(); // assign newly computed idx + + size_t before = linebuf->size(); + linebuf->writeString(filename); + linebuf->writeByte(0); // directory table index + linebuf->writeByte(0); // mtime + linebuf->writeByte(0); // length + linebuf_filetab_end += linebuf->size() - before; + } + + return *pidx; +} + +void dwarf_initmodule(const char *filename, const char *modname) +{ + if (modname) + { + static unsigned char abbrevModule[] = + { + DW_TAG_module, + //1, // one children + 0, // no children + DW_AT_name, DW_FORM_string, // module name + 0, 0, + }; + abbrevcode++; + abbrevbuf->writeuLEB128(abbrevcode); + abbrevbuf->write(abbrevModule,sizeof(abbrevModule)); + infobuf->writeuLEB128(abbrevcode); // abbreviation code + infobuf->writeString(modname); // DW_AT_name + //hasModname = 1; + } + else + hasModname = 0; + + dwarf_line_addfile(filename); +} + +void dwarf_termmodule() +{ + if (hasModname) + infobuf->writeByte(0); // end of DW_TAG_module's children +} + +/************************************* + * Finish writing Dwarf debug info to object file. + */ + +void dwarf_termfile() +{ + //printf("dwarf_termfile()\n"); + + /* ======================================== */ + + // Put out line number info + + // file_names + unsigned last_filenumber = 0; + const char* last_filename = NULL; + for (unsigned seg = 1; seg <= seg_count; seg++) + { + for (unsigned i = 0; i < SegData[seg]->SDlinnum_count; i++) + { + linnum_data *ld = &SegData[seg]->SDlinnum_data[i]; + const char *filename; +#if MARS + filename = ld->filename; +#else + Sfile *sf = ld->filptr; + if (sf) + filename = sf->SFname; + else + filename = ::filename; +#endif + if (last_filename == filename) + { + ld->filenumber = last_filenumber; + } + else + { + ld->filenumber = dwarf_line_addfile(filename); + + last_filenumber = ld->filenumber; + last_filename = filename; + } + } + } + // assert we haven't emitted anything but file table entries + assert(linebuf->size() == linebuf_filetab_end); + linebuf->writeByte(0); // end of file_names + + debugline.prologue_length = linebuf->size() - 10; + + for (unsigned seg = 1; seg <= seg_count; seg++) + { + seg_data *sd = SegData[seg]; + unsigned addressmax = 0; + unsigned linestart = ~0; + + if (!sd->SDlinnum_count) + continue; +#if ELFOBJ + if (!sd->SDsym) // gdb ignores line number data without a DW_AT_name + continue; +#endif + + //printf("sd = %x, SDlinnum_count = %d\n", sd, sd->SDlinnum_count); + for (int i = 0; i < sd->SDlinnum_count; i++) + { linnum_data *ld = &sd->SDlinnum_data[i]; + + // Set address to start of segment with DW_LNE_set_address + linebuf->writeByte(0); + linebuf->writeByte(NPTRSIZE + 1); + linebuf->writeByte(DW_LNE_set_address); + + dwarf_appreladdr(lineseg,linebuf,seg,0); + + // Dwarf2 6.2.2 State machine registers + unsigned address = 0; // instruction address + unsigned file = ld->filenumber; + unsigned line = 1; // line numbers beginning with 1 + + linebuf->writeByte(DW_LNS_set_file); + linebuf->writeuLEB128(file); + + for (int j = 0; j < ld->linoff_count; j++) + { int lininc = ld->linoff[j][0] - line; + int addinc = ld->linoff[j][1] - address; + + //printf("\tld[%d] line = %d offset = x%x lininc = %d addinc = %d\n", j, ld->linoff[j][0], ld->linoff[j][1], lininc, addinc); + + //assert(addinc >= 0); + if (addinc < 0) + continue; + if (j && lininc == 0 && !(addinc && j + 1 == ld->linoff_count)) + continue; + line += lininc; + if (line < linestart) + linestart = line; + address += addinc; + if (address >= addressmax) + addressmax = address + 1; + if (lininc >= debugline.line_base && lininc < debugline.line_base + debugline.line_range) + { unsigned opcode = lininc - debugline.line_base + + debugline.line_range * addinc + + debugline.opcode_base; + + if (opcode <= 255) + { linebuf->writeByte(opcode); + continue; + } + } + if (lininc) + { + linebuf->writeByte(DW_LNS_advance_line); + linebuf->writesLEB128((long)lininc); + } + if (addinc) + { + linebuf->writeByte(DW_LNS_advance_pc); + linebuf->writeuLEB128((unsigned long)addinc); + } + if (lininc || addinc) + linebuf->writeByte(DW_LNS_copy); + } + + // Write DW_LNS_advance_pc to cover the function prologue + linebuf->writeByte(DW_LNS_advance_pc); + linebuf->writeuLEB128((unsigned long)(sd->SDbuf->size() - address)); + + // Write DW_LNE_end_sequence + linebuf->writeByte(0); + linebuf->writeByte(1); + linebuf->writeByte(1); + + // reset linnum_data + ld->linoff_count = 0; + } + } + + debugline.total_length = linebuf->size() - 4; + memcpy(linebuf->buf, &debugline, sizeof(debugline)); + + /* ================================================= */ + + abbrevbuf->writeByte(0); + + /* ================================================= */ + + infobuf->writeByte(0); // ending abbreviation code + + debuginfo.total_length = infobuf->size() - 4; + memcpy(infobuf->buf, &debuginfo, sizeof(debuginfo)); + + /* ================================================= */ + + // Terminate by offset field containing 0 + debug_pubnames_buf->write32(0); + + // Plug final sizes into header + *(unsigned *)debug_pubnames_buf->buf = debug_pubnames_buf->size() - 4; + *(unsigned *)(debug_pubnames_buf->buf + 10) = infobuf->size(); + + /* ================================================= */ + + // Terminate by address/length fields containing 0 + append_addr(debug_aranges_buf, 0); + append_addr(debug_aranges_buf, 0); + + // Plug final sizes into header + *(unsigned *)debug_aranges_buf->buf = debug_aranges_buf->size() - 4; + + /* ================================================= */ + + // Terminate by beg address/end address fields containing 0 + append_addr(debug_ranges_buf, 0); + append_addr(debug_ranges_buf, 0); + + /* ================================================= */ + + // Free only if starting another file. Waste of time otherwise. + if (type_table) + { delete type_table; + type_table = NULL; + } + if (functype_table) + { delete functype_table; + functype_table = NULL; + } + if (functypebuf) + functypebuf->setsize(0); +} + +/***************************************** + * Start of code gen for function. + */ +void dwarf_func_start(Symbol *sfunc) +{ + if (I16 || I32) + CFA_state_current = CFA_state_init_32; + else if (I64) + CFA_state_current = CFA_state_init_64; + else + assert(0); + assert(CFA_state_current.offset == OFFSET_FAC); + cfa_buf.reset(); +} + +/***************************************** + * End of code gen for function. + */ +void dwarf_func_term(Symbol *sfunc) +{ + //printf("dwarf_func_term(sfunc = '%s')\n", sfunc->Sident); + unsigned funcabbrevcode; + + /* Put out the start of the debug_frame entry for this function + */ + Outbuffer *debug_frame_buf; + unsigned debug_frame_buf_offset; + + if (I64) + { + #pragma pack(1) + struct DebugFrameFDE + { + unsigned length; + unsigned CIE_pointer; + unsigned long long initial_location; + unsigned long long address_range; + }; + #pragma pack() + static DebugFrameFDE debugFrameFDE = + { 20, // length + 0, // CIE_pointer + 0, // initial_location + 0, // address_range + }; + + // Pad to 8 byte boundary + int n; + for (n = (-cfa_buf.size() & 7); n; n--) + cfa_buf.writeByte(DW_CFA_nop); + + debugFrameFDE.length = 20 + cfa_buf.size(); + debugFrameFDE.address_range = sfunc->Ssize; + // Do we need this? + //debugFrameFDE.initial_location = sfunc->Soffset; + + IDXSEC dfseg; + dfseg = dwarf_getsegment(debug_frame, 1); + debug_frame_secidx = SegData[dfseg]->SDshtidx; + debug_frame_buf = SegData[dfseg]->SDbuf; + debug_frame_buf_offset = debug_frame_buf->p - debug_frame_buf->buf; + debug_frame_buf->reserve(1000); + debug_frame_buf->writen(&debugFrameFDE,sizeof(debugFrameFDE)); + debug_frame_buf->write(&cfa_buf); + +#if ELFOBJ + dwarf_addrel(dfseg,debug_frame_buf_offset + 4,dfseg); +#endif + dwarf_addrel64(dfseg,debug_frame_buf_offset + 8,sfunc->Sseg,0); + } + else + { + #pragma pack(1) + struct DebugFrameFDE + { + unsigned length; + unsigned CIE_pointer; + unsigned initial_location; + unsigned address_range; + }; + #pragma pack() + static DebugFrameFDE debugFrameFDE = + { 12, // length + 0, // CIE_pointer + 0, // initial_location + 0, // address_range + }; + + // Pad to 4 byte boundary + int n; + for (n = (-cfa_buf.size() & 3); n; n--) + cfa_buf.writeByte(DW_CFA_nop); + + debugFrameFDE.length = 12 + cfa_buf.size(); + debugFrameFDE.address_range = sfunc->Ssize; + // Do we need this? + //debugFrameFDE.initial_location = sfunc->Soffset; + + IDXSEC dfseg; + dfseg = dwarf_getsegment(debug_frame, 1); + debug_frame_secidx = SegData[dfseg]->SDshtidx; + debug_frame_buf = SegData[dfseg]->SDbuf; + debug_frame_buf_offset = debug_frame_buf->p - debug_frame_buf->buf; + debug_frame_buf->reserve(1000); + debug_frame_buf->writen(&debugFrameFDE,sizeof(debugFrameFDE)); + debug_frame_buf->write(&cfa_buf); + +#if ELFOBJ + dwarf_addrel(dfseg,debug_frame_buf_offset + 4,dfseg); +#endif + dwarf_addrel(dfseg,debug_frame_buf_offset + 8,sfunc->Sseg); + } + + IDXSEC seg = sfunc->Sseg; + seg_data *sd = SegData[seg]; + +#if MARS + const char* filename = sfunc->Sfunc->Fstartline.Sfilename; + int filenum = dwarf_line_addfile(filename); +#else + int filenum = 1; +#endif + + unsigned ret_type = dwarf_typidx(sfunc->Stype->Tnext); + if (tybasic(sfunc->Stype->Tnext->Tty) == TYvoid) + ret_type = 0; + + // See if there are any parameters + int haveparameters = 0; + unsigned formalcode = 0; + unsigned autocode = 0; + SYMIDX si; + for (si = 0; si < globsym.top; si++) + { symbol *sa = globsym.tab[si]; + + static unsigned char formal[] = + { + DW_TAG_formal_parameter, + 0, + DW_AT_name, DW_FORM_string, + DW_AT_type, DW_FORM_ref4, + DW_AT_location, DW_FORM_block1, + 0, 0, + }; + + switch (sa->Sclass) + { case SCparameter: + case SCregpar: + case SCfastpar: + dwarf_typidx(sa->Stype); + formal[0] = DW_TAG_formal_parameter; + if (!formalcode) + formalcode = dwarf_abbrev_code(formal,sizeof(formal)); + haveparameters = 1; + break; + + case SCauto: + case SCbprel: + case SCregister: + case SCpseudo: + dwarf_typidx(sa->Stype); + formal[0] = DW_TAG_variable; + if (!autocode) + autocode = dwarf_abbrev_code(formal,sizeof(formal)); + haveparameters = 1; + break; + } + } + + Outbuffer abuf; + abuf.writeByte(DW_TAG_subprogram); + abuf.writeByte(haveparameters); // have children? + if (haveparameters) + { + abuf.writeByte(DW_AT_sibling); abuf.writeByte(DW_FORM_ref4); + } + abuf.writeByte(DW_AT_name); abuf.writeByte(DW_FORM_string); + abuf.writeuLEB128(DW_AT_MIPS_linkage_name); abuf.writeByte(DW_FORM_string); + abuf.writeByte(DW_AT_decl_file); abuf.writeByte(DW_FORM_data1); + abuf.writeByte(DW_AT_decl_line); abuf.writeByte(DW_FORM_data2); + if (ret_type) + { + abuf.writeByte(DW_AT_type); abuf.writeByte(DW_FORM_ref4); + } + if (sfunc->Sclass == SCglobal) + { + abuf.writeByte(DW_AT_external); abuf.writeByte(DW_FORM_flag); + } + abuf.writeByte(DW_AT_low_pc); abuf.writeByte(DW_FORM_addr); + abuf.writeByte(DW_AT_high_pc); abuf.writeByte(DW_FORM_addr); + abuf.writeByte(DW_AT_frame_base); abuf.writeByte(DW_FORM_data4); + abuf.writeByte(0); abuf.writeByte(0); + + funcabbrevcode = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned idxsibling = 0; + unsigned siblingoffset; + + unsigned infobuf_offset = infobuf->size(); + infobuf->writeuLEB128(funcabbrevcode); // abbreviation code + if (haveparameters) + { + siblingoffset = infobuf->size(); + infobuf->write32(idxsibling); // DW_AT_sibling + } + + const char *name; +#if MARS + name = sfunc->prettyIdent ? sfunc->prettyIdent : sfunc->Sident; +#else + name = sfunc->Sident; +#endif + infobuf->writeString(name); // DW_AT_name + infobuf->writeString(sfunc->Sident); // DW_AT_MIPS_linkage_name + infobuf->writeByte(filenum); // DW_AT_decl_file + infobuf->writeWord(sfunc->Sfunc->Fstartline.Slinnum); // DW_AT_decl_line + if (ret_type) + infobuf->write32(ret_type); // DW_AT_type + + if (sfunc->Sclass == SCglobal) + infobuf->writeByte(1); // DW_AT_external + + // DW_AT_low_pc and DW_AT_high_pc + dwarf_appreladdr(infoseg, infobuf, seg, funcoffset); + dwarf_appreladdr(infoseg, infobuf, seg, funcoffset + sfunc->Ssize); + +#if ELFOBJ + dwarf_addrel(infoseg,infobuf->size(),debug_loc_seg, 0); +#endif + infobuf->write32(debug_loc_buf->size()); // DW_AT_frame_base + + if (haveparameters) + { + for (si = 0; si < globsym.top; si++) + { symbol *sa = globsym.tab[si]; + unsigned vcode; + + switch (sa->Sclass) + { + case SCparameter: + case SCregpar: + case SCfastpar: + vcode = formalcode; + goto L1; + case SCauto: + case SCregister: + case SCpseudo: + case SCbprel: + vcode = autocode; + L1: + { unsigned soffset; + unsigned tidx = dwarf_typidx(sa->Stype); + + infobuf->writeuLEB128(vcode); // abbreviation code + infobuf->writeString(sa->Sident); // DW_AT_name + infobuf->write32(tidx); // DW_AT_type + soffset = infobuf->size(); + infobuf->writeByte(2); // DW_FORM_block1 + if (sa->Sfl == FLreg || sa->Sclass == SCpseudo) + { // BUG: register pairs not supported in Dwarf? + infobuf->writeByte(DW_OP_reg0 + sa->Sreglsw); + } + else + { + infobuf->writeByte(DW_OP_fbreg); + if (sa->Sclass == SCregpar || + sa->Sclass == SCparameter) + infobuf->writesLEB128(sa->Soffset); + else if (sa->Sclass == SCfastpar) + infobuf->writesLEB128(Aoff + BPoff - Poff + sa->Soffset); + else if (sa->Sclass == SCbprel) + infobuf->writesLEB128(-Poff + sa->Soffset); + else + infobuf->writesLEB128(Aoff + BPoff - Poff + sa->Soffset); + } + infobuf->buf[soffset] = infobuf->size() - soffset - 1; + break; + } + } + } + infobuf->writeByte(0); // end of parameter children + + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } + + /* ============= debug_pubnames =========================== */ + + debug_pubnames_buf->write32(infobuf_offset); + // Should be the fully qualified name, not the simple DW_AT_name + debug_pubnames_buf->writeString(sfunc->Sident); + + /* ============= debug_aranges =========================== */ + + if (sd->SDaranges_offset) + // Extend existing entry size + *(unsigned long long *)(debug_aranges_buf->buf + sd->SDaranges_offset + NPTRSIZE) = funcoffset + sfunc->Ssize; + else + { // Add entry + sd->SDaranges_offset = debug_aranges_buf->size(); + // address of start of .text segment + dwarf_appreladdr(debug_aranges_seg, debug_aranges_buf, seg, 0); + // size of .text segment + append_addr(debug_aranges_buf, funcoffset + sfunc->Ssize); + } + + /* ============= debug_ranges =========================== */ + + /* Each function gets written into its own segment, + * indicate this by adding to the debug_ranges + */ + // start of function and end of function + dwarf_appreladdr(debug_ranges_seg, debug_ranges_buf, seg, funcoffset); + dwarf_appreladdr(debug_ranges_seg, debug_ranges_buf, seg, funcoffset + sfunc->Ssize); + + /* ============= debug_loc =========================== */ + + assert(Poff >= 2 * REGSIZE); + assert(Poff < 63); // avoid sLEB128 encoding + unsigned short op_size = 0x0002; + unsigned short loc_op; + + // set the entry for this function in .debug_loc segment + // after call + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + 0); + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + 1); + + loc_op = ((Poff - REGSIZE) << 8) | (DW_OP_breg0 + dwarf_regno(SP)); + debug_loc_buf->write32(loc_op << 16 | op_size); + + // after push EBP + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + 1); + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + 3); + + loc_op = ((Poff) << 8) | (DW_OP_breg0 + dwarf_regno(SP)); + debug_loc_buf->write32(loc_op << 16 | op_size); + + // after mov EBP, ESP + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + 3); + dwarf_appreladdr(debug_loc_seg, debug_loc_buf, seg, funcoffset + sfunc->Ssize); + + loc_op = ((Poff) << 8) | (DW_OP_breg0 + dwarf_regno(BP)); + debug_loc_buf->write32(loc_op << 16 | op_size); + + // 2 zero addresses to end loc_list + append_addr(debug_loc_buf, 0); + append_addr(debug_loc_buf, 0); +} + + +/****************************************** + * Write out symbol table for current function. + */ + +void cv_outsym(symbol *s) +{ + //printf("cv_outsym('%s')\n",s->Sident); + //symbol_print(s); + + symbol_debug(s); +#if MARS + if (s->Sflags & SFLnodebug) + return; +#endif + type *t = s->Stype; + type_debug(t); + tym_t tym = tybasic(t->Tty); + if (tyfunc(tym) && s->Sclass != SCtypedef) + return; + + Outbuffer abuf; + unsigned code; + unsigned typidx; + unsigned soffset; + switch (s->Sclass) + { + case SCglobal: + typidx = dwarf_typidx(t); + + abuf.writeByte(DW_TAG_variable); + abuf.writeByte(0); // no children + abuf.writeByte(DW_AT_name); abuf.writeByte(DW_FORM_string); + abuf.writeByte(DW_AT_type); abuf.writeByte(DW_FORM_ref4); + abuf.writeByte(DW_AT_external); abuf.writeByte(DW_FORM_flag); + abuf.writeByte(DW_AT_location); abuf.writeByte(DW_FORM_block1); + abuf.writeByte(0); abuf.writeByte(0); + code = dwarf_abbrev_code(abuf.buf, abuf.size()); + + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString(s->Sident); // DW_AT_name + infobuf->write32(typidx); // DW_AT_type + infobuf->writeByte(1); // DW_AT_external + + soffset = infobuf->size(); + infobuf->writeByte(2); // DW_FORM_block1 + + infobuf->writeByte(DW_OP_addr); + dwarf_addrel(infoseg,infobuf->size(),s->Sseg); + infobuf->write32(0); // address of global + + infobuf->buf[soffset] = infobuf->size() - soffset - 1; + break; + } +} + + +/****************************************** + * Write out any deferred symbols. + */ + +void cv_outlist() +{ +} + + +/****************************************** + * Write out symbol table for current function. + */ + +void cv_func(Funcsym *s) +{ +} + +/* =================== Cached Types in debug_info ================= */ + +struct Atype +{ + Outbuffer *buf; + size_t start; + size_t end; +}; + +struct TypeInfo_Atype : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +TypeInfo_Atype ti_atype; + +const char* TypeInfo_Atype::toString() +{ + return "Atype"; +} + +hash_t TypeInfo_Atype::getHash(void *p) +{ Atype a; + hash_t hash = 0; + size_t i; + + a = *(Atype *)p; + for (i = a.start; i < a.end; i++) + { + hash = hash * 11 + a.buf->buf[i]; + } + return hash; +} + +int TypeInfo_Atype::equals(void *p1, void *p2) +{ + Atype a1 = *(Atype*)p1; + Atype a2 = *(Atype*)p2; + size_t len = a1.end - a1.start; + + return len == a2.end - a2.start && + memcmp(a1.buf->buf + a1.start, a2.buf->buf + a2.start, len) == 0; +} + +int TypeInfo_Atype::compare(void *p1, void *p2) +{ + Atype a1 = *(Atype*)p1; + Atype a2 = *(Atype*)p2; + size_t len = a1.end - a1.start; + if (len == a2.end - a2.start) + return memcmp(a1.buf->buf + a1.start, a2.buf->buf + a2.start, len); + else if (len < a2.end - a2.start) + return -1; + else + return 1; +} + +size_t TypeInfo_Atype::tsize() +{ + return sizeof(Atype); +} + +void TypeInfo_Atype::swap(void *p1, void *p2) +{ + assert(0); +} + +/* ======================= Type Index ============================== */ + +unsigned dwarf_typidx(type *t) +{ unsigned idx = 0; + unsigned nextidx; + unsigned keyidx; + unsigned pvoididx; + unsigned code; + type *tnext; + type *tbase; + const char *p; + + static unsigned char abbrevTypeBasic[] = + { + DW_TAG_base_type, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_byte_size, DW_FORM_data1, + DW_AT_encoding, DW_FORM_data1, + 0, 0, + }; + static unsigned char abbrevWchar[] = + { + DW_TAG_typedef, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_type, DW_FORM_ref4, + DW_AT_decl_file, DW_FORM_data1, + DW_AT_decl_line, DW_FORM_data2, + 0, 0, + }; + static unsigned char abbrevTypePointer[] = + { + DW_TAG_pointer_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypePointerVoid[] = + { + DW_TAG_pointer_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + 0, 0, + }; +#ifdef USE_DWARF_D_EXTENSIONS + static unsigned char abbrevTypeDArray[] = + { + DW_TAG_darray_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeDArrayVoid[] = + { + DW_TAG_darray_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + 0, 0, + }; + static unsigned char abbrevTypeAArray[] = + { + DW_TAG_aarray_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + DW_AT_type, DW_FORM_ref4, // element type + DW_AT_containing_type, DW_FORM_ref4, // key type + 0, 0, + }; + static unsigned char abbrevTypeDelegate[] = + { + DW_TAG_delegate_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, + DW_AT_containing_type, DW_FORM_ref4, // this type + DW_AT_type, DW_FORM_ref4, // function type + 0, 0, + }; +#endif // USE_DWARF_D_EXTENSIONS + static unsigned char abbrevTypeConst[] = + { + DW_TAG_const_type, + 0, // no children + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeConstVoid[] = + { + DW_TAG_const_type, + 0, // no children + 0, 0, + }; + static unsigned char abbrevTypeVolatile[] = + { + DW_TAG_volatile_type, + 0, // no children + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeVolatileVoid[] = + { + DW_TAG_volatile_type, + 0, // no children + 0, 0, + }; + + if (!t) + return 0; + + if (t->Tty & mTYconst) + { // We make a copy of the type to strip off the const qualifier and + // recurse, and then add the const abbrev code. To avoid ending in a + // loop if the type references the const version of itself somehow, + // we need to set TFforward here, because setting TFforward during + // member generation of dwarf_typidx(tnext) has no effect on t itself. + unsigned short old_flags = t->Tflags; + t->Tflags |= TFforward; + + tnext = type_copy(t); + tnext->Tcount++; + tnext->Tty &= ~mTYconst; + nextidx = dwarf_typidx(tnext); + + t->Tflags = old_flags; + + code = nextidx + ? dwarf_abbrev_code(abbrevTypeConst, sizeof(abbrevTypeConst)) + : dwarf_abbrev_code(abbrevTypeConstVoid, sizeof(abbrevTypeConstVoid)); + goto Lcv; + } + + if (t->Tty & mTYvolatile) + { tnext = type_copy(t); + tnext->Tcount++; + tnext->Tty &= ~mTYvolatile; + nextidx = dwarf_typidx(tnext); + code = nextidx + ? dwarf_abbrev_code(abbrevTypeVolatile, sizeof(abbrevTypeVolatile)) + : dwarf_abbrev_code(abbrevTypeVolatileVoid, sizeof(abbrevTypeVolatileVoid)); + Lcv: + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + if (nextidx) + infobuf->write32(nextidx); // DW_AT_type + goto Lret; + } + + tym_t ty; + ty = tybasic(t->Tty); + idx = typidx_tab[ty]; + if (idx) + return idx; + + unsigned char ate; + ate = tyuns(t->Tty) ? DW_ATE_unsigned : DW_ATE_signed; + switch (tybasic(t->Tty)) + { + Lnptr: + nextidx = dwarf_typidx(t->Tnext); + code = nextidx + ? dwarf_abbrev_code(abbrevTypePointer, sizeof(abbrevTypePointer)) + : dwarf_abbrev_code(abbrevTypePointerVoid, sizeof(abbrevTypePointerVoid)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + if (nextidx) + infobuf->write32(nextidx); // DW_AT_type + break; + + case TYullong: + case TYucent: + if (!t->Tnext) + { p = (tybasic(t->Tty) == TYullong) ? "unsigned long long" : "ucent"; + goto Lsigned; + } + +#ifndef USE_DWARF_D_EXTENSIONS + static unsigned char abbrevTypeStruct[] = + { + DW_TAG_structure_type, + 1, // children + DW_AT_sibling, DW_FORM_ref4, + DW_AT_name, DW_FORM_string, + DW_AT_byte_size, DW_FORM_data1, + 0, 0, + }; + + static unsigned char abbrevTypeMember[] = + { + DW_TAG_member, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_type, DW_FORM_ref4, + DW_AT_data_member_location, DW_FORM_block1, + 0, 0, + }; +#endif + + /* It's really TYdarray, and Tnext is the + * element type + */ +#ifdef USE_DWARF_D_EXTENSIONS + nextidx = dwarf_typidx(t->Tnext); + code = nextidx + ? dwarf_abbrev_code(abbrevTypeDArray, sizeof(abbrevTypeDArray)) + : dwarf_abbrev_code(abbrevTypeDArrayVoid, sizeof(abbrevTypeDArrayVoid)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + if (nextidx) + infobuf->write32(nextidx); // DW_AT_type +#else + { + unsigned lenidx = I64 ? dwarf_typidx(tsulong) : dwarf_typidx(tsuns); + + { + type *tdata = type_alloc(TYnptr); + tdata->Tnext = t->Tnext; + t->Tnext->Tcount++; + tdata->Tcount++; + nextidx = dwarf_typidx(tdata); + type_free(tdata); + } + + code = dwarf_abbrev_code(abbrevTypeStruct, sizeof(abbrevTypeStruct)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + unsigned siblingoffset = infobuf->size(); + unsigned idxsibling = 0; + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->write("_Array_", 7); // DW_AT_name + if (tybasic(t->Tnext->Tty)) + infobuf->writeString(tystring[tybasic(t->Tnext->Tty)]); + else + infobuf->writeByte(0); + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + + // length + code = dwarf_abbrev_code(abbrevTypeMember, sizeof(abbrevTypeMember)); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("length"); // DW_AT_name + infobuf->write32(lenidx); // DW_AT_type + + infobuf->writeByte(2); // DW_AT_data_member_location + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeByte(0); + + // ptr + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("ptr"); // DW_AT_name + infobuf->write32(nextidx); // DW_AT_type + + infobuf->writeByte(2); // DW_AT_data_member_location + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeByte(I64 ? 8 : 4); + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } +#endif + break; + + case TYllong: + case TYcent: + if (!t->Tnext) + { p = (tybasic(t->Tty) == TYllong) ? "long long" : "cent"; + goto Lsigned; + } + /* It's really TYdelegate, and Tnext is the + * function type + */ +#ifdef USE_DWARF_D_EXTENSIONS + { type *tv = type_fake(TYnptr); + tv->Tcount++; + pvoididx = dwarf_typidx(tv); // void* is the 'this' type + type_free(tv); + } + nextidx = dwarf_typidx(t->Tnext); + code = dwarf_abbrev_code(abbrevTypeDelegate, sizeof(abbrevTypeDelegate)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + infobuf->write32(pvoididx); // DW_AT_containing_type + infobuf->write32(nextidx); // DW_AT_type +#else + { + { + type *tp = type_fake(TYnptr); + tp->Tcount++; + pvoididx = dwarf_typidx(tp); // void* + + tp->Tnext = t->Tnext; // fptr* + tp->Tnext->Tcount++; + nextidx = dwarf_typidx(tp); + type_free(tp); + } + + code = dwarf_abbrev_code(abbrevTypeStruct, sizeof(abbrevTypeStruct)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + unsigned siblingoffset = infobuf->size(); + unsigned idxsibling = 0; + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->writeString("_Delegate"); // DW_AT_name + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + + // ctxptr + code = dwarf_abbrev_code(abbrevTypeMember, sizeof(abbrevTypeMember)); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("ctxptr"); // DW_AT_name + infobuf->write32(pvoididx); // DW_AT_type + + infobuf->writeByte(2); // DW_AT_data_member_location + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeByte(0); + + // funcptr + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("funcptr"); // DW_AT_name + infobuf->write32(nextidx); // DW_AT_type + + infobuf->writeByte(2); // DW_AT_data_member_location + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeByte(I64 ? 8 : 4); + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } +#endif + break; + + case TYnref: + case TYref: + case TYnptr: + if (!t->Tkey) + goto Lnptr; + + /* It's really TYaarray, and Tnext is the + * element type, Tkey is the key type + */ +#ifdef USE_DWARF_D_EXTENSIONS + keyidx = dwarf_typidx(t->Tkey); + nextidx = dwarf_typidx(t->Tnext); + code = dwarf_abbrev_code(abbrevTypeAArray, sizeof(abbrevTypeAArray)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + infobuf->write32(nextidx); // DW_AT_type + infobuf->write32(keyidx); // DW_AT_containing_type +#else + { + { + type *tp = type_fake(TYnptr); + tp->Tcount++; + pvoididx = dwarf_typidx(tp); // void* + } + + code = dwarf_abbrev_code(abbrevTypeStruct, sizeof(abbrevTypeStruct)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + unsigned siblingoffset = infobuf->size(); + unsigned idxsibling = 0; + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->write("_AArray_", 8); // DW_AT_name + if (tybasic(t->Tkey->Tty)) + p = tystring[tybasic(t->Tkey->Tty)]; + else + p = "key"; + infobuf->write(p, strlen(p)); + + infobuf->writeByte('_'); + if (tybasic(t->Tnext->Tty)) + p = tystring[tybasic(t->Tnext->Tty)]; + else + p = "value"; + infobuf->writeString(p); + + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + + // ptr + code = dwarf_abbrev_code(abbrevTypeMember, sizeof(abbrevTypeMember)); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("ptr"); // DW_AT_name + infobuf->write32(pvoididx); // DW_AT_type + + infobuf->writeByte(2); // DW_AT_data_member_location + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeByte(0); + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } +#endif + break; + + case TYvoid: return 0; + case TYbool: p = "_Bool"; ate = DW_ATE_boolean; goto Lsigned; + case TYchar: p = "char"; ate = (config.flags & CFGuchar) ? DW_ATE_unsigned_char : DW_ATE_signed_char; goto Lsigned; + case TYschar: p = "signed char"; ate = DW_ATE_signed_char; goto Lsigned; + case TYuchar: p = "unsigned char"; ate = DW_ATE_unsigned_char; goto Lsigned; + case TYshort: p = "short"; goto Lsigned; + case TYushort: p = "unsigned short"; goto Lsigned; + case TYint: p = "int"; goto Lsigned; + case TYuint: p = "unsigned"; goto Lsigned; + case TYlong: p = "long"; goto Lsigned; + case TYulong: p = "unsigned long"; goto Lsigned; + case TYdchar: p = "dchar"; goto Lsigned; + case TYfloat: p = "float"; ate = DW_ATE_float; goto Lsigned; + case TYdouble_alias: + case TYdouble: p = "double"; ate = DW_ATE_float; goto Lsigned; + case TYldouble: p = "long double"; ate = DW_ATE_float; goto Lsigned; + case TYifloat: p = "imaginary float"; ate = DW_ATE_imaginary_float; goto Lsigned; + case TYidouble: p = "imaginary double"; ate = DW_ATE_imaginary_float; goto Lsigned; + case TYildouble: p = "imaginary long double"; ate = DW_ATE_imaginary_float; goto Lsigned; + case TYcfloat: p = "complex float"; ate = DW_ATE_complex_float; goto Lsigned; + case TYcdouble: p = "complex double"; ate = DW_ATE_complex_float; goto Lsigned; + case TYcldouble: p = "complex long double"; ate = DW_ATE_complex_float; goto Lsigned; + Lsigned: + code = dwarf_abbrev_code(abbrevTypeBasic, sizeof(abbrevTypeBasic)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString(p); // DW_AT_name + infobuf->writeByte(tysize(t->Tty)); // DW_AT_byte_size + infobuf->writeByte(ate); // DW_AT_encoding + typidx_tab[ty] = idx; + return idx; + + case TYnsfunc: + case TYnpfunc: + case TYjfunc: + + case TYnfunc: + { + /* The dwarf typidx for the function type is completely determined by + * the return type typidx and the parameter typidx's. Thus, by + * caching these, we can cache the function typidx. + * Cache them in functypebuf[] + */ + Outbuffer tmpbuf; + nextidx = dwarf_typidx(t->Tnext); // function return type + tmpbuf.write32(nextidx); + unsigned params = 0; + for (param_t *p = t->Tparamtypes; p; p = p->Pnext) + { params = 1; + unsigned paramidx = dwarf_typidx(p->Ptype); + //printf("1: paramidx = %d\n", paramidx); +#ifdef DEBUG + if (!paramidx) type_print(p->Ptype); +#endif + assert(paramidx); + tmpbuf.write32(paramidx); + } + + if (!functypebuf) + functypebuf = new Outbuffer(); + unsigned functypebufidx = functypebuf->size(); + functypebuf->write(tmpbuf.buf, tmpbuf.size()); + /* If it's in the cache already, return the existing typidx + */ + if (!functype_table) + functype_table = new AArray(&ti_atype, sizeof(unsigned)); + Atype functype; + functype.buf = functypebuf; + functype.start = functypebufidx; + functype.end = functypebuf->size(); + unsigned *pidx = (unsigned *)functype_table->get(&functype); + if (*pidx) + { // Reuse existing typidx + functypebuf->setsize(functypebufidx); + return *pidx; + } + + /* Not in the cache, create a new typidx + */ + Outbuffer abuf; // for abbrev + abuf.writeByte(DW_TAG_subroutine_type); + if (params) + { + abuf.writeByte(1); // children + abuf.writeByte(DW_AT_sibling); abuf.writeByte(DW_FORM_ref4); + } + else + abuf.writeByte(0); // no children + abuf.writeByte(DW_AT_prototyped); abuf.writeByte(DW_FORM_flag); + if (nextidx != 0) // Don't write DW_AT_type for void + { abuf.writeByte(DW_AT_type); abuf.writeByte(DW_FORM_ref4); + } + + abuf.writeByte(0); abuf.writeByte(0); + code = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned paramcode; + if (params) + { abuf.reset(); + abuf.writeByte(DW_TAG_formal_parameter); + abuf.writeByte(0); + abuf.writeByte(DW_AT_type); abuf.writeByte(DW_FORM_ref4); + abuf.writeByte(0); abuf.writeByte(0); + paramcode = dwarf_abbrev_code(abuf.buf, abuf.size()); + } + + unsigned idxsibling = 0; + unsigned siblingoffset; + + idx = infobuf->size(); + infobuf->writeuLEB128(code); + siblingoffset = infobuf->size(); + if (params) + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->writeByte(1); // DW_AT_prototyped + if (nextidx) // if return type is not void + infobuf->write32(nextidx); // DW_AT_type + + if (params) + { unsigned *pparamidx = (unsigned *)(functypebuf->buf + functypebufidx); + //printf("2: functypebufidx = %x, pparamidx = %p, size = %x\n", functypebufidx, pparamidx, functypebuf->size()); + for (param_t *p = t->Tparamtypes; p; p = p->Pnext) + { infobuf->writeuLEB128(paramcode); + //unsigned x = dwarf_typidx(p->Ptype); + unsigned paramidx = *++pparamidx; + //printf("paramidx = %d\n", paramidx); + assert(paramidx); + infobuf->write32(paramidx); // DW_AT_type + } + infobuf->writeByte(0); // end parameter list + + // This is why the usual typidx caching does not work; this is unique every time + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } + + *pidx = idx; // remember it in the functype_table[] cache + break; + } + + case TYarray: + { static unsigned char abbrevTypeArray[] = + { + DW_TAG_array_type, + 1, // child (the subrange type) + DW_AT_sibling, DW_FORM_ref4, + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeArrayVoid[] = + { + DW_TAG_array_type, + 1, // child (the subrange type) + DW_AT_sibling, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeSubrange[] = + { + DW_TAG_subrange_type, + 0, // no children + DW_AT_type, DW_FORM_ref4, + DW_AT_upper_bound, DW_FORM_data4, + 0, 0, + }; + static unsigned char abbrevTypeSubrange2[] = + { + DW_TAG_subrange_type, + 0, // no children + DW_AT_type, DW_FORM_ref4, + 0, 0, + }; + unsigned code2 = (t->Tflags & TFsizeunknown) + ? dwarf_abbrev_code(abbrevTypeSubrange2, sizeof(abbrevTypeSubrange2)) + : dwarf_abbrev_code(abbrevTypeSubrange, sizeof(abbrevTypeSubrange)); + unsigned idxbase = dwarf_typidx(tssize); + unsigned idxsibling = 0; + unsigned siblingoffset; + nextidx = dwarf_typidx(t->Tnext); + unsigned code1 = nextidx ? dwarf_abbrev_code(abbrevTypeArray, sizeof(abbrevTypeArray)) + : dwarf_abbrev_code(abbrevTypeArrayVoid, sizeof(abbrevTypeArrayVoid)); + idx = infobuf->size(); + + infobuf->writeuLEB128(code1); // DW_TAG_array_type + siblingoffset = infobuf->size(); + infobuf->write32(idxsibling); // DW_AT_sibling + if (nextidx) + infobuf->write32(nextidx); // DW_AT_type + + infobuf->writeuLEB128(code2); // DW_TAG_subrange_type + infobuf->write32(idxbase); // DW_AT_type + if (!(t->Tflags & TFsizeunknown)) + infobuf->write32(t->Tdim ? t->Tdim - 1 : 0); // DW_AT_upper_bound + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + break; + } + + // SIMD vector types + case TYfloat4: tbase = tsfloat; goto Lvector; + case TYdouble2: tbase = tsdouble; goto Lvector; + case TYschar16: tbase = tsschar; goto Lvector; + case TYuchar16: tbase = tsuchar; goto Lvector; + case TYshort8: tbase = tsshort; goto Lvector; + case TYushort8: tbase = tsushort; goto Lvector; + case TYlong4: tbase = tslong; goto Lvector; + case TYulong4: tbase = tsulong; goto Lvector; + case TYllong2: tbase = tsllong; goto Lvector; + case TYullong2: tbase = tsullong; goto Lvector; + Lvector: + { static unsigned char abbrevTypeArray[] = + { + DW_TAG_array_type, + 1, // child (the subrange type) + (DW_AT_GNU_vector & 0x7F) | 0x80, DW_AT_GNU_vector >> 7, DW_FORM_flag, + DW_AT_type, DW_FORM_ref4, + DW_AT_sibling, DW_FORM_ref4, + 0, 0, + }; + static unsigned char abbrevTypeBaseTypeSibling[] = + { + DW_TAG_base_type, + 0, // no children + DW_AT_byte_size, DW_FORM_data1, // sizeof(tssize_t) + DW_AT_encoding, DW_FORM_data1, // DW_ATE_unsigned + 0, 0, + }; + + unsigned code2 = dwarf_abbrev_code(abbrevTypeBaseTypeSibling, sizeof(abbrevTypeBaseTypeSibling)); + unsigned code1 = dwarf_abbrev_code(abbrevTypeArray, sizeof(abbrevTypeArray)); + unsigned idxbase = dwarf_typidx(tbase); + unsigned idxsibling = 0; + unsigned siblingoffset; + + idx = infobuf->size(); + + infobuf->writeuLEB128(code1); // DW_TAG_array_type + infobuf->writeByte(1); // DW_AT_GNU_vector + infobuf->write32(idxbase); // DW_AT_type + siblingoffset = infobuf->size(); + infobuf->write32(idxsibling); // DW_AT_sibling + + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + + // Not sure why this is necessary instead of using dwarf_typidx(tssize), but gcc does it + infobuf->writeuLEB128(code2); // DW_TAG_base_type + infobuf->writeByte(tysize(tssize->Tty)); // DW_AT_byte_size + infobuf->writeByte(DW_ATE_unsigned); // DT_AT_encoding + + infobuf->writeByte(0); // no more siblings + break; + } + + case TYwchar_t: + { + unsigned code = dwarf_abbrev_code(abbrevWchar, sizeof(abbrevWchar)); + unsigned typebase = dwarf_typidx(tsint); + idx = infobuf->size(); + infobuf->writeuLEB128(code); // abbreviation code + infobuf->writeString("wchar_t"); // DW_AT_name + infobuf->write32(typebase); // DW_AT_type + infobuf->writeByte(1); // DW_AT_decl_file + infobuf->writeWord(1); // DW_AT_decl_line + typidx_tab[ty] = idx; + break; + } + + + case TYstruct: + { + Classsym *s = t->Ttag; + struct_t *st = s->Sstruct; + + if (s->Stypidx) + return s->Stypidx; + + static unsigned char abbrevTypeStruct0[] = + { + DW_TAG_structure_type, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_byte_size, DW_FORM_data1, + 0, 0, + }; + static unsigned char abbrevTypeStruct1[] = + { + DW_TAG_structure_type, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_declaration, DW_FORM_flag, + 0, 0, + }; + + if (t->Tflags & (TFsizeunknown | TFforward)) + { + abbrevTypeStruct1[0] = (st->Sflags & STRunion) + ? DW_TAG_union_type : DW_TAG_structure_type; + code = dwarf_abbrev_code(abbrevTypeStruct1, sizeof(abbrevTypeStruct1)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); + infobuf->writeString(s->Sident); // DW_AT_name + infobuf->writeByte(1); // DW_AT_declaration + break; // don't set Stypidx + } + + Outbuffer fieldidx; + + // Count number of fields + unsigned nfields = 0; + symlist_t sl; + t->Tflags |= TFforward; + for (sl = st->Sfldlst; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + + switch (sf->Sclass) + { + case SCmember: + fieldidx.write32(dwarf_typidx(sf->Stype)); + nfields++; + break; + } + } + t->Tflags &= ~TFforward; + if (nfields == 0) + { + abbrevTypeStruct0[0] = (st->Sflags & STRunion) + ? DW_TAG_union_type : DW_TAG_structure_type; + abbrevTypeStruct0[1] = 0; // no children + abbrevTypeStruct0[5] = DW_FORM_data1; // DW_AT_byte_size + code = dwarf_abbrev_code(abbrevTypeStruct0, sizeof(abbrevTypeStruct0)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); + infobuf->writeString(s->Sident); // DW_AT_name + infobuf->writeByte(0); // DW_AT_byte_size + } + else + { + Outbuffer abuf; // for abbrev + abuf.writeByte((st->Sflags & STRunion) + ? DW_TAG_union_type : DW_TAG_structure_type); + abuf.writeByte(1); // children + abuf.writeByte(DW_AT_sibling); abuf.writeByte(DW_FORM_ref4); + abuf.writeByte(DW_AT_name); abuf.writeByte(DW_FORM_string); + abuf.writeByte(DW_AT_byte_size); + + size_t sz = st->Sstructsize; + if (sz <= 0xFF) + abuf.writeByte(DW_FORM_data1); // DW_AT_byte_size + else if (sz <= 0xFFFF) + abuf.writeByte(DW_FORM_data2); // DW_AT_byte_size + else + abuf.writeByte(DW_FORM_data4); // DW_AT_byte_size + abuf.writeByte(0); abuf.writeByte(0); + + code = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned membercode; + abuf.reset(); + abuf.writeByte(DW_TAG_member); + abuf.writeByte(0); // no children + abuf.writeByte(DW_AT_name); + abuf.writeByte(DW_FORM_string); + abuf.writeByte(DW_AT_type); + abuf.writeByte(DW_FORM_ref4); + abuf.writeByte(DW_AT_data_member_location); + abuf.writeByte(DW_FORM_block1); + abuf.writeByte(0); + abuf.writeByte(0); + membercode = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned idxsibling = 0; + unsigned siblingoffset; + + idx = infobuf->size(); + infobuf->writeuLEB128(code); + siblingoffset = infobuf->size(); + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->writeString(s->Sident); // DW_AT_name + if (sz <= 0xFF) + infobuf->writeByte(sz); // DW_AT_byte_size + else if (sz <= 0xFFFF) + infobuf->writeWord(sz); // DW_AT_byte_size + else + infobuf->write32(sz); // DW_AT_byte_size + + s->Stypidx = idx; + unsigned n = 0; + for (sl = st->Sfldlst; sl; sl = list_next(sl)) + { symbol *sf = list_symbol(sl); + size_t soffset; + + switch (sf->Sclass) + { + case SCmember: + infobuf->writeuLEB128(membercode); + infobuf->writeString(sf->Sident); + //infobuf->write32(dwarf_typidx(sf->Stype)); + unsigned fi = ((unsigned *)fieldidx.buf)[n]; + infobuf->write32(fi); + n++; + soffset = infobuf->size(); + infobuf->writeByte(2); + infobuf->writeByte(DW_OP_plus_uconst); + infobuf->writeuLEB128(sf->Smemoff); + infobuf->buf[soffset] = infobuf->size() - soffset - 1; + break; + } + } + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + } + s->Stypidx = idx; + return idx; // no need to cache it + } + + case TYenum: + { static unsigned char abbrevTypeEnum[] = + { + DW_TAG_enumeration_type, + 1, // child (the subrange type) + DW_AT_sibling, DW_FORM_ref4, + DW_AT_name, DW_FORM_string, + DW_AT_byte_size, DW_FORM_data1, + 0, 0, + }; + static unsigned char abbrevTypeEnumMember[] = + { + DW_TAG_enumerator, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_const_value, DW_FORM_data1, + 0, 0, + }; + + symbol *s = t->Ttag; + enum_t *se = s->Senum; + type *tbase = s->Stype->Tnext; + unsigned sz = type_size(tbase); + symlist_t sl; + + if (s->Stypidx) + return s->Stypidx; + + if (se->SEflags & SENforward) + { + static unsigned char abbrevTypeEnumForward[] = + { + DW_TAG_enumeration_type, + 0, // no children + DW_AT_name, DW_FORM_string, + DW_AT_declaration, DW_FORM_flag, + 0, 0, + }; + code = dwarf_abbrev_code(abbrevTypeEnumForward, sizeof(abbrevTypeEnumForward)); + idx = infobuf->size(); + infobuf->writeuLEB128(code); + infobuf->writeString(s->Sident); // DW_AT_name + infobuf->writeByte(1); // DW_AT_declaration + break; // don't set Stypidx + } + + Outbuffer abuf; // for abbrev + abuf.write(abbrevTypeEnum, sizeof(abbrevTypeEnum)); + code = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned membercode; + abuf.reset(); + abuf.writeByte(DW_TAG_enumerator); + abuf.writeByte(0); + abuf.writeByte(DW_AT_name); + abuf.writeByte(DW_FORM_string); + abuf.writeByte(DW_AT_const_value); + if (tyuns(tbase->Tty)) + abuf.writeByte(DW_FORM_udata); + else + abuf.writeByte(DW_FORM_sdata); + abuf.writeByte(0); + abuf.writeByte(0); + membercode = dwarf_abbrev_code(abuf.buf, abuf.size()); + + unsigned idxsibling = 0; + unsigned siblingoffset; + + idx = infobuf->size(); + infobuf->writeuLEB128(code); + siblingoffset = infobuf->size(); + infobuf->write32(idxsibling); // DW_AT_sibling + infobuf->writeString(s->Sident); // DW_AT_name + infobuf->writeByte(sz); // DW_AT_byte_size + + for (sl = s->Senumlist; sl; sl = list_next(sl)) + { symbol *sf = (symbol *)list_ptr(sl); + unsigned long value = el_tolongt(sf->Svalue); + + infobuf->writeuLEB128(membercode); + infobuf->writeString(sf->Sident); + if (tyuns(tbase->Tty)) + infobuf->writeuLEB128(value); + else + infobuf->writesLEB128(value); + } + + infobuf->writeByte(0); // no more siblings + idxsibling = infobuf->size(); + *(unsigned *)(infobuf->buf + siblingoffset) = idxsibling; + + s->Stypidx = idx; + return idx; // no need to cache it + } + + default: + return 0; + } +Lret: + /* If infobuf->buf[idx .. size()] is already in infobuf, + * discard this one and use the previous one. + */ + Atype atype; + atype.buf = infobuf; + atype.start = idx; + atype.end = infobuf->size(); + + if (!type_table) + /* unsigned[Adata] type_table; + * where the table values are the type indices + */ + type_table = new AArray(&ti_atype, sizeof(unsigned)); + + unsigned *pidx; + pidx = (unsigned *)type_table->get(&atype); + if (!*pidx) // if no idx assigned yet + { + *pidx = idx; // assign newly computed idx + } + else + { // Reuse existing code + infobuf->setsize(idx); // discard current + idx = *pidx; + } + return idx; +} + +/* ======================= Abbreviation Codes ====================== */ + +struct Adata +{ + size_t start; + size_t end; +}; + +struct TypeInfo_Adata : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +TypeInfo_Adata ti_adata; + +const char* TypeInfo_Adata::toString() +{ + return "Adata"; +} + +hash_t TypeInfo_Adata::getHash(void *p) +{ Adata a; + hash_t hash = 0; + size_t i; + + a = *(Adata *)p; + for (i = a.start; i < a.end; i++) + { + //printf("%02x ", abbrevbuf->buf[i]); + hash = hash * 11 + abbrevbuf->buf[i]; + } + //printf("\nhash = %x, length = %d\n", hash, a.end - a.start); + return hash; +} + +int TypeInfo_Adata::equals(void *p1, void *p2) +{ + Adata a1 = *(Adata*)p1; + Adata a2 = *(Adata*)p2; + size_t len = a1.end - a1.start; + + return len == a2.end - a2.start && + memcmp(abbrevbuf->buf + a1.start, abbrevbuf->buf + a2.start, len) == 0; +} + +int TypeInfo_Adata::compare(void *p1, void *p2) +{ + Adata a1 = *(Adata*)p1; + Adata a2 = *(Adata*)p2; + size_t len = a1.end - a1.start; + if (len == a2.end - a2.start) + return memcmp(abbrevbuf->buf + a1.start, abbrevbuf->buf + a2.start, len); + else if (len < a2.end - a2.start) + return -1; + else + return 1; +} + +size_t TypeInfo_Adata::tsize() +{ + return sizeof(Adata); +} + +void TypeInfo_Adata::swap(void *p1, void *p2) +{ + assert(0); +} + + +unsigned dwarf_abbrev_code(unsigned char *data, size_t nbytes) +{ + if (!abbrev_table) + /* unsigned[Adata] abbrev_table; + * where the table values are the abbreviation codes. + */ + abbrev_table = new AArray(&ti_adata, sizeof(unsigned)); + + /* Write new entry into abbrevbuf + */ + Adata adata; + + unsigned idx = abbrevbuf->size(); + abbrevcode++; + abbrevbuf->writeuLEB128(abbrevcode); + adata.start = abbrevbuf->size(); + abbrevbuf->write(data, nbytes); + adata.end = abbrevbuf->size(); + + /* If abbrevbuf->buf[idx .. size()] is already in abbrevbuf, + * discard this one and use the previous one. + */ + + unsigned *pcode; + pcode = (unsigned *)abbrev_table->get(&adata); + if (!*pcode) // if no code assigned yet + { + *pcode = abbrevcode; // assign newly computed code + } + else + { // Reuse existing code + abbrevbuf->setsize(idx); // discard current + abbrevcode--; + } + return *pcode; +} + +#endif +#endif diff --git a/backend/dwarf.h b/backend/dwarf.h new file mode 100644 index 00000000..17ef6c65 --- /dev/null +++ b/backend/dwarf.h @@ -0,0 +1,18 @@ + +#ifndef DWARF_H +#define DWARF_H + +/* ==================== Dwarf debug ======================= */ + +// #define USE_DWARF_D_EXTENSIONS + +void dwarf_initfile(const char *filename); +void dwarf_termfile(); +void dwarf_initmodule(const char *filename, const char *modulename); +void dwarf_termmodule(); +void dwarf_func_start(Symbol *sfunc); +void dwarf_func_term(Symbol *sfunc); +unsigned dwarf_typidx(type *t); +unsigned dwarf_abbrev_code(unsigned char *data, size_t nbytes); + +#endif diff --git a/backend/dwarf2.h b/backend/dwarf2.h new file mode 100644 index 00000000..7aa9d7f4 --- /dev/null +++ b/backend/dwarf2.h @@ -0,0 +1,470 @@ + +// dwarf2.h +// Reflects declarations from the Dwarf 3 spec, not the Digital Mars +// dwarf implementation + +enum +{ + DW_TAG_array_type = 0x01, + DW_TAG_class_type = 0x02, + DW_TAG_entry_point = 0x03, + DW_TAG_enumeration_type = 0x04, + DW_TAG_formal_parameter = 0x05, + DW_TAG_imported_declaration = 0x08, + DW_TAG_label = 0x0A, + DW_TAG_lexical_block = 0x0B, + DW_TAG_member = 0x0D, + DW_TAG_pointer_type = 0x0F, + DW_TAG_reference_type = 0x10, + DW_TAG_compile_unit = 0x11, + DW_TAG_string_type = 0x12, + DW_TAG_structure_type = 0x13, + DW_TAG_subroutine_type = 0x15, + DW_TAG_typedef = 0x16, + DW_TAG_union_type = 0x17, + DW_TAG_unspecified_parameters = 0x18, + DW_TAG_variant = 0x19, + DW_TAG_common_block = 0x1A, + DW_TAG_common_inclusion = 0x1B, + DW_TAG_inheritance = 0x1C, + DW_TAG_inlined_subroutine = 0x1D, + DW_TAG_module = 0x1E, + DW_TAG_ptr_to_member_type = 0x1F, + DW_TAG_set_type = 0x20, + DW_TAG_subrange_type = 0x21, + DW_TAG_with_stmt = 0x22, + DW_TAG_access_declaration = 0x23, + DW_TAG_base_type = 0x24, + DW_TAG_catch_block = 0x25, + DW_TAG_const_type = 0x26, + DW_TAG_constant = 0x27, + DW_TAG_enumerator = 0x28, + DW_TAG_file_type = 0x29, + DW_TAG_friend = 0x2A, + DW_TAG_namelist = 0x2B, + DW_TAG_namelist_item = 0x2C, + DW_TAG_packed_type = 0x2D, + DW_TAG_subprogram = 0x2E, + DW_TAG_template_type_param = 0x2F, + DW_TAG_template_value_param = 0x30, + DW_TAG_thrown_type = 0x31, + DW_TAG_try_block = 0x32, + DW_TAG_variant_part = 0x33, + DW_TAG_variable = 0x34, + DW_TAG_volatile_type = 0x35, + + DW_TAG_dwarf_procedure = 0x36, + DW_TAG_restrict_type = 0x37, + DW_TAG_interface_type = 0x38, + DW_TAG_namespace = 0x39, + DW_TAG_imported_module = 0x3A, + DW_TAG_unspecified_type = 0x3B, + DW_TAG_partial_unit = 0x3C, + DW_TAG_imported_unit = 0x3D, + DW_TAG_condition = 0x3F, + DW_TAG_shared_type = 0x40, + + // D programming language extensions +#ifdef USE_DWARF_D_EXTENSIONS + DW_TAG_darray_type = 0x41, + DW_TAG_aarray_type = 0x42, + DW_TAG_delegate_type = 0x43, +#endif + + DW_TAG_lo_user = 0x4080, + DW_TAG_hi_user = 0xFFFF, +}; + +enum +{ + DW_CHILDREN_no = 0x00, + DW_CHILDREN_yes = 0x01, +}; + +enum +{ + DW_AT_sibling = 0x01, + DW_AT_location = 0x02, + DW_AT_name = 0x03, + DW_AT_ordering = 0x09, + DW_AT_byte_size = 0x0B, + DW_AT_bit_offset = 0x0C, + DW_AT_bit_size = 0x0D, + DW_AT_stmt_list = 0x10, + DW_AT_low_pc = 0x11, + DW_AT_high_pc = 0x12, + DW_AT_language = 0x13, + DW_AT_discr = 0x15, + DW_AT_discr_value = 0x16, + DW_AT_visibility = 0x17, + DW_AT_import = 0x18, + DW_AT_string_length = 0x19, + DW_AT_common_reference = 0x1A, + DW_AT_comp_dir = 0x1B, + DW_AT_const_value = 0x1C, + DW_AT_containing_type = 0x1D, + DW_AT_default_value = 0x1E, + DW_AT_inline = 0x20, + DW_AT_is_optional = 0x21, + DW_AT_lower_bound = 0x22, + DW_AT_producer = 0x25, + DW_AT_prototyped = 0x27, + DW_AT_return_addr = 0x2A, + DW_AT_start_scope = 0x2C, + DW_AT_stride_size = 0x2E, + DW_AT_upper_bound = 0x2F, + DW_AT_abstract_origin = 0x31, + DW_AT_accessibility = 0x32, + DW_AT_address_class = 0x33, + DW_AT_artificial = 0x34, + DW_AT_base_types = 0x35, + DW_AT_calling_convention = 0x36, + DW_AT_count = 0x37, + DW_AT_data_member_location = 0x38, + DW_AT_decl_column = 0x39, + DW_AT_decl_file = 0x3A, + DW_AT_decl_line = 0x3B, + DW_AT_declaration = 0x3C, + DW_AT_discr_list = 0x3D, + DW_AT_encoding = 0x3E, + DW_AT_external = 0x3F, + DW_AT_frame_base = 0x40, + DW_AT_friend = 0x41, + DW_AT_identifier_case = 0x42, + DW_AT_macro_info = 0x43, + DW_AT_namelist_item = 0x44, + DW_AT_priority = 0x45, + DW_AT_segment = 0x46, + DW_AT_specification = 0x47, + DW_AT_static_link = 0x48, + DW_AT_type = 0x49, + DW_AT_use_location = 0x4A, + DW_AT_variable_parameter = 0x4B, + DW_AT_virtuality = 0x4C, + DW_AT_vtable_elem_location = 0x4D, + + DW_AT_allocated = 0x4E, + DW_AT_associated = 0x4F, + DW_AT_data_location = 0x50, + DW_AT_byte_stride = 0x51, + DW_AT_entry_pc = 0x52, + DW_AT_use_UTF8 = 0x53, + DW_AT_extension = 0x54, + DW_AT_ranges = 0x55, + DW_AT_trampoline = 0x56, + DW_AT_call_column = 0x57, + DW_AT_call_file = 0x58, + DW_AT_call_line = 0x59, + DW_AT_description = 0x5A, + DW_AT_binary_scale = 0x5B, + DW_AT_decimal_scale = 0x5C, + DW_AT_small = 0x5D, + DW_AT_decimal_sign = 0x5E, + DW_AT_digit_count = 0x5F, + DW_AT_picture_string = 0x60, + DW_AT_mutable = 0x61, + DW_AT_threads_scaled = 0x62, + DW_AT_explicit = 0x63, + DW_AT_object_pointer = 0x64, + DW_AT_endianity = 0x65, + DW_AT_elemental = 0x66, + DW_AT_pure = 0x67, + DW_AT_recursive = 0x68, + + DW_AT_lo_user = 0x2000, + DW_AT_MIPS_linkage_name = 0x2007, + DW_AT_GNU_vector = 0x2107, + DW_AT_hi_user = 0x3FFF, +}; + +enum +{ + DW_FORM_addr = 0x01, + DW_FORM_block2 = 0x03, + DW_FORM_block4 = 0x04, + DW_FORM_data2 = 0x05, + DW_FORM_data4 = 0x06, + DW_FORM_data8 = 0x07, + DW_FORM_string = 0x08, + DW_FORM_block = 0x09, + DW_FORM_block1 = 0x0A, + DW_FORM_data1 = 0x0B, + DW_FORM_flag = 0x0C, + DW_FORM_sdata = 0x0D, + DW_FORM_strp = 0x0E, + DW_FORM_udata = 0x0F, + DW_FORM_ref_addr = 0x10, + DW_FORM_ref1 = 0x11, + DW_FORM_ref2 = 0x12, + DW_FORM_ref4 = 0x13, + DW_FORM_ref8 = 0x14, + DW_FORM_ref_udata = 0x15, + DW_FORM_indirect = 0x16, +}; + +enum +{ + DW_OP_addr = 0x03, + DW_OP_deref = 0x06, + DW_OP_const1u = 0x08, + DW_OP_const1s = 0x09, + DW_OP_const2u = 0x0a, + DW_OP_const2s = 0x0b, + DW_OP_const4u = 0x0c, + DW_OP_const4s = 0x0d, + DW_OP_const8u = 0x0e, + DW_OP_const8s = 0x0f, + DW_OP_constu = 0x10, + DW_OP_consts = 0x11, + DW_OP_dup = 0x12, + DW_OP_drop = 0x13, + DW_OP_over = 0x14, + DW_OP_pick = 0x15, + DW_OP_swap = 0x16, + DW_OP_rot = 0x17, + DW_OP_xderef = 0x18, + DW_OP_abs = 0x19, + DW_OP_and = 0x1a, + DW_OP_div = 0x1b, + DW_OP_minus = 0x1c, + DW_OP_mod = 0x1d, + DW_OP_mul = 0x1e, + DW_OP_neg = 0x1f, + DW_OP_not = 0x20, + DW_OP_or = 0x21, + DW_OP_plus = 0x22, + DW_OP_plus_uconst = 0x23, + DW_OP_shl = 0x24, + DW_OP_shr = 0x25, + DW_OP_shra = 0x26, + DW_OP_xor = 0x27, + DW_OP_skip = 0x2f, + DW_OP_bra = 0x28, + DW_OP_eq = 0x29, + DW_OP_ge = 0x2a, + + DW_OP_gt = 0x2b, + DW_OP_le = 0x2c, + DW_OP_lt = 0x2d, + DW_OP_ne = 0x2e, + DW_OP_lit0 = 0x30, + DW_OP_lit1 = 0x31, + DW_OP_lit31 = 0x4f, + DW_OP_reg0 = 0x50, + DW_OP_reg1 = 0x51, + DW_OP_reg31 = 0x6f, + DW_OP_breg0 = 0x70, + DW_OP_breg1 = 0x71, + DW_OP_breg31 = 0x8f, + DW_OP_regx = 0x90, + DW_OP_fbreg = 0x91, + DW_OP_bregx = 0x92, + DW_OP_piece = 0x93, + DW_OP_deref_size = 0x94, + DW_OP_xderef_size = 0x95, + DW_OP_nop = 0x96, + DW_OP_push_object_address = 0x97, + DW_OP_call2 = 0x98, + DW_OP_call4 = 0x99, + DW_OP_call_ref = 0x9a, + DW_OP_form_tls_address = 0x9b, + DW_OP_call_frame_cfa = 0x9c, + DW_OP_bit_piece = 0x9d, + DW_OP_lo_user = 0xe0, + DW_OP_hi_user = 0xff, +}; + +enum +{ + DW_ATE_address = 0x01, + DW_ATE_boolean = 0x02, + DW_ATE_complex_float = 0x03, + DW_ATE_float = 0x04, + DW_ATE_signed = 0x05, + DW_ATE_signed_char = 0x06, + DW_ATE_unsigned = 0x07, + DW_ATE_unsigned_char = 0x08, + DW_ATE_imaginary_float = 0x09, + DW_ATE_packed_decimal = 0x0a, + DW_ATE_numeric_string = 0x0b, + DW_ATE_editted = 0x0c, + DW_ATE_signed_fixed = 0x0d, + DW_ATE_unsigned_fixed = 0x0e, + DW_ATE_decimal_float = 0x0f, + DW_ATE_lo_user = 0x80, + DW_ATE_hi_user = 0xff, +}; + +enum +{ + DW_DS_unsigned = 0x01, + DW_DS_leading_overpunch = 0x02, + DW_DS_trailing_overpunch = 0x03, + DW_DS_leading_separate = 0x04, + DW_DS_trailing_separate = 0x05, +}; + +enum +{ + DW_END_default = 0x00, + DW_END_big = 0x01, + DW_END_little = 0x02, + DW_END_lo_user = 0x40, + DW_END_hi_user = 0xff, +}; + +enum +{ + DW_ACCESS_public = 0x01, + DW_ACCESS_protected = 0x02, + DW_ACCESS_private = 0x03, +}; + +enum +{ + DW_VIS_local = 0x01, + DW_VIS_exported = 0x02, + DW_VIS_qualified = 0x03, +}; + +enum +{ + DW_VIRTUALITY_none = 0x00, + DW_VIRTUALITY_virtual = 0x01, + DW_VIRTUALITY_pure_virtual = 0x02, +}; + +enum +{ + DW_LANG_C89 = 0x0001, + DW_LANG_C = 0x0002, + DW_LANG_Ada83 = 0x0003, + DW_LANG_C_plus_plus = 0x0004, + DW_LANG_Cobol74 = 0x0005, + DW_LANG_Cobol85 = 0x0006, + DW_LANG_Fortran77 = 0x0007, + DW_LANG_Fortran90 = 0x0008, + DW_LANG_Pascal83 = 0x0009, + DW_LANG_Modula2 = 0x000a, + DW_LANG_Java = 0x000b, + DW_LANG_C99 = 0x000c, + DW_LANG_Ada95 = 0x000d, + DW_LANG_Fortran95 = 0x000e, + DW_LANG_PLI = 0x000f, + DW_LANG_ObjC = 0x0010, + DW_LANG_ObjC_plus_plus = 0x0011, + DW_LANG_UPC = 0x0012, + DW_LANG_D = 0x0013, + DW_LANG_lo_user = 0x8000, + DW_LANG_hi_user = 0xffff, +}; + +enum +{ + DW_ID_case_sensitive = 0x00, + DW_ID_up_case = 0x01, + DW_ID_down_case = 0x02, + DW_ID_case_insensitive = 0x03, +}; + +enum +{ + DW_CC_normal = 0x01, + DW_CC_program = 0x02, + DW_CC_nocall = 0x03, + DW_CC_lo_user = 0x40, + DW_CC_hi_user = 0xff, +}; + +enum +{ + DW_INL_not_inlined = 0x00, + DW_INL_inlined = 0x01, + DW_INL_declared_not_inlined = 0x02, + DW_INL_declared_inlined = 0x03, +}; + +enum +{ + DW_ORD_row_major = 0x00, + DW_ORD_col_major = 0x01, +}; + +enum +{ + DW_DSC_label = 0x00, + DW_DSC_range = 0x01, +}; + +enum +{ + DW_LNS_copy = 0x01, + DW_LNS_advance_pc = 0x02, + DW_LNS_advance_line = 0x03, + DW_LNS_set_file = 0x04, + DW_LNS_set_column = 0x05, + DW_LNS_negate_stmt = 0x06, + DW_LNS_set_basic_block = 0x07, + DW_LNS_const_add_pc = 0x08, + DW_LNS_fixed_advance_pc = 0x09, + DW_LNS_set_prologue_end = 0x0a, + DW_LNS_set_epilogue_begin = 0x0b, + DW_LNS_set_isa = 0x0c, +}; + +enum +{ + DW_LNE_end_sequence = 0x01, + DW_LNE_set_address = 0x02, + DW_LNE_define_file = 0x03, + DW_LNE_lo_user = 0x80, + DW_LNE_hi_user = 0xff, +}; + +enum +{ + DW_MACINFO_define = 0x01, + DW_MACINFO_undef = 0x02, + DW_MACINFO_start_file = 0x03, + DW_MACINFO_end_file = 0x04, + DW_MACINFO_vendor_ext = 0xff, +}; + +enum +{ + DW_CFA_advance_loc = 0x40, + DW_CFA_offset = 0x80, + DW_CFA_restore = 0xc0, + DW_CFA_nop = 0x00, + DW_CFA_set_loc = 0x01, + DW_CFA_advance_loc1 = 0x02, + DW_CFA_advance_loc2 = 0x03, + DW_CFA_advance_loc4 = 0x04, + DW_CFA_offset_extended = 0x05, + DW_CFA_restore_extended = 0x06, + DW_CFA_undefined = 0x07, + DW_CFA_same_value = 0x08, + DW_CFA_register = 0x09, + DW_CFA_remember_state = 0x0a, + DW_CFA_restore_state = 0x0b, + DW_CFA_def_cfa = 0x0c, + DW_CFA_def_cfa_register = 0x0d, + DW_CFA_def_cfa_offset = 0x0e, + DW_CFA_def_cfa_expression = 0x0f, + DW_CFA_expression = 0x10, + DW_CFA_offset_extended_sf = 0x11, + DW_CFA_def_cfa_sf = 0x12, + DW_CFA_def_cfa_offset_sf = 0x13, + DW_CFA_val_offset = 0x14, + DW_CFA_val_offset_sf = 0x15, + DW_CFA_val_expression = 0x16, + + DW_CFA_GNU_window_save = 0x2d, + DW_CFA_GNU_args_size = 0x2e, + DW_CFA_GNU_negative_offset_extended = 0x2f, + + DW_CFA_lo_user = 0x1c, + DW_CFA_hi_user = 0x3f, +}; + + diff --git a/backend/ee.c b/backend/ee.c new file mode 100644 index 00000000..3f21254d --- /dev/null +++ b/backend/ee.c @@ -0,0 +1,124 @@ +// Copyright (C) 1995-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +/* + * Code to handle debugger expression evaluation + */ + +#if !SPP + +#include +#include +#include +#include "cc.h" +#include "token.h" +#include "global.h" +#include "type.h" +#include "oper.h" +#include "el.h" +#include "exh.h" +#if TX86 +#include "cgcv.h" +#endif + +#if SCPP +#include "parser.h" +#endif + +#include "iasm.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +#if MARS +EEcontext eecontext; +#endif + +////////////////////////////////////// +// Convert any symbols generated for the debugger expression to SCstack +// storage class. + +void eecontext_convs(unsigned marksi) +{ unsigned u; + unsigned top; + symtab_t *ps; + + // Change all generated SCtmp's and SCauto's to SCstack's +#if SCPP + ps = &globsym; +#else + ps = cstate.CSpsymtab; +#endif + top = ps->top; + //printf("eecontext_convs(%d,%d)\n",marksi,top); + for (u = marksi; u < top; u++) + { symbol *s; + + s = ps->tab[u]; + switch (s->Sclass) + { + case SCauto: + case SCtmp: + case SCregister: + s->Sclass = SCstack; + s->Sfl = FLstack; + break; + } + } +} + +//////////////////////////////////////// +// Parse the debugger expression. + +#if SCPP + +void eecontext_parse() +{ + if (eecontext.EEimminent) + { type *t; + unsigned marksi; + symbol *s; + + //printf("imminent\n"); + marksi = globsym.top; + eecontext.EEin++; + s = symbol_genauto(tspvoid); + eecontext.EEelem = func_expr_dtor(TRUE); + t = eecontext.EEelem->ET; + if (tybasic(t->Tty) != TYvoid) + { unsigned op; + elem *e; + + e = el_unat(OPind,t,el_var(s)); + op = tyaggregate(t->Tty) ? OPstreq : OPeq; + eecontext.EEelem = el_bint(op,t,e,eecontext.EEelem); + } + eecontext.EEin--; + eecontext.EEimminent = 0; + eecontext.EEfunc = funcsym_p; + + eecontext_convs(marksi); + + // Generate the typedef + if (eecontext.EEtypedef && config.fulltypes) + { symbol *s; + + s = symbol_name(eecontext.EEtypedef,SCtypedef,t); + cv_outsym(s); + symbol_free(s); + } + } +} + +#endif +#endif diff --git a/backend/el.c b/backend/el.c new file mode 100644 index 00000000..4d2f76ad --- /dev/null +++ b/backend/el.c @@ -0,0 +1,3326 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/* Routines to handle elems. */ + +#if !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "type.h" +#include "el.h" +#include "list.h" +#include "mem.h" +#include "oper.h" +#include "type.h" + +#include "code.h" + +#include "global.h" +#include "go.h" + +#if SCPP +#include "parser.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +#ifdef STATS +static int elfreed = 0; /* number of freed elems */ +static int eprm_cnt; /* max # of allocs at any point */ +#endif + +#if TARGET_OSX +extern void slist_add(Symbol *s); +#endif + +/******************************* + * Do our own storage allocation of elems. + */ + +static elem *nextfree = NULL; /* pointer to next free elem */ + +static int elcount = 0; /* number of allocated elems */ +static int elem_size = sizeof(elem); + +#ifdef DEBUG +static int elmax; /* max # of allocs at any point */ +#endif + +///////////////////////////// +// Table to gather redundant strings in. + +static struct STAB +{ symbol *sym; // symbol that refers to the string + char *p; // pointer to the string + int len; // length of string p +} stable[16]; +static int stable_si; + +/************************ + * Initialize el package. + */ + +void el_init() +{ + if (!configv.addlinenumbers) + elem_size = sizeof(elem) - sizeof(Srcpos); +} + +/******************************* + * Initialize for another run through. + */ + +void el_reset() +{ + stable_si = 0; + for (int i = 0; i < arraysize(stable); i++) + mem_free(stable[i].p); + memset(stable,0,sizeof(stable)); +} + +#if TX86 +/************************ + * Terminate el package. + */ + +void el_term() +{ +#if TERMCODE + int i; + + for (i = 0; i < arraysize(stable); i++) + mem_free(stable[i].p); + +#ifdef DEBUG + dbg_printf("Max # of elems = %d\n",elmax); +#endif + if (elcount != 0) + dbg_printf("unfreed elems = %d\n",elcount); + while (nextfree) + { elem *e; + + e = nextfree->E1; + mem_ffree(nextfree); + nextfree = e; + } +#else + assert(elcount == 0); +#endif +} +#endif + +/*********************** + * Allocate an element. + */ + +#if SCPP && __SC__ && __INTSIZE == 4 && TX86 && !_DEBUG_TRACE && !MEM_DEBUG && _WIN32 && !defined(DEBUG) + +__declspec(naked) elem *el_calloc() +{ + __asm + { + mov EAX,elcount + push EDI + + inc EAX + mov EDI,nextfree + + test EDI,EDI + je L27 + + mov EDX,E1[EDI] + mov elcount,EAX + + xor EAX,EAX + mov nextfree,EDX + jmp L30 + +L27: push sizeof(elem) + mov elcount,EAX + call mem_fmalloc + mov EDI,EAX + xor EAX,EAX + +L30: mov EDX,EDI + mov ECX,(sizeof(elem) + 3) / 4 + #if DOS386 + push DS + pop ES + #endif + rep stosd + mov EAX,EDX + pop EDI + ret + } +} + +#else + +elem *el_calloc() +{ + elem *e; + static elem ezero; + + elcount++; + if (nextfree) + { e = nextfree; + nextfree = e->E1; + } + else + e = (elem *) mem_fmalloc(sizeof(elem)); +#ifdef STATS + eprm_cnt++; +#endif + *e = ezero; /* clear it */ + +#ifdef DEBUG + e->id = IDelem; + if (elcount > elmax) + elmax = elcount; +#endif + /*dbg_printf("el_calloc() = %p\n",e);*/ + return e; +} + +#endif + +/*************** + * Free element + */ + +void el_free(elem *e) +{ + int op; + tym_t ty; + +L1: + if (!e) return; + elem_debug(e); + //dbg_printf("el_free(%p)\n",e); + //elem_print(e); + if (SCPP && PARSER) + { + ty = e->ET ? e->ET->Tty : 0; + type_free(e->ET); + } + else if (e->Ecount--) + return; // usage count + elcount--; + op = e->Eoper; + switch (op) + { + case OPconst: +#if FLOATS_IN_CODE + if (!PARSER && FLT_CODESEG_CELEM(e)) + flt_free_elem(e); +#endif + break; + + case OPvar: + break; + case OPrelconst: +#if SCPP + if (0 && PARSER && tybasic(ty) == TYmemptr) + el_free(e->EV.sm.ethis); +#endif + break; + case OPstring: + case OPasm: + mem_free(e->EV.ss.Vstring); + break; + default: + debug_assert(op < OPMAX); + if (!OTleaf(op)) + { elem *en; + + if (OTbinary(op)) + el_free(e->E2); + en = e->E1; +#ifdef DEBUG + memset(e,0xFF,elem_size); +#endif + e->E1 = nextfree; + nextfree = e; + +#ifdef STATS + elfreed++; +#endif + e = en; + goto L1; + } + break; + } +#ifdef DEBUG + memset(e,0xFF,elem_size); +#endif + e->E1 = nextfree; + nextfree = e; + +#ifdef STATS + elfreed++; +#endif +} + +#ifdef STATS +/* count number of elems available on free list */ +void el_count_free() + { + elem *e; + int count; + + for(e=nextfree;e;e=e->E1) + count++; + dbg_printf("Requests for elems %d\n",elcount); + dbg_printf("Requests to free elems %d\n",elfreed); + dbg_printf("Number of elems %d\n",eprm_cnt); + dbg_printf("Number of elems currently on free list %d\n",count); + } +#endif + +/********************* + * Combine e1 and e2 with a comma-expression. + * Be careful about either or both being NULL. + */ + +elem * el_combine(elem *e1,elem *e2) +{ + if (e1) + { if (e2) + e1 = (SCPP && PARSER) ? el_bint(OPcomma,e2->ET,e1,e2) + : el_bin(OPcomma,e2->Ety,e1,e2); + } + else + e1 = e2; + return e1; +} + +/********************* + * Combine e1 and e2 as parameters to a function. + * Be careful about either or both being NULL. + */ + +elem * el_param(elem *e1,elem *e2) +{ + //printf("el_param(%p, %p)\n", e1, e2); +#if 0 + if (e2 && e2->Eoper != OPstrpar && tybasic(e2->Ety) == TYstruct) + *(char*)0=0; +#endif + if (e1) + { if (e2) + e1 = (SCPP && PARSER) ? el_bint(OPparam,tsvoid,e1,e2) + : el_bin(OPparam,TYvoid,e1,e2); + } + else + e1 = e2; + return e1; +} + +/********************************* + * Create parameter list, terminated by a NULL. + */ + +elem *el_params(elem *e1, ...) +{ + elem *e; + va_list ap; + + e = NULL; + for (va_start(ap, e1); e1; e1 = va_arg(ap, elem *)) + { + e = el_param(e, e1); + } + va_end(ap); + return e; +} + +/***************************************** + * Do an array of parameters as a balanced + * binary tree. + */ + +elem *el_params(void **args, int length) +{ + if (length == 0) + return NULL; + if (length == 1) + return (elem *)args[0]; + int mid = length >> 1; + return el_param(el_params(args, mid), + el_params(args + mid, length - mid)); +} + +/***************************************** + * Do an array of parameters as a balanced + * binary tree. + */ + +elem *el_combines(void **args, int length) +{ + if (length == 0) + return NULL; + if (length == 1) + return (elem *)args[0]; + int mid = length >> 1; + return el_combine(el_combines(args, mid), + el_combines(args + mid, length - mid)); +} + +/*************************************** + * Return a list of the parameters. + */ + +int el_nparams(elem *e) +{ + if (e->Eoper == OPparam) + { + return el_nparams(e->E1) + el_nparams(e->E2); + } + else + return 1; +} + +/************************************* + * Create a quad word out of two dwords. + */ + +elem *el_pair(tym_t tym, elem *lo, elem *hi) +{ +#if 0 + lo = el_una(OPu32_64, TYullong, lo); + hi = el_una(OPu32_64, TYullong, hi); + hi = el_bin(OPshl, TYullong, hi, el_long(TYint, 32)); + return el_bin(OPor, tym, lo, hi); +#else + return el_bin(OPpair, tym, lo, hi); +#endif +} + + +/************************* + * Copy an element (not the tree!). + */ + +void el_copy(elem *to,elem *from) +{ + assert(to && from); + elem_debug(from); + elem_debug(to); + memcpy(to,from,elem_size); + elem_debug(to); +} + +/*********************************** + * Allocate a temporary, and return temporary elem. + */ + +elem * el_alloctmp(tym_t ty) +{ + symbol *s; + + assert(MARS || !PARSER); + s = symbol_generate(SCtmp,type_fake(ty)); + symbol_add(s); + s->Sfl = FLtmp; + s->Sflags = SFLfree | SFLunambig | GTregcand; + return el_var(s); +} + +/******************************** + * Select the e1 child of e. + */ + +elem * el_selecte1(elem *e) +{ elem *e1; + + assert(!PARSER); + elem_debug(e); + assert(EOP(e)); + e1 = e->E1; + elem_debug(e1); + if (e->E2) elem_debug(e->E2); + e->E1 = NULL; // so e1 won't be freed + if (configv.addlinenumbers) + { + if (e->Esrcpos.Slinnum) + e1->Esrcpos = e->Esrcpos; + } + e1->Ety = e->Ety; +// if (tyaggregate(e1->Ety)) +// e1->Enumbytes = e->Enumbytes; +#if MARS + if (!e1->Ejty) + e1->Ejty = e->Ejty; +#endif + el_free(e); + return e1; +} + +/******************************** + * Select the e2 child of e. + */ + +elem * el_selecte2(elem *e) +{ elem *e2; + + //dbg_printf("el_selecte2(%p)\n",e); + elem_debug(e); + assert(EBIN(e)); + if (e->E1) + elem_debug(e->E1); + e2 = e->E2; + elem_debug(e2); + e->E2 = NULL; // so e2 won't be freed + if (configv.addlinenumbers) + { + if (e->Esrcpos.Slinnum) + e2->Esrcpos = e->Esrcpos; + } + if (PARSER) + el_settype(e2,e->ET); + else + { e2->Ety = e->Ety; +// if (tyaggregate(e->Ety)) +// e2->Enumbytes = e->Enumbytes; + } + el_free(e); + return e2; +} + +/************************* + * Create and return a duplicate of e, including its leaves. + * No CSEs. + */ + +elem * el_copytree(elem *e) +{ elem *d; + + if (!e) + return e; + elem_debug(e); + d = el_calloc(); + el_copy(d,e); + assert(!e->Ecount); + if (SCPP && PARSER) + { + type_debug(d->ET); + d->ET->Tcount++; + } + if (EOP(e)) + { d->E1 = el_copytree(e->E1); + if (EBIN(e)) + d->E2 = el_copytree(e->E2); + } + else + { + switch (e->Eoper) + { case OPstring: +#if 0 + if (OPTIMIZER) + { + /* Convert the string to a static symbol and + then just refer to it, because two OPstrings can't + refer to the same string. + */ + + el_convstring(e); // convert string to symbol + d->Eoper = OPrelconst; + d->EV.sp.Vsym = e->EV.sp.Vsym; + break; + } +#endif +#if 0 + case OPrelconst: + e->EV.sm.ethis = NULL; + break; +#endif + case OPasm: + d->EV.ss.Vstring = (char *) mem_malloc(d->EV.ss.Vstrlen); + memcpy(d->EV.ss.Vstring,e->EV.ss.Vstring,e->EV.ss.Vstrlen); + break; + } + } + return d; +} + +/************************* + * Similar to el_copytree(e). But if e has any side effects, it's replaced + * with (tmp = e) and tmp is returned. + */ + +elem * el_same(elem **pe) +{ elem *e = *pe; + + if (e && el_sideeffect(e)) + { + *pe = exp2_copytotemp(e); /* convert to ((tmp=e),tmp) */ + e = (*pe)->E2; /* point at tmp */ + } + return el_copytree(e); +} + +/************************** + * Replace symbol s1 with s2 in tree. + */ + +#if SCPP + +void el_replace_sym(elem *e,symbol *s1,symbol *s2) +{ + symbol_debug(s1); + symbol_debug(s2); + while (1) + { elem_debug(e); + if (EOP(e)) + { if (EBIN(e)) + el_replace_sym(e->E2,s1,s2); + e = e->E1; + } + else + { + switch (e->Eoper) + { + case OPvar: + case OPrelconst: + if (e->EV.sp.Vsym == s1) + e->EV.sp.Vsym = s2; + break; + } + break; + } + } +} + +#endif + +/************************************* + * Does symbol s appear in tree e? + * Returns: + * 1 yes + * 0 no + */ + +#if MARS + +int el_appears(elem *e,Symbol *s) +{ + symbol_debug(s); + while (1) + { elem_debug(e); + if (EOP(e)) + { if (EBIN(e) && el_appears(e->E2,s)) + return 1; + e = e->E1; + } + else + { + switch (e->Eoper) + { + case OPvar: + case OPrelconst: + if (e->EV.sp.Vsym == s) + return 1; + break; + } + break; + } + } + return 0; +} + +/***************************************** + * Look for symbol that is a base of addressing mode e. + * Returns: + * s symbol used as base + * NULL couldn't find a base symbol + */ + +#if 0 +Symbol *el_basesym(elem *e) +{ Symbol *s; + + s = NULL; + while (1) + { elem_debug(e); + switch (e->Eoper) + { + case OPvar: + s = e->EV.sp.Vsym; + break; + case OPcomma: + e = e->E2; + continue; + case OPind: + s = el_basesym(e->E1); + break; + case OPadd: + s = el_basesym(e->E1); + if (!s) + s = el_basesym(e->E2); + break; + } + break; + } + return s; +} +#endif + +/**************************************** + * Does any definition of lvalue ed appear in e? + * Returns: + * 1 yes + * 0 no + */ + +int el_anydef(elem *ed, elem *e) +{ int op; + int edop; + Symbol *s; + elem *e1; + + edop = ed->Eoper; + s = (edop == OPvar) ? ed->EV.sp.Vsym : NULL; + while (1) + { + op = e->Eoper; + if (!OTleaf(op)) + { + e1 = e->E1; + if (OTdef(op)) + { + if (e1->Eoper == OPvar && e1->EV.sp.Vsym == s) + return 1; + + // This doesn't cover all the cases + if (e1->Eoper == edop && el_match(e1,ed)) + return 1; + } + if (OTbinary(op) && el_anydef(ed,e->E2)) + return 1; + e = e1; + } + else + break; + } + return 0; +} + +#endif + +/************************ + * Make a binary operator node. + */ + +elem * el_bint(unsigned op,type *t,elem *e1,elem *e2) +{ elem *e; + + /* e2 is NULL when OPpostinc is built */ + assert(op < OPMAX && OTbinary(op) && e1); + assert(PARSER); + e = el_calloc(); + if (t) + { e->ET = t; + type_debug(t); + e->ET->Tcount++; + } + e->Eoper = op; + elem_debug(e1); + if (e2) + elem_debug(e2); + e->E1 = e1; + e->E2 = e2; + return e; +} + +elem * el_bin(unsigned op,tym_t ty,elem *e1,elem *e2) +{ elem *e; + +#if 0 + if (!(op < OPMAX && OTbinary(op) && e1 && e2)) + *(char *)0=0; +#endif + assert(op < OPMAX && OTbinary(op) && e1 && e2); + assert(MARS || !PARSER); + elem_debug(e1); + elem_debug(e2); + e = el_calloc(); + e->Ety = ty; + e->Eoper = op; + e->E1 = e1; + e->E2 = e2; + if (op == OPcomma && tyaggregate(ty)) + e->ET = e2->ET; + return e; +} + +/************************ + * Make a unary operator node. + */ + +elem * el_unat(unsigned op,type *t,elem *e1) +{ elem *e; + +#ifdef DEBUG + if (!(op < OPMAX && OTunary(op) && e1)) + dbg_printf("op = x%x, e1 = %p\n",op,e1); +#endif + assert(op < OPMAX && OTunary(op) && e1); + assert(PARSER); + elem_debug(e1); + e = el_calloc(); + e->Eoper = op; + e->E1 = e1; + if (t) + { + type_debug(t); + t->Tcount++; + e->ET = t; + } + return e; +} + +elem * el_una(unsigned op,tym_t ty,elem *e1) +{ elem *e; + +#ifdef DEBUG + if (!(op < OPMAX && OTunary(op) && e1)) + dbg_printf("op = x%x, e1 = %p\n",op,e1); +#endif + assert(op < OPMAX && OTunary(op) && e1); + assert(MARS || !PARSER); + elem_debug(e1); + e = el_calloc(); + e->Ety = ty; + e->Eoper = op; + e->E1 = e1; + return e; +} + +/******************* + * Make a constant node out of integral type. + */ + +elem * el_longt(type *t,targ_llong val) +{ elem *e; + + assert(PARSER); + e = el_calloc(); + e->Eoper = OPconst; + e->ET = t; + if (e->ET) + { type_debug(t); + e->ET->Tcount++; + } + e->EV.Vllong = val; + return e; +} + +elem * el_long(tym_t t,targ_llong val) +{ elem *e; + + assert(MARS || !PARSER); + e = el_calloc(); + e->Eoper = OPconst; + e->Ety = t; + switch (tybasic(t)) + { + case TYfloat: + case TYifloat: + e->EV.Vfloat = val; + break; + case TYdouble: + case TYidouble: + e->EV.Vdouble = val; + break; + case TYldouble: + case TYildouble: + e->EV.Vldouble = val; + break; + case TYcfloat: + case TYcdouble: + case TYcldouble: + assert(0); + break; + default: + e->EV.Vllong = val; + break; + } + return e; +} + +/******************************* + * If elem is a const that can be converted to an OPconst, + * do the conversion. + */ + +#if SCPP +void el_toconst(elem *e) +{ + elem_debug(e); + assert(PARSER); +#if TX86 + if (e->Eoper == OPvar && e->EV.sp.Vsym->Sflags & SFLvalue) +#else + if (e->Eoper == OPvar && e->EV.sp.Vsym->Sflags & SFLvalue && + tybasic(e->ET->Tty) != TYstruct) +#endif + { elem *es = e->EV.sp.Vsym->Svalue; + + type_debug(e->ET); + symbol_debug(e->EV.sp.Vsym); + elem_debug(es); + e->Eoper = es->Eoper; + assert(e->Eoper == OPconst); + e->EV = es->EV; + } +} +#endif + +/******************************* + * Set new type for elem. + */ + +elem * el_settype(elem *e,type *t) +{ +#if MARS + assert(0); +#else + assert(PARSER); + elem_debug(e); + type_debug(t); + type_settype(&e->ET,t); +#endif + return e; +} + +/******************************* + * Walk tree, replacing symbol s1 with s2. + */ + +#if SCPP + +void el_replacesym(elem *e,symbol *s1,symbol *s2) +{ + _chkstack(); + + assert(PARSER); + while (e) + { elem_debug(e); + if (EOP(e)) + { el_replacesym(e->E2,s1,s2); + e = e->E1; + } + else + { + if ((e->Eoper == OPvar || e->Eoper == OPrelconst) && + e->EV.sp.Vsym == s1) + e->EV.sp.Vsym = s2; + break; + } + } +} + +#endif + +/******************************* + * Create elem that is the size of a type. + */ + +elem * el_typesize(type *t) +{ +#if MARS + assert(0); + return NULL; +#else + assert(PARSER); + type_debug(t); + if (CPP && tybasic(t->Tty) == TYstruct && t->Tflags & TFsizeunknown) + { elem *e; + + symbol_debug(t->Ttag); + e = el_calloc(); + e->Eoper = OPsizeof; + e->EV.sp.Vsym = t->Ttag; + e->ET = tssize; + e->ET->Tcount++; + type_debug(tssize); + elem_debug(e); + return e; + } + else if (tybasic(t->Tty) == TYarray && type_isvla(t)) + { + type *troot = type_arrayroot(t); + elem *en; + + en = el_nelems(t); + return el_bint(OPmul, en->ET, en, el_typesize(troot)); + } + else + return el_longt(tssize,type_size(t)); +#endif +} + +/***************************** + * Return an elem that evaluates to the number of elems in a type + * (if it is an array). Returns NULL if t is not an array. + */ + +#if SCPP +elem * el_nelems(type *t) +{ elem *enelems; + + assert(PARSER); + type_debug(t); + if (tybasic(t->Tty) == TYarray) + { type *ts = tssize; + + enelems = el_longt(ts, 1); + do + { + if (t->Tflags & TFsizeunknown || + (t->Tflags & TFvla && !t->Tel)) + { synerr(EM_unknown_size,"array"); // size of array is unknown + t->Tflags &= ~TFsizeunknown; + } + else if (t->Tflags & TFvla) + { + enelems = el_bint(OPmul, ts, enelems, el_copytree(t->Tel)); + } + else if (enelems->Eoper == OPconst) + { enelems->EV.Vllong *= t->Tdim; + type_chksize(enelems->EV.Vllong); + } + else + enelems = el_bint(OPmul, enelems->ET, enelems, el_longt(ts, t->Tdim)); + t = t->Tnext; + } while (tybasic(t->Tty) == TYarray); + } + else + enelems = NULL; + return enelems; +} +#endif + +/************************************ + * Return != 0 if function has any side effects. + */ + +#if MARS + +int el_funcsideeff(elem *e) +{ Symbol *s; + + if (e->Eoper == OPvar && + tyfunc((s = e->EV.sp.Vsym)->Stype->Tty) && + ((s->Sfunc && s->Sfunc->Fflags3 & Fnosideeff) || s == funcsym_p) + ) + return 0; + return 1; // assume it does have side effects +} + +#endif + +/**************************** + * Return != 0 if elem has any side effects. + */ + +int el_sideeffect(elem *e) +{ int op; + + assert(e); + op = e->Eoper; + assert(op < OPMAX); + elem_debug(e); + return typemask(e) & mTYvolatile || + OTsideff(op) || + (OTunary(op) && el_sideeffect(e->E1)) || + (OTbinary(op) && (el_sideeffect(e->E1) || + el_sideeffect(e->E2))); +} + +#if TX86 +/****************************** + * Input: + * ea lvalue (might be an OPbit) + * Returns: + * 0 eb has no dependency on ea + * 1 eb might have a dependency on ea + * 2 eb definitely depends on ea + */ + +int el_depends(elem *ea,elem *eb) +{ + L1: + elem_debug(ea); + elem_debug(eb); + switch (ea->Eoper) + { + case OPbit: + ea = ea->E1; + goto L1; + case OPvar: + case OPind: + break; + default: + assert(0); + } + switch (eb->Eoper) + { + case OPconst: + case OPrelconst: + case OPstring: +#if SCPP + case OPsizeof: +#endif + goto Lnodep; + case OPvar: + if (ea->Eoper == OPvar && ea->EV.sp.Vsym != eb->EV.sp.Vsym) + goto Lnodep; + break; + default: + break; // this could use improvement + } + return 1; + +Lnodep: + return 0; +} +#endif + +/*************************************** + * Allocate localgot symbol. + */ + +symbol *el_alloc_localgot() +{ +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + /* Since localgot is a local variable to each function, + * localgot must be set back to NULL + * at the start of code gen for each function. + */ + if (I32 && !localgot) + { + //printf("el_alloc_localgot()\n"); + char name[15]; + static int tmpnum; + sprintf(name, "_LOCALGOT%d", tmpnum++); + localgot = symbol_name(name, SCtmp, type_fake(TYnptr)); + symbol_add(localgot); + localgot->Sfl = FLtmp; + localgot->Sflags = SFLfree | SFLunambig | GTregcand; + } + return localgot; +#else + return NULL; +#endif +} + + +/************************** + * Make an elem out of a symbol, PIC style. + */ + +#if TARGET_OSX + +elem *el_picvar(symbol *s) +{ elem *e; + int x; + + //printf("el_picvar(s = '%s')", s->Sident); printf(" Sclass = "); WRclass((enum SC) s->Sclass); printf("\n"); + //symbol_print(s); + symbol_debug(s); + type_debug(s->Stype); + e = el_calloc(); + e->Eoper = OPvar; + e->EV.sp.Vsym = s; + e->Ety = s->ty(); + + switch (s->Sclass) + { + case SCstatic: + case SClocstat: + x = 0; + goto case_got; + + case SCcomdat: + case SCcomdef: + if (0 && I64) + { + x = 0; + goto case_got; + } + case SCglobal: + case SCextern: +#if 0 + if (s->Stype->Tty & mTYthread) + x = 0; + else +#endif + x = 1; + case_got: + { + int op = e->Eoper; + tym_t tym = e->Ety; + e->Eoper = OPrelconst; + e->Ety = TYnptr; + if (I32) + e = el_bin(OPadd, TYnptr, e, el_var(el_alloc_localgot())); +#if 1 + if (s->Stype->Tty & mTYthread) + { + if (!tls_get_addr_sym) + { + /* void *___tls_get_addr(void *ptr); + * Parameter ptr is passed in EAX, matching TYjfunc calling convention. + */ + tls_get_addr_sym = symbol_name("___tls_get_addr",SCglobal,type_fake(TYjfunc)); + symbol_keep(tls_get_addr_sym); + slist_add(tls_get_addr_sym); + } + if (x == 1) + e = el_una(OPind, TYnptr, e); + e = el_bin(OPcallns, TYnptr, el_var(tls_get_addr_sym), e); + if (op == OPvar) + e = el_una(OPind, TYnptr, e); + } + else +#endif + { + switch (op * 2 + x) + { + case OPvar * 2 + 1: + e = el_una(OPind, TYnptr, e); + e = el_una(OPind, TYnptr, e); + break; + case OPvar * 2 + 0: + case OPrelconst * 2 + 1: + e = el_una(OPind, TYnptr, e); + break; + case OPrelconst * 2 + 0: + break; + default: + assert(0); + break; + } + } + e->Ety = tym; + break; + } + default: + break; + } + return e; +} +#endif +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + +elem *el_picvar(symbol *s) +{ elem *e; + int x; + + //printf("el_picvar(s = '%s')\n", s->Sident); + symbol_debug(s); + type_debug(s->Stype); + e = el_calloc(); + e->Eoper = OPvar; + e->EV.sp.Vsym = s; + e->Ety = s->ty(); + + /* For 32 bit: + * CALL __i686.get_pc_thunk.bx@PC32 + * ADD EBX,offset _GLOBAL_OFFSET_TABLE_@GOTPC[2] + * Generate for var locals: + * MOV reg,s@GOTOFF[014h][EBX] + * For var globals: + * MOV EAX,s@GOT32[EBX] + * MOV reg,[EAX] + * For TLS var locals and globals: + * MOV EAX,s@TLS_GD[EBX] + * CALL ___tls_get_addr@PLT32 + * MOV reg,[EAX] + ***************************************** + * Generate for var locals: + * MOV reg,s@PC32[RIP] + * For var globals: + * MOV RAX,s@GOTPCREL[RIP] + * MOV reg,[RAX] + * For TLS var locals and globals: + * 0x66 + * LEA DI,s@TLSGD[RIP] + * 0x66 + * 0x66 + * 0x48 (REX | REX_W) + * CALL __tls_get_addr@PLT32 + * MOV reg,[RAX] + */ + + if (I64) + { + elfobj_refGOTsym(); + switch (s->Sclass) + { + case SCstatic: + case SClocstat: + x = 0; + goto case_got64; + + case SCcomdat: + case SCcomdef: + case SCglobal: + case SCextern: + x = 1; + case_got64: + { + int op = e->Eoper; + tym_t tym = e->Ety; + e->Ety = TYnptr; + + if (s->Stype->Tty & mTYthread) + { + /* Add "volatile" to prevent e from being common subexpressioned. + * This is so we can preserve the magic sequence of instructions + * that the gnu linker patches: + * lea EDI,x@tlsgd[RIP], call __tls_get_addr@plt + * => + * mov EAX,gs[0], sub EAX,x@tpoff + */ + e->Eoper = OPrelconst; + e->Ety |= mTYvolatile; + if (!tls_get_addr_sym) + { + /* void *__tls_get_addr(void *ptr); + * Parameter ptr is passed in RDI, matching TYnfunc calling convention. + */ + tls_get_addr_sym = symbol_name("__tls_get_addr",SCglobal,type_fake(TYnfunc)); + symbol_keep(tls_get_addr_sym); + } + e = el_bin(OPcall, TYnptr, el_var(tls_get_addr_sym), e); + } + + switch (op * 2 + x) + { + case OPvar * 2 + 1: + e = el_una(OPind, TYnptr, e); + break; + case OPvar * 2 + 0: + case OPrelconst * 2 + 1: + break; + case OPrelconst * 2 + 0: + e = el_una(OPaddr, TYnptr, e); + break; + default: + assert(0); + break; + } + e->Ety = tym; + break; + } + default: + break; + } + } + else + switch (s->Sclass) + { + /* local (and thread) symbols get only one level of indirection; + * all globally known symbols get two. + */ + case SCstatic: + case SClocstat: + x = 0; + goto case_got; + + case SCcomdat: + case SCcomdef: + case SCglobal: + case SCextern: + if (s->Stype->Tty & mTYthread) + x = 0; + else + x = 1; + case_got: + { + int op = e->Eoper; + tym_t tym = e->Ety; + e->Eoper = OPrelconst; + e->Ety = TYnptr; + e = el_bin(OPadd, TYnptr, e, el_var(el_alloc_localgot())); + + if (s->Stype->Tty & mTYthread) + { + /* Add "volatile" to prevent e from being common subexpressioned. + * This is so we can preserve the magic sequence of instructions + * that the gnu linker patches: + * lea EAX,x@tlsgd[EBX], call __tls_get_addr@plt + * => + * mov EAX,gs[0], sub EAX,x@tpoff + * elf32-i386.c + */ + e->Ety |= mTYvolatile; + if (!tls_get_addr_sym) + { + /* void *___tls_get_addr(void *ptr); + * Parameter ptr is passed in EAX, matching TYjfunc calling convention. + */ + tls_get_addr_sym = symbol_name("___tls_get_addr",SCglobal,type_fake(TYjfunc)); + symbol_keep(tls_get_addr_sym); + } + e = el_bin(OPcall, TYnptr, el_var(tls_get_addr_sym), e); + } + + switch (op * 2 + x) + { + case OPvar * 2 + 1: + e = el_una(OPind, TYnptr, e); + e = el_una(OPind, TYnptr, e); + break; + case OPvar * 2 + 0: + case OPrelconst * 2 + 1: + e = el_una(OPind, TYnptr, e); + break; + case OPrelconst * 2 + 0: + break; + default: + assert(0); + break; + } + e->Ety = tym; + break; + } + default: + break; + } + return e; +} +#endif + +/************************** + * Make an elem out of a symbol. + */ + +#if MARS +elem * el_var(symbol *s) +{ elem *e; + + //printf("el_var(s = '%s')\n", s->Sident); + //printf("%x\n", s->Stype->Tty); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + // OSX is currently always pic + if (config.flags3 & CFG3pic && +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + (!(s->Stype->Tty & mTYthread) || I64) && +#endif + !tyfunc(s->ty())) + // Position Independent Code + return el_picvar(s); +#endif +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic && tyfunc(s->ty())) + { + switch (s->Sclass) + { + case SCcomdat: + case SCcomdef: + case SCglobal: + case SCextern: + el_alloc_localgot(); + break; + } + } +#endif + symbol_debug(s); + type_debug(s->Stype); + e = el_calloc(); + e->Eoper = OPvar; + e->EV.sp.Vsym = s; + type_debug(s->Stype); + e->Ety = s->ty(); + if (s->Stype->Tty & mTYthread) + { + //printf("thread local %s\n", s->Sident); +#if TARGET_OSX + ; +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + /* For 32 bit: + * Generate for var locals: + * MOV reg,GS:[00000000] // add GS: override in back end + * ADD reg, offset s@TLS_LE + * e => *(&s + *(GS:0)) + * For var globals: + * MOV reg,GS:[00000000] + * ADD reg, s@TLS_IE + * e => *(s + *(GS:0)) + * note different fixup + ***************************************** + * For 64 bit: + * Generate for var locals: + * MOV reg,FS:s@TPOFF32 + * For var globals: + * MOV RAX,s@GOTTPOFF[RIP] + * MOV reg,FS:[RAX] + * + * For address of locals: + * MOV RAX,FS:[00] + * LEA reg,s@TPOFF32[RAX] + * e => &s + *(FS:0) + * For address of globals: + * MOV reg,FS:[00] + * MOV RAX,s@GOTTPOFF[RIP] + * ADD reg,RAX + * e => s + *(FS:0) + * This leaves us with a problem, as the 'var' version cannot simply have + * its address taken, as what is the address of FS:s ? The (not so efficient) + * solution is to just use the second address form, and * it. + * Turns out that is identical to the 32 bit version, except GS => FS and the + * fixups are different. + * In the future, we should figure out a way to optimize to the 'var' version. + */ + if (I64) + elfobj_refGOTsym(); + elem *e1 = el_calloc(); + e1->EV.sp.Vsym = s; + if (s->Sclass == SCstatic || s->Sclass == SClocstat) + { e1->Eoper = OPrelconst; + e1->Ety = TYnptr; + } + else + { + e1->Eoper = OPvar; + e1->Ety = TYnptr; + } + + /* Fake GS:[0000] as a load of _tls_array, and then in the back end recognize + * the fake and rewrite it as GS:[0000] (or FS:[0000] for I64), because there is + * no way to represent segment overrides in the elem nodes. + */ + elem *e2 = el_calloc(); + e2->Eoper = OPvar; + e2->EV.sp.Vsym = rtlsym[RTLSYM_TLS_ARRAY]; + e2->Ety = e2->EV.sp.Vsym->ty(); + + e->Eoper = OPind; + e->E1 = el_bin(OPadd,e1->Ety,e2,e1); + e->E2 = NULL; +#else + /* + mov EAX,FS:__tls_array + mov ECX,__tls_index + mov EAX,[ECX*4][EAX] + inc dword ptr _t[EAX] + + e => *(&s + *(FS:_tls_array + _tls_index * 4)) + + If this is an executable app, not a dll, _tls_index + can be assumed to be 0. + */ + elem *e1,*e2,*ea; + + e1 = el_calloc(); + e1->Eoper = OPrelconst; + e1->EV.sp.Vsym = s; + e1->Ety = TYnptr; + + if (config.wflags & WFexe) + { + // e => *(&s + *(FS:_tls_array)) + e2 = el_var(rtlsym[RTLSYM_TLS_ARRAY]); + } + else + { + e2 = el_bin(OPmul,TYint,el_var(rtlsym[RTLSYM_TLS_INDEX]),el_long(TYint,4)); + ea = el_var(rtlsym[RTLSYM_TLS_ARRAY]); + e2 = el_bin(OPadd,ea->Ety,ea,e2); + } + e2 = el_una(OPind,TYint,e2); + + e->Eoper = OPind; + e->E1 = el_bin(OPadd,e1->Ety,e1,e2); + e->E2 = NULL; +#endif + } + return e; +} +#elif SCPP +elem * el_var(symbol *s) +{ elem *e; + + //printf("el_var(s = '%s')\n", s->Sident); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic && !tyfunc(s->ty())) + return el_picvar(s); +#endif + symbol_debug(s); + type_debug(s->Stype); + e = el_calloc(); + e->Eoper = OPvar; + e->EV.sp.Vsym = s; + if (SCPP && PARSER) +#if TX86 && TARGET_WINDOS + { type *t = s->Stype; + + type_debug(t); + e->ET = t; + t->Tcount++; + switch (t->Tty & (mTYimport | mTYthread)) + { case mTYimport: + obj_import(e); + break; + case mTYthread: + /* + mov EAX,FS:__tls_array + mov ECX,__tls_index + mov EAX,[ECX*4][EAX] + inc dword ptr _t[EAX] + + e => *(&s + *(FS:_tls_array + _tls_index * 4)) + */ +#if MARS + assert(0); +#else + { elem *e1,*e2,*ea; + + e1 = el_calloc(); + e1->Eoper = OPrelconst; + e1->EV.sp.Vsym = s; + e1->ET = newpointer(s->Stype); + e1->ET->Tcount++; + + e2 = el_bint(OPmul,tsint,el_var(rtlsym[RTLSYM_TLS_INDEX]),el_longt(tsint,4)); + ea = el_var(rtlsym[RTLSYM_TLS_ARRAY]); + e2 = el_bint(OPadd,ea->ET,ea,e2); + e2 = el_unat(OPind,tsint,e2); + + e->Eoper = OPind; + e->E1 = el_bint(OPadd,e1->ET,e1,e2); + e->E2 = NULL; + } +#endif + break; + case mTYthread | mTYimport: + assert(SCPP); +#if SCPP + tx86err(EM_thread_and_dllimport,s->Sident); // can't be both thread and import +#endif + break; + } + } +#else + { type_debug(s->Stype); + e->ET = s->Stype; + e->ET->Tcount++; + } +#endif + else + e->Ety = s->ty(); + return e; +} +#endif + +/************************** + * Make a pointer to an elem out of a symbol. + */ + +elem * el_ptr(symbol *s) +{ + elem *e; + + //printf("el_ptr(s = '%s')\n", s->Sident); + //printf("el_ptr\n"); + symbol_debug(s); + type_debug(s->Stype); +#if TARGET_OSX + if (config.flags3 & CFG3pic && tyfunc(s->ty()) && I32) + { + /* Cannot access address of code from code. + * Instead, create a data variable, put the address of the + * code in that data variable, and return the elem for + * that data variable. + */ + symbol *sd = symboldata(Doffset, TYnptr); + Doffset += reftoident(DATA, Doffset, s, 0, CFoff); + e = el_picvar(sd); + return e; + } +#endif +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (config.flags3 & CFG3pic && + tyfunc(s->ty())) + e = el_picvar(s); + else +#endif + e = el_var(s); +#if SCPP + if (PARSER) + { type_debug(e->ET); + e = el_unat(OPaddr,type_ptr(e,e->ET),e); + } + else +#endif + if (e->Eoper == OPvar) + { + e->Ety = TYnptr; + e->Eoper = OPrelconst; + } + else + { e = el_una(OPaddr, TYnptr, e); + e = doptelem(e, GOALvalue | GOALflags); + } + return e; +} + +/************************** + * Make a pointer to an elem out of a symbol at offset. + */ + +#if SCPP + +elem * el_ptr_offset(symbol *s,targ_size_t offset) +{ elem *e; + elem *e1; + + e = el_ptr(s); /* e is an elem which is a pointer to s */ + e1 = e->E1; + if (e1->Eoper == OPvar) + ; + // The following case happens if symbol s is in thread local storage + else if (e1->Eoper == OPind && + e1->E1->Eoper == OPadd && + e1->E1->E1->Eoper == OPrelconst) + e1 = e1->E1->E1; + else + assert(0); + assert(e1->EV.sp.Vsym == s); + e1->EV.sp.Voffset = offset; + return e; +} + +#endif + +/************************* + * Returns: + * !=0 elem evaluates right-to-left + * 0 elem evaluates left-to-right + */ + +HINT ERTOL(elem *e) +{ + elem_debug(e); + assert(!PARSER); +#if TX86 + return OTrtol(e->Eoper) && + (!OTopeq(e->Eoper) || config.inline8087 || !tyfloating(e->Ety)); +#else + return OTrtol(e->Eoper); +#endif +} + +/******************************** + * Return !=0 if expression never returns. + * Does not detect all cases, errs on the side of saying it returns. + */ + +int el_noreturn(elem *e) +{ int result = 0; + + while (1) + { elem_debug(e); + switch (e->Eoper) + { case OPcomma: + if (result |= el_noreturn(e->E1)) + break; + e = e->E2; + continue; + + case OPcall: + case OPucall: + e = e->E1; + if (e->Eoper == OPvar && e->EV.sp.Vsym->Sflags & SFLexit) + result = 1; + break; + + case OPhalt: + result = 1; + break; + + default: + break; + } + break; + } + return result; +} + +/******************************** + * Scan down commas and return the controlling elem. + */ + +elem *el_scancommas(elem *e) +{ + while (e->Eoper == OPcomma) + e = e->E2; + return e; +} + +/*************************** + * Count number of commas in the expression. + */ + +int el_countCommas(elem *e) +{ int ncommas = 0; + while (1) + { + if (EBIN(e)) + { + ncommas += (e->Eoper == OPcomma) + el_countCommas(e->E2); + } + else if (EUNA(e)) + { + } + else + break; + e = e->E1; + } + return ncommas; +} + +/************************************ + * Convert floating point constant to a read-only symbol. + * Needed iff floating point code can't load immediate constants. + */ + +elem *el_convfloat(elem *e) +{ + unsigned char buffer[32]; + +#if TX86 + assert(config.inline8087); + + // Do not convert if the constants can be loaded with the special FPU instructions + if (tycomplex(e->Ety)) + { + if (loadconst(e, 0) && loadconst(e, 1)) + return e; + } + else if (loadconst(e, 0)) + return e; + + changes++; + tym_t ty = e->Ety; + int sz = tysize(ty); + assert(sz <= sizeof(buffer)); + void *p; + switch (tybasic(ty)) + { + case TYfloat: + case TYifloat: + p = &e->EV.Vfloat; + assert(sz == sizeof(e->EV.Vfloat)); + break; + + case TYdouble: + case TYidouble: + case TYdouble_alias: + p = &e->EV.Vdouble; + assert(sz == sizeof(e->EV.Vdouble)); + break; + + case TYldouble: + case TYildouble: + /* The size, alignment, and padding of long doubles may be different + * from host to target + */ + p = buffer; + memset(buffer, 0, sz); // ensure padding is 0 + memcpy(buffer, &e->EV.Vldouble, 10); + break; + + case TYcfloat: + p = &e->EV.Vcfloat; + assert(sz == sizeof(e->EV.Vcfloat)); + break; + + case TYcdouble: + p = &e->EV.Vcdouble; + assert(sz == sizeof(e->EV.Vcdouble)); + break; + + case TYcldouble: + p = buffer; + memset(buffer, 0, sz); + memcpy(buffer, &e->EV.Vcldouble.re, 10); + memcpy(buffer + tysize(TYldouble), &e->EV.Vcldouble.im, 10); + break; + + default: + assert(0); + } + +#if 0 + printf("%gL+%gLi\n", (double)e->EV.Vcldouble.re, (double)e->EV.Vcldouble.im); + printf("el_convfloat() %g %g sz=%d\n", e->EV.Vcdouble.re, e->EV.Vcdouble.im, sz); +printf("el_convfloat(): sz = %d\n", sz); +unsigned short *p = (unsigned short *)&e->EV.Vcldouble; +for (int i = 0; i < sz/2; i++) printf("%04x ", p[i]); +printf("\n"); +#endif + + symbol *s = out_readonly_sym(ty, p, sz); + el_free(e); + e = el_var(s); + e->Ety = ty; + if (e->Eoper == OPvar) + e->Ety |= mTYconst; + //printf("s: %s %d:x%x\n", s->Sident, s->Sseg, s->Soffset); +#endif + return e; +} + +/************************************ + * Convert vector constant to a read-only symbol. + * Needed iff vector code can't load immediate constants. + */ + +elem *el_convxmm(elem *e) +{ + unsigned char buffer[16]; + +#if TX86 + // Do not convert if the constants can be loaded with the special XMM instructions +#if 0 + if (loadconst(e)) + return e; +#endif + + changes++; + tym_t ty = e->Ety; + int sz = tysize(ty); + assert(sz <= sizeof(buffer)); + void *p = &e->EV.Vcent; + +#if 0 +printf("el_convxmm(): sz = %d\n", sz); +for (size i = 0; i < sz; i++) printf("%02x ", ((unsigned char *)p)[i]); +printf("\n"); +#endif + + symbol *s = out_readonly_sym(ty, p, sz); + el_free(e); + e = el_var(s); + e->Ety = ty; + if (e->Eoper == OPvar) + e->Ety |= mTYconst; + //printf("s: %s %d:x%x\n", s->Sident, s->Sseg, s->Soffset); +#endif + return e; +} + +/******************************** + * Convert reference to a string to reference to a symbol + * stored in the static data segment. + */ + +elem *el_convstring(elem *e) +{ + //printf("el_convstring()\n"); + int i; + symbol *s; + char *p; + targ_size_t len; + + assert(!PARSER); + elem_debug(e); + assert(e->Eoper == OPstring); + p = e->EV.ss.Vstring; + e->EV.ss.Vstring = NULL; + len = e->EV.ss.Vstrlen; + +#if TARGET_SEGMENTED + // Handle strings that go into the code segment + if (tybasic(e->Ety) == TYcptr || + (tyfv(e->Ety) && config.flags3 & CFG3strcod)) + { + assert(OMFOBJ); // option not done yet for others + s = symbol_generate(SCstatic, type_fake(mTYcs | e->Ety)); + s->Sfl = FLcsdata; + s->Soffset = Coffset; + s->Sseg = cseg; + symbol_keep(s); + if (!eecontext.EEcompile || eecontext.EEin) + { obj_bytes(cseg,Coffset,len,p); + Coffset += len; + } + mem_free(p); + goto L1; + } +#endif + + if (eecontext.EEin) // if compiling debugger expression + { + s = out_readonly_sym(e->Ety, p, len); + mem_free(p); + goto L1; + } + + // See if e is already in the string table + for (i = 0; i < arraysize(stable); i++) + { if (stable[i].len == len && + memcmp(stable[i].p,p,len) == 0) + { + // Replace e with that symbol + MEM_PH_FREE(p); + s = stable[i].sym; + goto L1; + } + } + + // Replace string with a symbol that refers to that string + // in the DATA segment + + if (eecontext.EEcompile) + s = symboldata(Doffset,e->Ety); + else + s = out_readonly_sym(e->Ety,p,len); + + // Remember the string for possible reuse later + //dbg_printf("Adding %d, '%s'\n",stable_si,p); + mem_free(stable[stable_si].p); + stable[stable_si].p = p; + stable[stable_si].len = len; + stable[stable_si].sym = s; + stable_si = (stable_si + 1) & (arraysize(stable) - 1); + +L1: + // Refer e to the symbol generated + elem *ex = el_ptr(s); + ex->Ety = e->Ety; + if (e->EV.ss.Voffset) + { + if (ex->Eoper == OPrelconst) + ex->EV.sp.Voffset += e->EV.ss.Voffset; + else + ex = el_bin(OPadd, ex->Ety, ex, el_long(TYint, e->EV.ss.Voffset)); + } + el_free(e); + return ex; +} + +/******************************************** + * If e is a long double constant, and it is perfectly representable as a + * double constant, convert it to a double constant. + * Note that this must NOT be done in contexts where there are no further + * operations, since then it could change the type (eg, in the function call + * printf("%La", 2.0L); the 2.0 must stay as a long double). + */ +#if 1 +void shrinkLongDoubleConstantIfPossible(elem *e) +{ + if (e->Eoper == OPconst && e->Ety == TYldouble) + { + /* Check to see if it can be converted into a double (this happens + * when the low bits are all zero, and the exponent is in the + * double range). + * Use 'volatile' to prevent optimizer from folding away the conversions, + * and thereby missing the truncation in the conversion to double. + */ + volatile long double v = e->EV.Vldouble; + volatile double vDouble; + *(&vDouble) = v; + if (v == vDouble) // This will fail if compiler does NaN incorrectly! + { + // Yes, we can do it! + e->EV.Vdouble = vDouble; + e->Ety = TYdouble; + } + } +} +#endif + + +/************************* + * Run through a tree converting it to CODGEN. + */ + +elem *el_convert(elem *e) +{ int op; + + //printf("el_convert(%p)\n", e); + elem_debug(e); + op = e->Eoper; + switch (op) + { + case OPvar: + break; + + case OPconst: +#if TX86 + if (tyvector(e->Ety)) + e = el_convxmm(e); + else if (tyfloating(e->Ety) && config.inline8087) + e = el_convfloat(e); +#endif + break; + + case OPstring: + changes++; + e = el_convstring(e); + break; + + case OPnullptr: + e = el_long(e->Ety, 0); + break; + + case OPmul: + /* special floating-point case: allow x*2 to be x+x + * in this case, we preserve the constant 2. + */ + if (tyreal(e->Ety) && // don't bother with imaginary or complex + e->E2->Eoper == OPconst && el_toldouble(e->E2) == 2.0L) + { + e->E1 = el_convert(e->E1); + /* Don't call el_convert(e->E2), we want it to stay as a constant + * which will be detected by code gen. + */ + break; + } +#if 1 + case OPdiv: + case OPadd: + case OPmin: + // For a*b,a+b,a-b,a/b, if a long double constant is involved, convert it to a double constant. + if (tyreal(e->Ety)) + shrinkLongDoubleConstantIfPossible(e->E1); + if (tyreal(e->Ety)) + shrinkLongDoubleConstantIfPossible(e->E2); + // fall through... +#endif + default: + if (OTbinary(op)) + { + e->E1 = el_convert(e->E1); + e->E2 = el_convert(e->E2); + } + else if (OTunary(op)) + { + e->E1 = el_convert(e->E1); + } + break; + } + return e; +} + + +/************************ + * Make a constant elem. + * ty = type of elem + * *pconst = union of constant data + */ + +elem * el_const(tym_t ty,union eve *pconst) +{ elem *e; + + assert(MARS || !PARSER); + e = el_calloc(); + e->Eoper = OPconst; + e->Ety = ty; + memcpy(&e->EV,pconst,sizeof(e->EV)); + return e; +} + + +/************************** + * Insert constructor information into tree. + * e code to construct the object + * decl VarDeclaration of variable being constructed + */ + +#if MARS +elem *el_dctor(elem *e,void *decl) +{ + elem *ector = el_calloc(); + ector->Eoper = OPdctor; + ector->Ety = TYvoid; + ector->EV.ed.Edecl = decl; + if (e) + e = el_bin(OPinfo,e->Ety,ector,e); + else + /* Remember that a "constructor" may execute no code, hence + * the need for OPinfo if there is code to execute. + */ + e = ector; + return e; +} +#endif + +/************************** + * Insert destructor information into tree. + * e code to destruct the object + * decl VarDeclaration of variable being destructed + * (must match decl for corresponding OPctor) + */ + +#if MARS +elem *el_ddtor(elem *e,void *decl) +{ + /* A destructor always executes code, or we wouldn't need + * eh for it. + * An OPddtor must match 1:1 with an OPdctor + */ + elem *edtor = el_calloc(); + edtor->Eoper = OPddtor; + edtor->Ety = TYvoid; + edtor->EV.ed.Edecl = decl; + edtor->EV.ed.Eleft = e; + return edtor; +} +#endif + +/************************** + * Insert constructor information into tree. + * ector pointer to object being constructed + * e code to construct the object + * sdtor function to destruct the object + */ + +#if SCPP +elem *el_ctor(elem *ector,elem *e,symbol *sdtor) +{ + //printf("el_ctor(ector = %p, e = %p, sdtor = %p)\n", ector, e, sdtor); + //printf("stdor = '%s'\n", cpp_prettyident(sdtor)); + //printf("e:\n"); elem_print(e); + if (ector) + { + if (sdtor) + { + if (sdtor->Sfunc->Fbody) + { + n2_instantiate_memfunc(sdtor); + } + // Causes symbols to be written out prematurely when + // writing precompiled headers. + // Moved to outelem(). + //nwc_mustwrite(sdtor); + } + if (!sdtor || ector->Eoper == OPcall || + (ector->Eoper == OPrelconst && !(sytab[ector->EV.sp.Vsym->Sclass] & SCSS)) +#if TX86 + // Not ambient memory model + || (tyfarfunc(sdtor->ty()) ? !LARGECODE : LARGECODE) +#endif + ) + { + el_free(ector); + } + else + { + ector = el_unat(OPctor,ector->ET,ector); + ector->EV.eop.Edtor = sdtor; + symbol_debug(sdtor); + if (e) + e = el_bint(OPinfo,e->ET,ector,e); + else + e = ector; + } + } + return e; +} +#endif + +/************************** + * Insert destructor information into tree. + * edtor pointer to object being destructed + * e code to do the destruction + */ + +elem *el_dtor(elem *edtor,elem *e) +{ + if (edtor) + { + edtor = el_unat(OPdtor,edtor->ET,edtor); + if (e) + e = el_bint(OPcomma,e->ET,edtor,e); + else + e = edtor; + } + return e; +} + +/********************************** + * Create an elem of the constant 0, of the type t. + */ + +elem *el_zero(type *t) +{ + elem *e; + + assert(PARSER); + + e = el_calloc(); + e->Eoper = OPconst; + e->ET = t; + if (t) + { + type_debug(t); + e->ET->Tcount++; + } + return(e); +} + +/******************* + * Find and return pointer to parent of e starting at *pe. + * Return NULL if can't find it. + */ + +elem ** el_parent(elem *e,elem **pe) +{ + assert(e && pe && *pe); + elem_debug(e); + elem_debug(*pe); + if (e == *pe) + return pe; + else if (OTunary((*pe)->Eoper)) + return el_parent(e,&((*pe)->E1)); + else if (OTbinary((*pe)->Eoper)) + { elem **pe2; + + return ((pe2 = el_parent(e,&((*pe)->E1))) != 0) ? pe2 + : el_parent(e,&((*pe)->E2)); + } + else + return NULL; +} + +/******************************* + * Return !=0 if trees match. + */ + +static int gmatch2; // kludge for el_match2() + +int el_match(elem *n1,elem *n2) +{ unsigned op; + tym_t tym,tym2; + +L1: + if (n1 == n2) + return TRUE; + if (!n1 || !n2) + goto nomatch; + elem_debug(n1); + elem_debug(n2); + + if ((op = n1->Eoper) != n2->Eoper) + goto nomatch; + + if ((tym = typemask(n1)) != (tym2 = typemask(n2))) + { +#if TX86 + if ((tym & ~mTYbasic) != (tym2 & ~mTYbasic)) +#else + if ((tym & ~mTYbasic & ~mTYMAN) != (tym2 & ~mTYbasic & ~mTYMAN)) +#endif + { + if (!(gmatch2 & 2)) + goto nomatch; + } + tym = tybasic(tym); + tym2 = tybasic(tym2); + if (tyequiv[tym] != tyequiv[tym2] && + !((gmatch2 & 8) && touns(tym) == touns(tym2)) + ) + goto nomatch; + gmatch2 &= ~8; + } + + if (OTunary(op)) + { + L2: + if (PARSER) + { + n1 = n1->E1; + n2 = n2->E1; + assert(n1 && n2); + goto L1; + } + else if (OPTIMIZER) + { + if (op == OPstrpar || op == OPstrctor) + { if (/*n1->Enumbytes != n2->Enumbytes ||*/ n1->ET != n2->ET) + goto nomatch; + } + n1 = n1->E1; + n2 = n2->E1; + assert(n1 && n2); + goto L1; + } + else + { + if (n1->E1 == n2->E1) + goto ismatch; + n1 = n1->E1; + n2 = n2->E1; + assert(n1 && n2); + goto L1; + } + } + else if (OTbinary(op)) + { + if (!PARSER) + { + if (op == OPstreq) + { if (/*n1->Enumbytes != n2->Enumbytes ||*/ n1->ET != n2->ET) + goto nomatch; + } + } + if (el_match(n1->E2,n2->E2)) + { + goto L2; // check left tree + } + goto nomatch; + } + else /* leaf elem */ + { unsigned n; + + switch (op) + { + case OPconst: + if (gmatch2 & 1) + break; + Lagain: + switch (tybasic(tym)) + { + case TYshort: + case TYwchar_t: + case TYushort: + case TYchar16: + case_short: + if (n1->EV.Vshort != n2->EV.Vshort) + goto nomatch; + break; + case TYlong: + case TYulong: + case TYdchar: + case_long: + if (n1->EV.Vlong != n2->EV.Vlong) + goto nomatch; + break; + case TYllong: + case TYullong: + case_llong: + if (n1->EV.Vllong != n2->EV.Vllong) + goto nomatch; + break; + case TYcent: + case TYucent: + if (n1->EV.Vcent.lsw != n2->EV.Vcent.lsw || + n1->EV.Vcent.msw != n2->EV.Vcent.msw) + goto nomatch; + break; + case TYenum: + if (PARSER) + { tym = n1->ET->Tnext->Tty; + goto Lagain; + } + case TYint: + case TYuint: + if (intsize == SHORTSIZE) + goto case_short; + else + goto case_long; + +#if TX86 +#if JHANDLE + case TYjhandle: +#endif + case TYnullptr: + case TYnptr: +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + if (NPTRSIZE == SHORTSIZE) + goto case_short; + else if (NPTRSIZE == LONGSIZE) + goto case_long; + else + { assert(NPTRSIZE == LLONGSIZE); + goto case_llong; + } +#endif + + case TYbool: + case TYchar: + case TYuchar: + case TYschar: + if (n1->EV.Vschar != n2->EV.Vschar) + goto nomatch; + break; +#if TARGET_SEGMENTED + case TYfptr: + case TYhptr: + case TYvptr: + + /* Far pointers on the 386 are longer than + any integral type... + */ + if (memcmp(&n1->EV,&n2->EV,tysize[tybasic(tym)])) + goto nomatch; + break; +#endif + /* Compare bit patterns w/o worrying about + exceptions, unordered comparisons, etc. + */ + case TYfloat: + case TYifloat: + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vfloat))) + goto nomatch; + break; + + case TYdouble: + case TYdouble_alias: + case TYidouble: + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vdouble))) + goto nomatch; + break; + + case TYldouble: + case TYildouble: +#if LNGDBLSIZE > 10 + /* sizeof is 12, but actual size is 10 */ + if (memcmp(&n1->EV,&n2->EV,10)) +#else + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vldouble))) +#endif + goto nomatch; + break; + + case TYcfloat: + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vcfloat))) + goto nomatch; + break; + + case TYcdouble: + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vcdouble))) + goto nomatch; + break; + + case TYcldouble: +#if LNGDBLSIZE > 10 + /* sizeof is 12, but actual size of each part is 10 */ + if (memcmp(&n1->EV,&n2->EV,10) || + memcmp(&n1->EV.Vldouble + 1, &n2->EV.Vldouble + 1, 10)) +#else + if (memcmp(&n1->EV,&n2->EV,sizeof(n1->EV.Vcldouble))) +#endif + goto nomatch; + break; + case TYvoid: + break; // voids always match +#if SCPP + case TYident: + assert(errcnt); + goto nomatch; +#endif + default: +#ifdef DEBUG + elem_print(n1); +#endif + assert(0); + } + break; + case OPrelconst: + case OPvar: +#if SCPP + case OPsizeof: +#endif + symbol_debug(n1->EV.sp.Vsym); + symbol_debug(n2->EV.sp.Vsym); + if (n1->EV.sp.Voffset != n2->EV.sp.Voffset) + goto nomatch; +#if SCPP + if (gmatch2 & 4) + { +#if 0 + printf("------- symbols ---------\n"); + symbol_print(n1->EV.sp.Vsym); + symbol_print(n2->EV.sp.Vsym); + printf("\n"); +#endif + if (/*strcmp(n1->EV.sp.Vsym->Sident, n2->EV.sp.Vsym->Sident) &&*/ + n1->EV.sp.Vsym != n2->EV.sp.Vsym && + (!n1->EV.sp.Vsym->Ssequence || n1->EV.sp.Vsym->Ssequence != n2->EV.sp.Vsym->Ssequence)) + goto nomatch; + } + else +#endif + { + if (n1->EV.sp.Vsym != n2->EV.sp.Vsym) + goto nomatch; + } + break; + case OPasm: + case OPstring: + case OPhstring: + if (n1->EV.ss.Vstrlen != (n = n2->EV.ss.Vstrlen) || + n1->EV.ss.Voffset != n2->EV.ss.Voffset || + memcmp(n1->EV.ss.Vstring,n2->EV.ss.Vstring,n)) + goto nomatch; /* check bytes in the string */ + break; + case OPstrthis: + case OPframeptr: + case OPhalt: + case OPgot: + break; +#if SCPP + case OPmark: + break; +#endif + default: +#ifdef DEBUG + WROP(op); +#endif + assert(0); + } +ismatch: + return TRUE; + } + assert(0); + /* NOTREACHED */ + +nomatch: + return FALSE; +} + +/********************************* + * Kludge on el_match(). Same, but ignore differences in OPconst. + */ + +int el_match2(elem *n1,elem *n2) +{ int result; + + gmatch2 = 1; + result = el_match(n1,n2); + gmatch2 = 0; + return result; +} + +/********************************* + * Kludge on el_match(). Same, but ignore differences in type modifiers. + */ + +int el_match3(elem *n1,elem *n2) +{ int result; + + gmatch2 = 2; + result = el_match(n1,n2); + gmatch2 = 0; + return result; +} + +/********************************* + * Kludge on el_match(). Same, but ignore differences in spelling of var's. + */ + +int el_match4(elem *n1,elem *n2) +{ int result; + + gmatch2 = 2|4; + result = el_match(n1,n2); + gmatch2 = 0; + return result; +} + +/********************************* + * Kludge on el_match(). Same, but regard signed/unsigned as equivalent. + */ + +int el_match5(elem *n1,elem *n2) +{ int result; + + gmatch2 = 8; + result = el_match(n1,n2); + gmatch2 = 0; + return result; +} + +/****************************** + * Extract long value from constant parser elem. + */ + +targ_llong el_tolongt(elem *e) +{ targ_llong result; + char parsersave = PARSER; + + PARSER = 1; + result = el_tolong(e); + PARSER = parsersave; + return result; +} + +/****************************** + * Extract long value from constant elem. + */ + +targ_llong el_tolong(elem *e) +{ targ_llong result; + tym_t ty; + + elem_debug(e); +#if SCPP + if (e->Eoper == OPsizeof) + { + e->Eoper = OPconst; + e->EV.Vllong = type_size(e->EV.sp.Vsym->Stype); + } +#endif +#ifdef DEBUG + if (e->Eoper != OPconst) + elem_print(e); +#endif + assert(e->Eoper == OPconst); + ty = tybasic(typemask(e)); +L1: + switch (ty) + { + case TYchar: + if (config.flags & CFGuchar) + goto Uchar; + /* FALL-THROUGH */ + case TYschar: + result = e->EV.Vschar; + break; + case TYuchar: + case TYbool: + Uchar: + result = e->EV.Vuchar; + break; + case TYshort: + Ishort: + result = e->EV.Vshort; + break; + case TYushort: + case TYwchar_t: + case TYchar16: + Ushort: + result = e->EV.Vushort; + break; +#if SCPP && TX86 + case TYenum: + assert(PARSER); + ty = e->ET->Tnext->Tty; + goto L1; +#endif + +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + case TYnptr: + case TYnullptr: + if (NPTRSIZE == SHORTSIZE) + goto Ushort; + if (NPTRSIZE == LONGSIZE) + goto Ulong; + if (NPTRSIZE == LLONGSIZE) + goto Ullong; + assert(0); + + case TYuint: + if (intsize == SHORTSIZE) + goto Ushort; + goto Ulong; + + case TYulong: + case TYdchar: +#if TARGET_SEGMENTED + case TYfptr: + case TYhptr: + case TYvptr: +#endif + case TYvoid: /* some odd cases */ + Ulong: + result = e->EV.Vulong; + break; + + case TYint: + if (intsize == SHORTSIZE) + goto Ishort; + goto Ilong; + + case TYlong: + Ilong: + result = e->EV.Vlong; + break; + + case TYllong: + case TYullong: + Ullong: + result = e->EV.Vullong; + break; + case TYdouble_alias: + case TYldouble: + case TYdouble: + case TYfloat: + case TYildouble: + case TYidouble: + case TYifloat: + case TYcldouble: + case TYcdouble: + case TYcfloat: + result = (targ_llong)el_toldouble(e); + break; + +#if SCPP + case TYmemptr: + ty = tybasic(tym_conv(e->ET)); + goto L1; +#endif + + case TYcent: + case TYucent: + goto Ullong; // should do better than this when actually doing arithmetic on cents + + default: +#if SCPP + // Can happen as result of syntax errors + assert(errcnt); +#else +#ifdef DEBUG + elem_print(e); +#endif + assert(0); +#endif + } + return result; +} + +/*********************************** + * Determine if constant e is all ones or all zeros. + * Input: + * bit 0: all zeros + * 1: 1 + * -1: all ones + */ + +int el_allbits(elem *e,int bit) +{ targ_llong value; + + elem_debug(e); + assert(e->Eoper == OPconst); + value = e->EV.Vullong; + switch (tysize(e->Ety)) + { + case 1: value = (signed char) value; + break; + case 2: value = (short) value; + break; + case 4: value = (int) value; + break; + case 8: break; + default: + assert(0); + } + if (bit == -1) + value++; + else if (bit == 1) + value--; + return value == 0; +} + +/******************************************** + * Determine if constant e is a 32 bit or less value, or is a 32 bit value sign extended to 64 bits. + */ + +int el_signx32(elem *e) +{ + elem_debug(e); + assert(e->Eoper == OPconst); + if (tysize(e->Ety) == 8) + { + if (e->EV.Vullong != (int)e->EV.Vullong) + return FALSE; + } + return TRUE; +} + +/****************************** + * Extract long double value from constant elem. + * Silently ignore types which are not floating point values. + */ + +targ_ldouble el_toldouble(elem *e) +{ targ_ldouble result; + + elem_debug(e); + assert(cnst(e)); +#if TX86 + switch (tybasic(typemask(e))) + { + case TYfloat: + case TYifloat: + result = e->EV.Vfloat; + break; + case TYdouble: + case TYidouble: + case TYdouble_alias: + result = e->EV.Vdouble; + break; + case TYldouble: + case TYildouble: + result = e->EV.Vldouble; + break; + default: + result = 0; + break; + } +#else + switch (tysize[tybasic(typemask(e))]) + { + case FLOATSIZE: // TYfloat + result = e->EV.Vfloat; + break; + case DOUBLESIZE: // TYdouble + result = e->EV.Vdouble; + break; +#if DOUBLESIZE != LNGDBLSIZE + case LNGDBLSIZE: // TYldouble +#ifdef LNGHDBLSIZE + case LNGHDBLSIZE: +#endif + result = e->EV.Vldouble; + break; +#endif + default: + result = 0; + break; + } +#endif + return result; +} + +/******************************** + * Is elem type-dependent or value-dependent? + * Return !=0 if so. + */ + +int el_isdependent(elem *e) +{ + if (type_isdependent(e->ET)) + return 1; + while (1) + { + if (e->PEFflags & PEFdependent) + return 1; + if (OTunary(e->Eoper)) + e = e->E1; + else if (OTbinary(e->Eoper)) + { if (el_isdependent(e->E2)) + return 1; + e = e->E1; + } + else + break; + } + return 0; +} + +/**************************************** + * Return alignment size of elem. + */ + +unsigned el_alignsize(elem *e) +{ + tym_t tym = tybasic(e->Ety); + unsigned alignsize = tyalignsize(tym); + if (alignsize == (unsigned)-1) + { + assert(e->ET); + alignsize = type_alignsize(e->ET); + } + return alignsize; +} + +/******************************* + * Check for errors in a tree. + */ + +#ifdef DEBUG + +void el_check(elem *e) +{ + elem_debug(e); + while (1) + { + if (OTunary(e->Eoper)) + e = e->E1; + else if (OTbinary(e->Eoper)) + { el_check(e->E2); + e = e->E1; + } + else + break; + } +} + +#endif + +/******************************* + * Write out expression elem. + */ + +#ifdef DEBUG + +void elem_print(elem *e) +{ static int nestlevel = 0; + int i; + tym_t tym; + + nestlevel++; + for (i = nestlevel; --i;) dbg_printf(" "); + dbg_printf("el:%p ",e); + if (!e) + { dbg_printf("\n"); + goto ret; + } + elem_debug(e); + if (configv.addlinenumbers) + { + e->Esrcpos.print("elem_print"); + } + if (!PARSER) + { dbg_printf("cnt=%d ",e->Ecount); + if (!OPTIMIZER) + dbg_printf("cs=%d ",e->Ecomsub); + } + WROP(e->Eoper); + dbg_printf(" "); + if (SCPP && PARSER) + { + if (e->ET) + { type_debug(e->ET); + if (tybasic(e->ET->Tty) == TYstruct) + dbg_printf("%d ", (int)type_size(e->ET)); + WRTYxx(e->ET->Tty); + } + } + else + { + if ((e->Eoper == OPstrpar || e->Eoper == OPstrctor || e->Eoper == OPstreq) || + e->Ety == TYstruct) + if (e->ET) + dbg_printf("%d ", (int)type_size(e->ET)); + WRTYxx(e->Ety); + } + if (OTunary(e->Eoper)) + { + if (e->E2) + dbg_printf("%p %p\n",e->E1,e->E2); + else + dbg_printf("%p\n",e->E1); + elem_print(e->E1); + } + else if (OTbinary(e->Eoper)) + { + if (!PARSER && e->Eoper == OPstreq) + dbg_printf("bytes=%d ", (int)type_size(e->ET)); + dbg_printf("%p %p\n",e->E1,e->E2); + elem_print(e->E1); + elem_print(e->E2); + } + else + { + switch (e->Eoper) + { + case OPrelconst: + dbg_printf(" %lld+&",(unsigned long long)e->Eoffset); + dbg_printf(" %s",e->EV.sp.Vsym->Sident); + break; + case OPvar: + if (e->Eoffset) + dbg_printf(" %lld+",(unsigned long long)e->Eoffset); + dbg_printf(" %s",e->EV.sp.Vsym->Sident); + break; + case OPasm: + case OPstring: + case OPhstring: + dbg_printf(" '%s',%lld\n",e->EV.ss.Vstring,(unsigned long long)e->EV.ss.Voffset); + break; + case OPconst: + tym = tybasic(typemask(e)); + case_tym: + switch (tym) + { case TYbool: + case TYchar: + case TYschar: + case TYuchar: + dbg_printf("%d ",e->EV.Vuchar); + break; +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + case TYnullptr: + case TYnptr: + if (NPTRSIZE == LONGSIZE) + goto L1; + if (NPTRSIZE == SHORTSIZE) + goto L3; + if (NPTRSIZE == LLONGSIZE) + goto L2; + assert(0); + break; + case TYenum: + if (PARSER) + { tym = e->ET->Tnext->Tty; + goto case_tym; + } + case TYint: + case TYuint: + case TYvoid: /* in case (void)(1) */ +#if TX86 + if (tysize[TYint] == LONGSIZE) + goto L1; +#endif + case TYshort: + case TYwchar_t: + case TYushort: + case TYchar16: + L3: + dbg_printf("%d ",e->EV.Vint); + break; + case TYlong: + case TYulong: + case TYdchar: +#if TARGET_SEGMENTED + case TYfptr: + case TYvptr: + case TYhptr: +#endif + L1: + dbg_printf("%dL ",e->EV.Vlong); + break; + + case TYllong: + L2: + dbg_printf("%lldLL ",e->EV.Vllong); + break; + + case TYullong: + dbg_printf("%lluLL ",e->EV.Vullong); + break; + + case TYcent: + case TYucent: + dbg_printf("%lluLL+%lluLL ", e->EV.Vcent.msw, e->EV.Vcent.lsw); + break; + + case TYfloat: + dbg_printf("%gf ",(double)e->EV.Vfloat); + break; + case TYdouble: + case TYdouble_alias: + dbg_printf("%g ",(double)e->EV.Vdouble); + break; + case TYldouble: + dbg_printf("%Lg ", e->EV.Vldouble); + break; + + case TYifloat: + dbg_printf("%gfi ", (double)e->EV.Vfloat); + break; + + case TYidouble: + dbg_printf("%gi ", (double)e->EV.Vdouble); + break; + + case TYildouble: + dbg_printf("%gLi ", (double)e->EV.Vldouble); + break; + + case TYcfloat: + dbg_printf("%gf+%gfi ", (double)e->EV.Vcfloat.re, (double)e->EV.Vcfloat.im); + break; + + case TYcdouble: + dbg_printf("%g+%gi ", (double)e->EV.Vcdouble.re, (double)e->EV.Vcdouble.im); + break; + + case TYcldouble: + dbg_printf("%gL+%gLi ", (double)e->EV.Vcldouble.re, (double)e->EV.Vcldouble.im); + break; + + case TYfloat4: + case TYdouble2: + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: + dbg_printf("%llxLL+%llxLL ", e->EV.Vcent.msw, e->EV.Vcent.lsw); + break; + +#if !MARS + case TYident: + dbg_printf("'%s' ", e->ET->Tident); + break; +#endif + + default: + dbg_printf("Invalid type "); + WRTYxx(typemask(e)); + /*assert(0);*/ + } + break; + default: + break; + } + dbg_printf("\n"); + } +ret: + nestlevel--; +} + +#endif + +/********************************** + * Hydrate an elem. + */ + +#if HYDRATE +void el_hydrate(elem **pe) +{ + elem *e; + + if (!isdehydrated(*pe)) + return; + + assert(PARSER); + e = (elem *) ph_hydrate(pe); + elem_debug(e); +#ifdef DEBUG + if (!(e->Eoper < OPMAX)) + dbg_printf("e = x%lx, e->Eoper = %d\n",e,e->Eoper); +#endif + debug_assert(e->Eoper < OPMAX); + type_hydrate(&e->ET); + if (configv.addlinenumbers) + { filename_translate(&e->Esrcpos); + srcpos_hydrate(&e->Esrcpos); + } + if (EOP(e)) + { el_hydrate(&e->E1); + if (EBIN(e)) + el_hydrate(&e->E2); +#if SCPP + else if (e->Eoper == OPctor) + { symbol_hydrate(&e->EV.eop.Edtor); + symbol_debug(e->EV.eop.Edtor); + } +#endif + } + else + { + switch (e->Eoper) + { case OPstring: + case OPasm: + ph_hydrate(&e->EV.ss.Vstring); + break; + + case OPrelconst: + //if (tybasic(e->ET->Tty) == TYmemptr) + //el_hydrate(&e->EV.sm.ethis); + case OPvar: +#if TX86 + symbol_hydrate(&e->EV.sp.Vsym); +#else + ph_hydrate(&e->EV.sp.Vsym); +#endif + symbol_debug(e->EV.sp.Vsym); + break; + } + } +} +#endif + +/********************************** + * Dehydrate an elem. + */ + +#if DEHYDRATE +void el_dehydrate(elem **pe) +{ elem *e; + + if ((e = *pe) == NULL || isdehydrated(e)) + return; + + assert(PARSER); + elem_debug(e); +#ifdef DEBUG + if (!(e->Eoper < OPMAX)) + dbg_printf("e = x%lx, e->Eoper = %d\n",e,e->Eoper); +#endif + debug_assert(e->Eoper < OPMAX); + ph_dehydrate(pe); +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(e)) + return; +#endif + type_dehydrate(&e->ET); +#if TX86 + if (configv.addlinenumbers) + srcpos_dehydrate(&e->Esrcpos); +#endif + if (EOP(e)) + { el_dehydrate(&e->E1); + if (EBIN(e)) + el_dehydrate(&e->E2); +#if SCPP + else if (e->Eoper == OPctor) + symbol_dehydrate(&e->EV.eop.Edtor); +#endif + } + else + { + switch (e->Eoper) + { case OPstring: + case OPasm: + ph_dehydrate(&e->EV.ss.Vstring); + break; + case OPrelconst: + //if (tybasic(e->ET->Tty) == TYmemptr) + //el_dehydrate(&e->EV.sm.ethis); + case OPvar: +#if TX86 + symbol_dehydrate(&e->EV.sp.Vsym); +#else + ph_dehydrate(&e->EV.sp.Vsym); +#endif + break; + } + } +} +#endif + +#endif /* !SPP */ diff --git a/backend/el.h b/backend/el.h new file mode 100644 index 00000000..40aa3eb2 --- /dev/null +++ b/backend/el.h @@ -0,0 +1,219 @@ +// Copyright (C) 1985-1995 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/* Routines to handle elems. */ + +#if __SC__ +#pragma once +#endif + +#ifndef EL_H +#define EL_H 1 + +/****************************************** + * Elems: + * Elems are the basic tree element. They can be either + * terminal elems (leaves), unary elems (left subtree exists) + * or binary elems (left and right subtrees exist). + */ + +struct elem +{ +#ifdef DEBUG + unsigned short id; +#define IDelem 0x4C45 // 'EL' +#define elem_debug(e) assert((e)->id == IDelem) +#else +#define elem_debug(e) +#endif + + unsigned char Eoper; // operator (OPxxxx) + unsigned char Ecount; // # of parents of this elem - 1, + // always 0 until CSE elimination is done + unsigned char Eflags; + #define EFLAGS_variadic 1 // variadic function call + + union eve EV; // variants for each type of elem + union + { + // PARSER + struct + { + unsigned PEFflags_; + #define PEFflags _EU._EP.PEFflags_ + #define PEFnotlvalue 1 // although elem may look like + // an lvalue, it isn't + #define PEFtemplate_id 0x10 // symbol is a template-id + #define PEFparentheses 0x20 // expression was within () + #define PEFaddrmem 0x40 // address of member + #define PEFdependent 0x80 // value-dependent + #define PEFmember 0x100 // was a class member access + Symbol *Emember_; // if PEFmember, this is the member + #define Emember _EU._EP.Emember_ + }_EP; + + // OPTIMIZER + struct + { + tym_t Ety_; // data type (TYxxxx) + #define Ety _EU._EO.Ety_ + unsigned Eexp_; // index into expnod[] + #define Eexp _EU._EO.Eexp_ + + // These flags are all temporary markers, used once and then + // thrown away. + unsigned char Nflags_; // NFLxxx + #define Nflags _EU._EO.Nflags_ + #define NFLli 1 // loop invariant + #define NFLnogoal 2 // evaluate elem for side effects only + #define NFLassign 8 // unambiguous assignment elem + #define NFLaecp 0x10 // AE or CP or VBE expression + #define NFLdelcse 0x40 // this is not the generating CSE + #define NFLtouns 0x80 // relational operator was changed from signed to unsigned +#if MARS + unsigned char Ejty_; // original Jupiter/Mars type + #define Ejty _EU._EO.Ejty_ +#endif + }_EO; + + // CODGEN + struct + { + // Ety2: Must be in same position as Ety! + tym_t Ety2_; // data type (TYxxxx) + #define Ety2 _EU._EC.Ety2_ + unsigned char Ecomsub_; // number of remaining references to + // this common subexp (used to determine + // first, intermediate, and last references + // to a CSE) + #define Ecomsub _EU._EC.Ecomsub_ + }_EC; + }_EU; + + struct TYPE *ET; // pointer to type of elem if TYstruct | TYarray + Srcpos Esrcpos; // source file position +}; + +#define typemask(e) ((!MARS && PARSER) ? (e)->ET->Tty : (e)->Ety ) +#define typetym(e) ((e)->ET->Tty) +#define el_fl(e) ((enum FL)((e)->EV.sp.Vsym->Sfl)) +#define Eoffset EV.sp.Voffset +#define Esymnum EV.sp.Vsymnum + +#define list_elem(list) ((elem *) list_ptr(list)) +#define list_setelem(list,ptr) list_ptr(list) = (elem *)(ptr) +#define cnst(e) ((e)->Eoper == OPconst) /* Determine if elem is a constant */ +#define E1 EV.eop.Eleft /* left child */ +#define E2 EV.eop.Eright /* right child */ +#define Erd EV.sp.spu.Erd // reaching definition + +#define el_int(a,b) el_long(a,b) + +typedef elem *elem_p; /* try to reduce the symbol table size */ + +void el_init(void); +void el_reset(void); +void el_term(void); +elem_p el_calloc(void); +void el_free(elem_p); +elem_p el_combine(elem_p ,elem_p); +elem_p el_param(elem_p ,elem_p); +elem_p el_params(elem_p , ...); +elem *el_params(void **args, int length); +elem *el_combines(void **args, int length); +int el_nparams(elem *e); +elem_p el_pair(tym_t, elem_p, elem_p); +void el_copy(elem_p ,elem_p); +elem_p el_alloctmp(tym_t); +elem_p el_selecte1(elem_p); +elem_p el_selecte2(elem_p); +elem_p el_copytree(elem_p); +void el_replace_sym(elem *e,symbol *s1,symbol *s2); +elem_p el_scancommas(elem_p); +int el_countCommas(elem_p); +int el_sideeffect(elem_p); +int el_depends(elem *ea,elem *eb); +#if LONGLONG +targ_llong el_tolongt(elem_p); +targ_llong el_tolong(elem_p); +#else +targ_long el_tolongt(elem_p); +targ_long el_tolong(elem_p); +#endif +int el_allbits(elem_p,int); +int el_signx32(elem_p); +targ_ldouble el_toldouble(elem_p); +void el_toconst(elem_p); +elem_p el_same(elem_p *); +int el_match(elem_p ,elem_p); +int el_match2(elem_p ,elem_p); +int el_match3(elem_p ,elem_p); +int el_match4(elem_p ,elem_p); +int el_match5(elem_p ,elem_p); + +int el_appears(elem *e,symbol *s); +Symbol *el_basesym(elem *e); +int el_anydef(elem *ed, elem *e); +elem_p el_bint(unsigned,type *,elem_p ,elem_p); +elem_p el_unat(unsigned,type *,elem_p); +elem_p el_bin(unsigned,tym_t,elem_p ,elem_p); +elem_p el_una(unsigned,tym_t,elem_p); +#if LONGLONG // DJB +elem_p el_longt(type *,targ_llong); +#else +elem_p el_longt(type *,targ_long); +#endif +symbol *el_alloc_localgot(); +elem_p el_var(symbol *); +elem_p el_settype(elem_p ,type *); +elem_p el_typesize(type *); +elem_p el_ptr(symbol *); +void el_replace_sym(elem *e,symbol *s1,symbol *s2); +elem * el_ptr_offset(symbol *s,targ_size_t offset); +void el_replacesym(elem *,symbol *,symbol *); +elem_p el_nelems(type *); + +#if LONGLONG +elem_p el_long(tym_t,targ_llong); +#else +elem_p el_long(tym_t,targ_long); +#endif + +int ERTOL(elem_p); +int el_noreturn(elem_p); +elem *el_dctor(elem *e,void *decl); +elem *el_ddtor(elem *e,void *decl); +elem *el_ctor(elem *ector,elem *e,symbol *sdtor); +elem *el_dtor(elem *edtor,elem *e); +elem *el_zero(type *t); +elem_p el_const(tym_t,union eve *); +elem_p el_test(tym_t,union eve *); +elem_p * el_parent(elem_p ,elem_p *); + +#ifdef DEBUG +void el_check(elem_p); +#else +#define el_check(e) ((void)0) +#endif + +elem *el_convfloat(elem *); +elem *el_convstring(elem *); +elem *el_convert(elem *e); +int el_isdependent(elem *); +unsigned el_alignsize(elem *); + +void elem_print(elem *); +void el_hydrate(elem **); +void el_dehydrate(elem **); + +#endif + diff --git a/backend/elfobj.c b/backend/elfobj.c new file mode 100644 index 00000000..b3aa5a28 --- /dev/null +++ b/backend/elfobj.c @@ -0,0 +1,3111 @@ +// Copyright (C) ?-1998 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +// Output to ELF object files + +#if SCPP || MARS +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "cc.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "melf.h" +#include "outbuf.h" +#include "filespec.h" +#include "cv4.h" +#include "cgcv.h" +#include "dt.h" + +#include "aa.h" +#include "tinfo.h" + +#if ELFOBJ + +#include "dwarf.h" + +#include "aa.h" +#include "tinfo.h" + +//#define DEBSYM 0x7E + +static Outbuffer *fobjbuf; + +regm_t BYTEREGS = BYTEREGS_INIT; +regm_t ALLREGS = ALLREGS_INIT; + +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" + +#define MATCH_SECTION 1 + +#define DEST_LEN (IDMAX + IDOHD + 1) +char *obj_mangle2(Symbol *s,char *dest); + +#if MARS +// C++ name mangling is handled by front end +#define cpp_mangle(s) ((s)->Sident) +#endif + +/*************************************************** + * Correspondence of relocation types + * 386 32 bit in 64 64 in 64 + * RI_TYPE_SYM32 R_X86_64_32 R_X86_64_64 + * RI_TYPE_GOTOFF R_X86_64_PC32 R_X86_64_ + * RI_TYPE_GOTPC R_X86_64_ R_X86_64_ + * RI_TYPE_GOT32 R_X86_64_ R_X86_64_ + * RI_TYPE_TLS_GD R_X86_64_TLSGD R_X86_64_ + * RI_TYPE_TLS_IE R_X86_64_GOTTPOFF R_X86_64_ + * RI_TYPE_TLS_LE R_X86_64_TPOFF32 R_X86_64_ + * RI_TYPE_PLT32 R_X86_64_PLT32 R_X86_64_ + * RI_TYPE_PC32 R_X86_64_PC32 R_X86_64_ + */ + +/****************************************** + */ + +symbol *GOTsym; // global offset table reference + +symbol *elfobj_getGOTsym() +{ + if (!GOTsym) + { + GOTsym = symbol_name("_GLOBAL_OFFSET_TABLE_",SCglobal,tspvoid); + } + return GOTsym; +} + +void elfobj_refGOTsym() +{ + if (!GOTsym) + { + symbol *s = elfobj_getGOTsym(); + objextern(s); + } +} + +static void objfile_write(FILE *fd, void *buffer, unsigned len); + +STATIC char * objmodtoseg (const char *modname); +STATIC void obj_browse_flush(); +STATIC void objfixupp (struct FIXUP *); +STATIC void ledata_new (int seg,targ_size_t offset); +void obj_tlssections(); + +static IDXSYM elf_addsym(IDXSTR sym, targ_size_t val, unsigned sz, + unsigned typ,unsigned bind,IDXSEC sec); +static long elf_align(FILE *fd, targ_size_t size, long offset); + +// The object file is built is several separate pieces + +// Non-repeatable section types have single output buffers +// Pre-allocated buffers are defined for: +// Section Names string table +// Section Headers table +// Symbol table +// String table +// Notes section +// Comment data + +// Section Names - String table for section names only +static Outbuffer *section_names; +#define SEC_NAMES_INIT 800 +#define SEC_NAMES_INC 400 + +// Hash table for section_names +AArray *section_names_hashtable; + +/* ====================== Cached Strings in section_names ================= */ + +struct TypeInfo_Idxstr : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +TypeInfo_Idxstr ti_idxstr; + +const char* TypeInfo_Idxstr::toString() +{ + return "IDXSTR"; +} + +hash_t TypeInfo_Idxstr::getHash(void *p) +{ + IDXSTR a = *(IDXSTR *)p; + hash_t hash = 0; + for (const char *s = (char *)(section_names->buf + a); + *s; + s++) + { + hash = hash * 11 + *s; + } + return hash; +} + +int TypeInfo_Idxstr::equals(void *p1, void *p2) +{ + IDXSTR a1 = *(IDXSTR*)p1; + IDXSTR a2 = *(IDXSTR*)p2; + const char *s1 = (char *)(section_names->buf + a1); + const char *s2 = (char *)(section_names->buf + a2); + + return strcmp(s1, s2) == 0; +} + +int TypeInfo_Idxstr::compare(void *p1, void *p2) +{ + IDXSTR a1 = *(IDXSTR*)p1; + IDXSTR a2 = *(IDXSTR*)p2; + const char *s1 = (char *)(section_names->buf + a1); + const char *s2 = (char *)(section_names->buf + a2); + + return strcmp(s1, s2); +} + +size_t TypeInfo_Idxstr::tsize() +{ + return sizeof(IDXSTR); +} + +void TypeInfo_Idxstr::swap(void *p1, void *p2) +{ + assert(0); +} + + +/* ======================================================================== */ + +// String Table - String table for all other names +static Outbuffer *symtab_strings; + + +// Section Headers +Outbuffer *SECbuf; // Buffer to build section table in +#define SecHdrTab ((Elf32_Shdr *)SECbuf->buf) +#define GET_SECTION(secidx) (SecHdrTab + secidx) +#define GET_SECTION_NAME(secidx) (section_names->buf + SecHdrTab[secidx].sh_name) + +// The relocation for text and data seems to get lost. +// Try matching the order gcc output them +// This means defining the sections and then removing them if they are +// not used. +static int section_cnt; // Number of sections in table + +#define SHI_TEXT 1 +#define SHI_RELTEXT 2 +#define SHI_DATA 3 +#define SHI_RELDATA 4 +#define SHI_BSS 5 +#define SHI_RODAT 6 +#define SHI_STRINGS 7 +#define SHI_SYMTAB 8 +#define SHI_SECNAMES 9 +#define SHI_COM 10 +#define SHI_NOTE 11 + +IDXSYM *mapsec2sym; +#define S2S_INC 20 + +#define SymbolTable ((Elf32_Sym *)SYMbuf->buf) +#define SymbolTable64 ((Elf64_Sym *)SYMbuf->buf) +static int symbol_idx; // Number of symbols in symbol table +static int local_cnt; // Number of symbols with STB_LOCAL + +#define STI_FILE 1 // Where file symbol table entry is +#define STI_TEXT 2 +#define STI_DATA 3 +#define STI_BSS 4 +#define STI_GCC 5 // Where "gcc2_compiled" symbol is */ +#define STI_RODAT 6 // Symbol for readonly data +#define STI_NOTE 7 // Where note symbol table entry is +#define STI_COM 8 + +// NOTE: There seems to be a requirement that the read-only data have the +// same symbol table index and section index. Use section NOTE as a place +// holder. When a read-only string section is required, swap to NOTE. + +// Symbol Table +Outbuffer *SYMbuf; // Buffer to build symbol table in + +// Notes data (note currently used) +static Outbuffer *note_data; +static IDXSEC secidx_note; // Final table index for note data + +// Comment data for compiler version +static Outbuffer *comment_data; +static const char compiler[] = "\0Digital Mars C/C++" + VERSION + ; // compiled by ... + +// Each compiler segment is an elf section +// Predefined compiler segments CODE,DATA,CDATA,UDATA map to indexes +// into SegData[] +// An additionl index is reserved for comment data +// New compiler segments are added to end. +// +// There doesn't seem to be any way to get reserved data space in the +// same section as initialized data or code, so section offsets should +// be continuous when adding data. Fix-ups anywhere withing existing data. + +#define COMD UDATA+1 +#define OB_SEG_SIZ 10 // initial number of segments supported +#define OB_SEG_INC 10 // increment for additional segments + +#define OB_CODE_STR 100000 // initial size for code +#define OB_CODE_INC 100000 // increment for additional code +#define OB_DATA_STR 100000 // initial size for data +#define OB_DATA_INC 100000 // increment for additional data +#define OB_CDATA_STR 1024 // initial size for data +#define OB_CDATA_INC 1024 // increment for additional data +#define OB_COMD_STR 256 // initial size for comments + // increment as needed +#define OB_XTRA_STR 250 // initial size for extra segments +#define OB_XTRA_INC 10000 // increment size + +#define MAP_SEG2SECIDX(seg) (SegData[seg]->SDshtidx) +#define MAP_SEG2SYMIDX(seg) (SegData[seg]->SDsymidx) +#define MAP_SEG2SEC(seg) (&SecHdrTab[MAP_SEG2SECIDX(seg)]) +#define MAP_SEG2TYP(seg) (MAP_SEG2SEC(seg)->sh_flags & SHF_EXECINSTR ? CODE : DATA) + +seg_data **SegData; +int seg_count; +int seg_max; +int seg_tlsseg = UNKNOWN; +int seg_tlsseg_bss = UNKNOWN; + +int elf_getsegment2(IDXSEC shtidx, IDXSYM symidx, IDXSEC relidx); + + +/******************************* + * Output a string into a string table + * Input: + * strtab = string table for entry + * str = string to add + * + * Returns index into the specified string table. + */ + +IDXSTR elf_addstr(Outbuffer *strtab, const char *str) +{ + //dbg_printf("elf_addstr(strtab = x%x str = '%s')\n",strtab,str); + IDXSTR idx = strtab->size(); // remember starting offset + strtab->writeString(str); + //dbg_printf("\tidx %d, new size %d\n",idx,strtab->size()); + return idx; +} + +/******************************* + * Find a string in a string table + * Input: + * strtab = string table for entry + * str = string to find + * + * Returns index into the specified string table or 0. + */ + +static IDXSTR elf_findstr(Outbuffer *strtab, const char *str, const char *suffix) +{ + //printf("elf_findstr(strtab = %p, str = %s, suffix = %s\n", strtab, str ? str : "", suffix ? suffix : ""); + + size_t len = strlen(str); + + // Combine str~suffix and have buf point to the combination +#ifdef DEBUG + char tmpbuf[25]; // to exercise the alloca() code path +#else + char tmpbuf[1024]; // the alloca() code path is slow +#endif + const char *buf; + if (suffix) + { + size_t suffixlen = strlen(suffix); + if (len + suffixlen >= sizeof(tmpbuf)) + { + buf = (char *)alloca(len + suffixlen + 1); + assert(buf); + } + else + { + buf = tmpbuf; + } + memcpy((char *)buf, str, len); + memcpy((char *)buf + len, suffix, suffixlen + 1); + len += suffixlen; + } + else + buf = str; + + // Linear search, slow + const char *ent = (char *)strtab->buf+1; + const char *pend = ent+strtab->size() - 1; + while (ent + len < pend) + { + if (memcmp(buf, ent, len + 1) == 0) + return ent - (const char *)strtab->buf; + ent = (const char *)memchr(ent, 0, pend - ent); + ent += 1; + } + return 0; // never found match +} + +/******************************* + * Output a mangled string into the symbol string table + * Input: + * str = string to add + * + * Returns index into the table. + */ + +static IDXSTR elf_addmangled(Symbol *s) +{ + //printf("elf_addmangled(%s)\n", s->Sident); + char dest[DEST_LEN]; + char *destr; + const char *name; + int len; + IDXSTR namidx; + + namidx = symtab_strings->size(); + destr = obj_mangle2(s, dest); + name = destr; + if (CPP && name[0] == '_' && name[1] == '_') + { + if (strncmp(name,"__ct__",6) == 0) + name += 4; +#if 0 + switch(name[2]) + { + case 'c': + if (strncmp(name,"__ct__",6) == 0) + name += 4; + break; + case 'd': + if (strcmp(name,"__dl__FvP") == 0) + name = "__builtin_delete"; + break; + case 'v': + //if (strcmp(name,"__vec_delete__FvPiUIPi") == 0) + //name = "__builtin_vec_del"; + //else + //if (strcmp(name,"__vn__FPUI") == 0) + //name = "__builtin_vec_new"; + break; + case 'n': + if (strcmp(name,"__nw__FPUI") == 0) + name = "__builtin_new"; + break; + } +#endif + } + else if (tyfunc(s->ty()) && s->Sfunc && s->Sfunc->Fredirect) + name = s->Sfunc->Fredirect; + len = strlen(name); + symtab_strings->reserve(len+1); + strcpy((char *)symtab_strings->p,name); + symtab_strings->setsize(namidx+len+1); + if (destr != dest) // if we resized result + mem_free(destr); + //dbg_printf("\telf_addmagled symtab_strings %s namidx %d len %d size %d\n",name, namidx,len,symtab_strings->size()); + return namidx; +} + +/******************************* + * Output a symbol into the symbol table + * Input: + * stridx = string table index for name + * val = value associated with symbol + * sz = symbol size + * typ = symbol type + * bind = symbol binding + * segidx = segment index for segment where symbol is defined + * + * Returns the symbol table index for the symbol + */ + +static IDXSYM elf_addsym(IDXSTR nam, targ_size_t val, unsigned sz, + unsigned typ, unsigned bind, IDXSEC sec) +{ + //dbg_printf("elf_addsym(nam %d, val %d, sz %x, typ %x, bind %x, sec %d\n", + //nam,val,sz,typ,bind,sec); + + /* We want globally defined data symbols to have a size because + * zero sized symbols break copy relocations for shared libraries. + */ + assert(!(sz == 0 && (bind == STB_GLOBAL || bind == STB_WEAK) && + (typ == STT_OBJECT || typ == STT_TLS) && + sec != SHT_UNDEF)); + + if (I64) + { + if (!SYMbuf) + { SYMbuf = new Outbuffer(50 * sizeof(Elf64_Sym)); + SYMbuf->reserve(100 * sizeof(Elf64_Sym)); + } + Elf64_Sym sym; + sym.st_name = nam; + sym.st_value = val; + sym.st_size = sz; + sym.st_info = ELF_ST_INFO(bind,typ); + sym.st_other = 0; + sym.st_shndx = sec; + SYMbuf->write(&sym,sizeof(sym)); + } + else + { + if (!SYMbuf) + { SYMbuf = new Outbuffer(50 * sizeof(Elf32_Sym)); + SYMbuf->reserve(100 * sizeof(Elf32_Sym)); + } + Elf32_Sym sym; + sym.st_name = nam; + sym.st_value = val; + sym.st_size = sz; + sym.st_info = ELF_ST_INFO(bind,typ); + sym.st_other = 0; + sym.st_shndx = sec; + SYMbuf->write(&sym,sizeof(sym)); + } + if (bind == STB_LOCAL) + local_cnt++; + //dbg_printf("\treturning symbol table index %d\n",symbol_idx); + return symbol_idx++; +} + +/******************************* + * Create a new section header table entry. + * + * Input: + * name = section name + * suffix = suffix for name or NULL + * type = type of data in section sh_type + * flags = attribute flags sh_flags + * Output: + * section_cnt = assigned number for this section + * Note: Sections will be reordered on output + */ + +static IDXSEC elf_newsection2( + elf_u32_f32 name, + elf_u32_f32 type, + elf_u32_f32 flags, + elf_add_f32 addr, + elf_off_f32 offset, + elf_u32_f32 size, + elf_u32_f32 link, + elf_u32_f32 info, + elf_u32_f32 addralign, + elf_u32_f32 entsize) +{ + Elf32_Shdr sec; + + sec.sh_name = name; + sec.sh_type = type; + sec.sh_flags = flags; + sec.sh_addr = addr; + sec.sh_offset = offset; + sec.sh_size = size; + sec.sh_link = link; + sec.sh_info = info; + sec.sh_addralign = addralign; + sec.sh_entsize = entsize; + + if (!SECbuf) + { SECbuf = new Outbuffer(4 * sizeof(Elf32_Shdr)); + SECbuf->reserve(16 * sizeof(Elf32_Shdr)); + } + SECbuf->write((void *)&sec, sizeof(sec)); + return section_cnt++; +} + +static IDXSEC elf_newsection(const char *name, const char *suffix, + elf_u32_f32 type, elf_u32_f32 flags) +{ + // dbg_printf("elf_newsection(%s,%s,type %d, flags x%x)\n", + // name?name:"",suffix?suffix:"",type,flags); + + IDXSTR namidx = section_names->size(); + section_names->writeString(name); + if (suffix) + { // Append suffix string + section_names->setsize(section_names->size() - 1); // back up over terminating 0 + section_names->writeString(suffix); + } + IDXSTR *pidx = (IDXSTR *)section_names_hashtable->get(&namidx); + assert(!*pidx); // must not already exist + *pidx = namidx; + + return elf_newsection2(namidx,type,flags,0,0,0,0,0,0,0); +} + +/************************** + * Ouput read only data and generate a symbol for it. + * + */ + +symbol *elf_sym_cdata(tym_t ty,char *p,int len) +{ + symbol *s; + +#if 0 + if (OPT_IS_SET(OPTfwritable_strings)) + { + alignOffset(DATA, tysize(ty)); + s = symboldata(Doffset, ty); + SegData[DATA]->SDbuf->write(p,len); + s->Sseg = DATA; + s->Soffset = Doffset; // Remember its offset into DATA section + Doffset += len; + } + else +#endif + { + //printf("elf_sym_cdata(ty = %x, p = %x, len = %d, CDoffset = %x)\n", ty, p, len, CDoffset); + alignOffset(CDATA, tysize(ty)); + s = symboldata(CDoffset, ty); + obj_bytes(CDATA, CDoffset, len, p); + s->Sseg = CDATA; + } + + s->Sfl = /*(config.flags3 & CFG3pic) ? FLgotoff :*/ FLextern; + return s; +} + +/************************** + * Ouput read only data for data + * + */ + +int elf_data_cdata(char *p, int len, int *pseg) +{ + int oldoff; + /*if (OPT_IS_SET(OPTfwritable_strings)) + { + oldoff = Doffset; + SegData[DATA]->SDbuf->reserve(len); + SegData[DATA]->SDbuf->writen(p,len); + Doffset += len; + *pseg = DATA; + } + else*/ + { + oldoff = CDoffset; + SegData[CDATA]->SDbuf->reserve(len); + SegData[CDATA]->SDbuf->writen(p,len); + CDoffset += len; + *pseg = CDATA; + } + return oldoff; +} + +int elf_data_cdata(char *p, int len) +{ + int pseg; + + return elf_data_cdata(p, len, &pseg); +} + +/****************************** + * Perform initialization that applies to all .o output files. + * Called before any other obj_xxx routines + */ + +void obj_init(Outbuffer *objbuf, const char *filename, const char *csegname) +{ + //printf("obj_init()\n"); + + cseg = CODE; + fobjbuf = objbuf; + + mapsec2sym = NULL; + note_data = NULL; + secidx_note = 0; + comment_data = NULL; + seg_tlsseg = UNKNOWN; + seg_tlsseg_bss = UNKNOWN; + GOTsym = NULL; + + // Initialize buffers + + if (symtab_strings) + symtab_strings->setsize(1); + else + { symtab_strings = new Outbuffer(1024); + symtab_strings->reserve(2048); + symtab_strings->writeByte(0); + } + + if (SECbuf) + SECbuf->setsize(0); + section_cnt = 0; + + if (I64) + { + static char section_names_init64[] = + "\0.symtab\0.strtab\0.shstrtab\0.text\0.data\0.bss\0.note\0.comment\0.rodata\0.note.GNU-stack\0.rela.text\0.rela.data"; + #define NAMIDX_NONE 0 + #define NAMIDX_SYMTAB 1 // .symtab + #define NAMIDX_STRTAB 9 // .strtab + #define NAMIDX_SHSTRTAB 17 // .shstrtab + #define NAMIDX_TEXT 27 // .text + #define NAMIDX_DATA 33 // .data + #define NAMIDX_BSS 39 // .bss + #define NAMIDX_NOTE 44 // .note + #define NAMIDX_COMMENT 50 // .comment + #define NAMIDX_RODATA 59 // .rodata + #define NAMIDX_GNUSTACK 67 // .note.GNU-stack + #define NAMIDX_RELTEXT 83 // .rel.text and .rela.text + #define NAMIDX_RELDATA 93 // .rel.data + #define NAMIDX_RELDATA64 94 // .rela.data + + if (section_names) + section_names->setsize(sizeof(section_names_init64)); + else + { section_names = new Outbuffer(512); + section_names->reserve(1024); + section_names->writen(section_names_init64, sizeof(section_names_init64)); + } + + if (section_names_hashtable) + delete section_names_hashtable; + section_names_hashtable = new AArray(&ti_idxstr, sizeof(IDXSTR)); + + // name,type,flags,addr,offset,size,link,info,addralign,entsize + elf_newsection2(0, SHT_NULL, 0, 0,0,0,0,0, 0,0); + elf_newsection2(NAMIDX_TEXT,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR,0,0,0,0,0, 4,0); + elf_newsection2(NAMIDX_RELTEXT,SHT_RELA, 0,0,0,0,SHI_SYMTAB, SHI_TEXT, 8,0x18); + elf_newsection2(NAMIDX_DATA,SHT_PROGDEF,SHF_ALLOC|SHF_WRITE, 0,0,0,0,0, 8,0); + elf_newsection2(NAMIDX_RELDATA64,SHT_RELA, 0,0,0,0,SHI_SYMTAB, SHI_DATA, 8,0x18); + elf_newsection2(NAMIDX_BSS, SHT_NOBITS,SHF_ALLOC|SHF_WRITE, 0,0,0,0,0, 16,0); + elf_newsection2(NAMIDX_RODATA,SHT_PROGDEF,SHF_ALLOC, 0,0,0,0,0, 16,0); + elf_newsection2(NAMIDX_STRTAB,SHT_STRTAB, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_SYMTAB,SHT_SYMTAB, 0, 0,0,0,0,0, 8,0); + elf_newsection2(NAMIDX_SHSTRTAB,SHT_STRTAB, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_COMMENT, SHT_PROGDEF,0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_NOTE,SHT_NOTE, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_GNUSTACK,SHT_PROGDEF,0, 0,0,0,0,0, 1,0); + + IDXSTR namidx; + namidx = NAMIDX_TEXT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RELTEXT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_DATA; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RELDATA64; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_BSS; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RODATA; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_STRTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_SYMTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_SHSTRTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_COMMENT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_NOTE; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_GNUSTACK; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + } + else + { + static char section_names_init[] = + "\0.symtab\0.strtab\0.shstrtab\0.text\0.data\0.bss\0.note\0.comment\0.rodata\0.note.GNU-stack\0.rel.text\0.rel.data"; + + if (section_names) + section_names->setsize(sizeof(section_names_init)); + else + { section_names = new Outbuffer(512); + section_names->reserve(100*1024); + section_names->writen(section_names_init, sizeof(section_names_init)); + } + + if (section_names_hashtable) + delete section_names_hashtable; + section_names_hashtable = new AArray(&ti_idxstr, sizeof(IDXSTR)); + + // name,type,flags,addr,offset,size,link,info,addralign,entsize + elf_newsection2(0, SHT_NULL, 0, 0,0,0,0,0, 0,0); + elf_newsection2(NAMIDX_TEXT,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR,0,0,0,0,0, 16,0); + elf_newsection2(NAMIDX_RELTEXT,SHT_REL, 0,0,0,0,SHI_SYMTAB, SHI_TEXT, 4,8); + elf_newsection2(NAMIDX_DATA,SHT_PROGDEF,SHF_ALLOC|SHF_WRITE, 0,0,0,0,0, 4,0); + elf_newsection2(NAMIDX_RELDATA,SHT_REL, 0,0,0,0,SHI_SYMTAB, SHI_DATA, 4,8); + elf_newsection2(NAMIDX_BSS, SHT_NOBITS,SHF_ALLOC|SHF_WRITE, 0,0,0,0,0, 32,0); + elf_newsection2(NAMIDX_RODATA,SHT_PROGDEF,SHF_ALLOC, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_STRTAB,SHT_STRTAB, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_SYMTAB,SHT_SYMTAB, 0, 0,0,0,0,0, 4,0); + elf_newsection2(NAMIDX_SHSTRTAB,SHT_STRTAB, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_COMMENT, SHT_PROGDEF,0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_NOTE,SHT_NOTE, 0, 0,0,0,0,0, 1,0); + elf_newsection2(NAMIDX_GNUSTACK,SHT_PROGDEF,0, 0,0,0,0,0, 1,0); + + IDXSTR namidx; + namidx = NAMIDX_TEXT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RELTEXT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_DATA; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RELDATA; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_BSS; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_RODATA; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_STRTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_SYMTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_SHSTRTAB; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_COMMENT; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_NOTE; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + namidx = NAMIDX_GNUSTACK; *(IDXSTR *)section_names_hashtable->get(&namidx) = namidx; + } + + if (SYMbuf) + SYMbuf->setsize(0); + symbol_idx = 0; + local_cnt = 0; + // The symbols that every object file has + elf_addsym(0, 0, 0, STT_NOTYPE, STB_LOCAL, 0); + elf_addsym(0, 0, 0, STT_FILE, STB_LOCAL, SHT_ABS); // STI_FILE + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_TEXT); // STI_TEXT + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_DATA); // STI_DATA + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_BSS); // STI_BSS + elf_addsym(0, 0, 0, STT_NOTYPE, STB_LOCAL, SHI_TEXT); // STI_GCC + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_RODAT); // STI_RODAT + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_NOTE); // STI_NOTE + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, SHI_COM); // STI_COM + + // Initialize output buffers for CODE, DATA and COMMENTS + // (NOTE not supported, BSS not required) + + seg_count = 0; + + elf_getsegment2(SHI_TEXT, STI_TEXT, SHI_RELTEXT); + assert(SegData[CODE]->SDseg == CODE); + + elf_getsegment2(SHI_DATA, STI_DATA, SHI_RELDATA); + assert(SegData[DATA]->SDseg == DATA); + + elf_getsegment2(SHI_RODAT, STI_RODAT, 0); + assert(SegData[CDATA]->SDseg == CDATA); + + elf_getsegment2(SHI_BSS, STI_BSS, 0); + assert(SegData[UDATA]->SDseg == UDATA); + + elf_getsegment2(SHI_COM, STI_COM, 0); + assert(SegData[COMD]->SDseg == COMD); + + if (config.fulltypes) + dwarf_initfile(filename); +} + +/************************** + * Initialize the start of object output for this particular .o file. + * + * Input: + * filename: Name of source file + * csegname: User specified default code segment name + */ + +void obj_initfile(const char *filename, const char *csegname, const char *modname) +{ + //dbg_printf("obj_initfile(filename = %s, modname = %s)\n",filename,modname); + + IDXSTR name = elf_addstr(symtab_strings, filename); + if (I64) + SymbolTable64[STI_FILE].st_name = name; + else + SymbolTable[STI_FILE].st_name = name; + +#if 0 + // compiler flag for linker + if (I64) + SymbolTable64[STI_GCC].st_name = elf_addstr(symtab_strings,"gcc2_compiled."); + else + SymbolTable[STI_GCC].st_name = elf_addstr(symtab_strings,"gcc2_compiled."); +#endif + + if (csegname && *csegname && strcmp(csegname,".text")) + { // Define new section and make it the default for cseg segment + // NOTE: cseg is initialized to CODE + IDXSEC newsecidx; + Elf32_Shdr *newtextsec; + IDXSYM newsymidx; + SegData[cseg]->SDshtidx = newsecidx = + elf_newsection(csegname,0,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR); + newtextsec = &SecHdrTab[newsecidx]; + newtextsec->sh_addralign = 4; + SegData[cseg]->SDsymidx = + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, newsecidx); + } + if (config.fulltypes) + dwarf_initmodule(filename, modname); +} + +/*************************** + * Renumber symbols so they are + * ordered as locals, weak and then global + * Returns: + * sorted symbol table, caller must free with util_free() + */ + +void *elf_renumbersyms() +{ void *symtab; + int nextlocal = 0; + int nextglobal = local_cnt; + + SYMIDX *sym_map = (SYMIDX *)util_malloc(sizeof(SYMIDX),symbol_idx); + + if (I64) + { + Elf64_Sym *oldsymtab = (Elf64_Sym *)SYMbuf->buf; + Elf64_Sym *symtabend = oldsymtab+symbol_idx; + + symtab = util_malloc(sizeof(Elf64_Sym),symbol_idx); + + Elf64_Sym *sl = (Elf64_Sym *)symtab; + Elf64_Sym *sg = sl + local_cnt; + + int old_idx = 0; + for(Elf64_Sym *s = oldsymtab; s != symtabend; s++) + { // reorder symbol and map new #s to old + int bind = ELF_ST_BIND(s->st_info); + if (bind == STB_LOCAL) + { + *sl++ = *s; + sym_map[old_idx] = nextlocal++; + } + else + { + *sg++ = *s; + sym_map[old_idx] = nextglobal++; + } + old_idx++; + } + } + else + { + Elf32_Sym *oldsymtab = (Elf32_Sym *)SYMbuf->buf; + Elf32_Sym *symtabend = oldsymtab+symbol_idx; + + symtab = util_malloc(sizeof(Elf32_Sym),symbol_idx); + + Elf32_Sym *sl = (Elf32_Sym *)symtab; + Elf32_Sym *sg = sl + local_cnt; + + int old_idx = 0; + for(Elf32_Sym *s = oldsymtab; s != symtabend; s++) + { // reorder symbol and map new #s to old + int bind = ELF_ST_BIND(s->st_info); + if (bind == STB_LOCAL) + { + *sl++ = *s; + sym_map[old_idx] = nextlocal++; + } + else + { + *sg++ = *s; + sym_map[old_idx] = nextglobal++; + } + old_idx++; + } + } + + // Renumber the relocations + for (int i = 1; i <= seg_count; i++) + { // Map indicies in the segment table + seg_data *pseg = SegData[i]; + pseg->SDsymidx = sym_map[pseg->SDsymidx]; + if (pseg->SDrel) + { + if (I64) + { + Elf64_Rela *rel = (Elf64_Rela *) pseg->SDrel->buf; + for (int r = 0; r < pseg->SDrelcnt; r++) + { + unsigned t = ELF64_R_TYPE(rel->r_info); + unsigned si = ELF64_R_SYM(rel->r_info); + assert(si < symbol_idx); + rel->r_info = ELF64_R_INFO(sym_map[si],t); + rel++; + } + } + else + { + Elf32_Rel *rel = (Elf32_Rel *) pseg->SDrel->buf; + assert(pseg->SDrelcnt == pseg->SDrel->size() / sizeof(Elf32_Rel)); + for (int r = 0; r < pseg->SDrelcnt; r++) + { + unsigned t = ELF32_R_TYPE(rel->r_info); + unsigned si = ELF32_R_IDX(rel->r_info); + assert(si < symbol_idx); + rel->r_info = ELF32_R_INFO(sym_map[si],t); + rel++; + } + } + } + }; + + return symtab; +} + + +/*************************** + * Fixup and terminate object file. + */ + +void obj_termfile() +{ + //dbg_printf("obj_termfile\n"); + if (configv.addlinenumbers) + { + dwarf_termmodule(); + } +} + +/********************************* + * Terminate package. + */ + +void obj_term() +{ + //printf("obj_term()\n"); +#if SCPP + if (!errcnt) +#endif + { + outfixlist(); // backpatches + } + + if (configv.addlinenumbers) + { + dwarf_termfile(); + } + +#if SCPP + if (errcnt) + return; +#endif + + // Write out the bytes for the header + static const char elf_string32[EI_NIDENT] = + { + ELFMAG0,ELFMAG1,ELFMAG2,ELFMAG3, + ELFCLASS32, // EI_CLASS + ELFDATA2LSB, // EI_DATA + EV_CURRENT, // EI_VERSION + ELFOSABI_LINUX,0, // EI_OSABI,EI_ABIVERSION + 0,0,0,0,0,0,0 + }; + static const char elf_string64[EI_NIDENT] = + { + ELFMAG0,ELFMAG1,ELFMAG2,ELFMAG3, + ELFCLASS64, // EI_CLASS + ELFDATA2LSB, // EI_DATA + EV_CURRENT, // EI_VERSION + ELFOSABI_LINUX,0, // EI_OSABI,EI_ABIVERSION + 0,0,0,0,0,0,0 + }; + fobjbuf->write(I64 ? elf_string64 : elf_string32, EI_NIDENT); + + long foffset; + Elf32_Shdr *sechdr; + seg_data *seg; + void *symtab = elf_renumbersyms(); + FILE *fd = NULL; + + // Output the ELF Header + // The section header is build in the static variable elf_header + static Elf64_Ehdr elf_header = + { + ET_REL, // e_type + EM_X86_64, // e_machine + EV_CURRENT, // e_version + 0, // e_entry + 0, // e_phoff + 0, // e_shoff + 0, // e_flags + sizeof(Elf64_Ehdr) + EI_NIDENT, // e_ehsize + sizeof(Elf64_Phdr), // e_phentsize + 0, // e_phnum + sizeof(Elf64_Shdr), // e_shentsize + 0, // e_shnum + 0 // e_shstrndx + }; + int hdrsize = I64 ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Hdr); + + elf_header.e_shnum = section_cnt; + elf_header.e_shstrndx = SHI_SECNAMES; + fobjbuf->writezeros(hdrsize); + + // Walk through sections determining size and file offsets + // Sections will be output in the following order + // Null segment + // For each Code/Data Segment + // code/data to load + // relocations without addens + // .bss + // notes + // comments + // section names table + // symbol table + // strings table + + foffset = EI_NIDENT + hdrsize; // start after header + // section header table at end + + // + // First output individual section data associate with program + // code and data + // + //printf("Setup offsets and sizes foffset %d\n\tsection_cnt %d, seg_count %d\n",foffset,section_cnt,seg_count); + for (int i=1; i<= seg_count; i++) + { + seg = SegData[i]; + sechdr = MAP_SEG2SEC(i); // corresponding section + foffset = elf_align(fd,sechdr->sh_addralign,foffset); + if (i == UDATA) // 0, BSS never allocated + { // but foffset as if it has + sechdr->sh_offset = foffset; + sechdr->sh_size = seg->SDoffset; + // accumulated size + continue; + } + else if (sechdr->sh_type == SHT_NOBITS) // .tbss never allocated + { + sechdr->sh_offset = foffset; + sechdr->sh_size = seg->SDoffset; + // accumulated size + continue; + } + else if (!seg->SDbuf) + continue; // For others leave sh_offset as 0 + + sechdr->sh_offset = foffset; + //printf("\tsection name %d,",sechdr->sh_name); + if (seg->SDbuf && seg->SDbuf->size()) + { + //printf(" - size %d\n",seg->SDbuf->size()); + sechdr->sh_size = seg->SDbuf->size(); + fobjbuf->write(seg->SDbuf->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + } + //printf(" assigned offset %d, size %d\n",foffset,sechdr->sh_size); + } + + // + // Next output any notes or comments + // + if (note_data) + { + sechdr = &SecHdrTab[secidx_note]; // Notes + sechdr->sh_size = note_data->size(); + sechdr->sh_offset = foffset; + fobjbuf->write(note_data->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + } + + if (comment_data) + { + sechdr = &SecHdrTab[SHI_COM]; // Comments + sechdr->sh_size = comment_data->size(); + sechdr->sh_offset = foffset; + fobjbuf->write(comment_data->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + } + + // + // Then output string table for section names + // + sechdr = &SecHdrTab[SHI_SECNAMES]; // Section Names + sechdr->sh_size = section_names->size(); + sechdr->sh_offset = foffset; + //dbg_printf("section names offset %d\n",foffset); + fobjbuf->write(section_names->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + + // + // Symbol table and string table for symbols next + // + //dbg_printf("output symbol table size %d\n",SYMbuf->size()); + sechdr = &SecHdrTab[SHI_SYMTAB]; // Symbol Table + sechdr->sh_size = SYMbuf->size(); + sechdr->sh_entsize = I64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym); + sechdr->sh_link = SHI_STRINGS; + sechdr->sh_info = local_cnt; + foffset = elf_align(fd,4,foffset); + sechdr->sh_offset = foffset; + fobjbuf->write(symtab, sechdr->sh_size); + foffset += sechdr->sh_size; + util_free(symtab); + + //dbg_printf("output section strings size 0x%x,offset 0x%x\n",symtab_strings->size(),foffset); + sechdr = &SecHdrTab[SHI_STRINGS]; // Symbol Strings + sechdr->sh_size = symtab_strings->size(); + sechdr->sh_offset = foffset; + fobjbuf->write(symtab_strings->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + + // + // Now the relocation data for program code and data sections + // + foffset = elf_align(fd,4,foffset); + //dbg_printf("output relocations size 0x%x, foffset 0x%x\n",section_names->size(),foffset); + for (int i=1; i<= seg_count; i++) + { + seg = SegData[i]; + if (!seg->SDbuf) + { +// sechdr = &SecHdrTab[seg->SDrelidx]; +// if (I64 && sechdr->sh_type == SHT_RELA) +// sechdr->sh_offset = foffset; + continue; // 0, BSS never allocated + } + if (seg->SDrel && seg->SDrel->size()) + { + assert(seg->SDrelidx); + sechdr = &SecHdrTab[seg->SDrelidx]; + sechdr->sh_size = seg->SDrel->size(); + sechdr->sh_offset = foffset; + if (I64) + { + assert(seg->SDrelcnt == seg->SDrel->size() / sizeof(Elf64_Rela)); +#ifdef DEBUG + for (size_t i = 0; i < seg->SDrelcnt; ++i) + { Elf64_Rela *p = ((Elf64_Rela *)seg->SDrel->buf) + i; + if (ELF64_R_TYPE(p->r_info) == R_X86_64_64) + assert(*(Elf64_Xword *)(seg->SDbuf->buf + p->r_offset) == 0); + } +#endif + } + else + assert(seg->SDrelcnt == seg->SDrel->size() / sizeof(Elf32_Rel)); + fobjbuf->write(seg->SDrel->buf, sechdr->sh_size); + foffset += sechdr->sh_size; + } + } + + // + // Finish off with the section header table + // + elf_header.e_shoff = foffset; // remember location in elf header + //dbg_printf("output section header table\n"); + + // Output the completed Section Header Table + if (I64) + { // Translate section headers to 64 bits + int sz = section_cnt * sizeof(Elf64_Shdr); + fobjbuf->reserve(sz); + for (int i = 0; i < section_cnt; i++) + { + Elf32_Shdr *p = SecHdrTab + i; + Elf64_Shdr s; + s.sh_name = p->sh_name; + s.sh_type = p->sh_type; + s.sh_flags = p->sh_flags; + s.sh_addr = p->sh_addr; + s.sh_offset = p->sh_offset; + s.sh_size = p->sh_size; + s.sh_link = p->sh_link; + s.sh_info = p->sh_info; + s.sh_addralign = p->sh_addralign; + s.sh_entsize = p->sh_entsize; + fobjbuf->write(&s, sizeof(s)); + } + foffset += sz; + } + else + { + fobjbuf->write(SecHdrTab, section_cnt * sizeof(Elf32_Shdr)); + foffset += section_cnt * sizeof(Elf32_Shdr); + } + + // + // Now that we have correct offset to section header table, e_shoff, + // go back and re-output the elf header + // + fobjbuf->position(EI_NIDENT, hdrsize); + if (I64) + { + fobjbuf->write(&elf_header, hdrsize); + } + else + { Elf32_Hdr h; + // Transfer to 32 bit header + h.e_type = elf_header.e_type; + h.e_machine = EM_386; + h.e_version = elf_header.e_version; + h.e_entry = elf_header.e_entry; + h.e_phoff = elf_header.e_phoff; + h.e_shoff = elf_header.e_shoff; + h.e_flags = elf_header.e_flags; + h.e_ehsize = sizeof(Elf32_Hdr) + EI_NIDENT; + h.e_phentsize = sizeof(elf_pht); + h.e_phnum = elf_header.e_phnum; + h.e_shentsize = sizeof(Elf32_Shdr); + h.e_shnum = elf_header.e_shnum; + h.e_shstrndx = elf_header.e_shstrndx; + fobjbuf->write(&h, hdrsize); + } + fobjbuf->position(foffset, 0); + fobjbuf->flush(); +} + +/***************************** + * Line number support. + */ + +/*************************** + * Record file and line number at segment and offset. + * The actual .debug_line segment is put out by dwarf_termfile(). + * Input: + * cseg current code segment + */ + +void objlinnum(Srcpos srcpos, targ_size_t offset) +{ + if (srcpos.Slinnum == 0) + return; + +#if 0 +#if MARS || SCPP + printf("objlinnum(cseg=%d, offset=0x%lx) ", cseg, offset); +#endif + srcpos.print(""); +#endif + +#if MARS + if (!srcpos.Sfilename) + return; +#endif +#if SCPP + if (!srcpos.Sfilptr) + return; + sfile_debug(&srcpos_sfile(srcpos)); + Sfile *sf = *srcpos.Sfilptr; +#endif + + size_t i; + seg_data *seg = SegData[cseg]; + + // Find entry i in SDlinnum_data[] that corresponds to srcpos filename + for (i = 0; 1; i++) + { + if (i == seg->SDlinnum_count) + { // Create new entry + if (seg->SDlinnum_count == seg->SDlinnum_max) + { // Enlarge array + unsigned newmax = seg->SDlinnum_max * 2 + 1; + //printf("realloc %d\n", newmax * sizeof(linnum_data)); + seg->SDlinnum_data = (linnum_data *)mem_realloc( + seg->SDlinnum_data, newmax * sizeof(linnum_data)); + memset(seg->SDlinnum_data + seg->SDlinnum_max, 0, + (newmax - seg->SDlinnum_max) * sizeof(linnum_data)); + seg->SDlinnum_max = newmax; + } + seg->SDlinnum_count++; +#if MARS + seg->SDlinnum_data[i].filename = srcpos.Sfilename; +#endif +#if SCPP + seg->SDlinnum_data[i].filptr = sf; +#endif + break; + } +#if MARS + if (seg->SDlinnum_data[i].filename == srcpos.Sfilename) +#endif +#if SCPP + if (seg->SDlinnum_data[i].filptr == sf) +#endif + break; + } + + linnum_data *ld = &seg->SDlinnum_data[i]; +// printf("i = %d, ld = x%x\n", i, ld); + if (ld->linoff_count == ld->linoff_max) + { + if (!ld->linoff_max) + ld->linoff_max = 8; + ld->linoff_max *= 2; + ld->linoff = (unsigned (*)[2])mem_realloc(ld->linoff, ld->linoff_max * sizeof(unsigned) * 2); + } + ld->linoff[ld->linoff_count][0] = srcpos.Slinnum; + ld->linoff[ld->linoff_count][1] = offset; + ld->linoff_count++; +} + + +/******************************* + * Set start address + */ + +void obj_startaddress(Symbol *s) +{ + //dbg_printf("obj_startaddress(Symbol *%s)\n",s->Sident); + //obj.startaddress = s; +} + +/******************************* + * Output library name. + * Output: + */ + +void obj_includelib(const char *name) +{ + //dbg_printf("obj_includelib(name *%s)\n",name); +} + +/************************** + * Embed string in executable. + */ + +void obj_exestr(const char *p) +{ + //dbg_printf("obj_exestr(char *%s)\n",p); +} + +/************************** + * Embed string in obj. + */ + +void obj_user(const char *p) +{ + //dbg_printf("obj_user(char *%s)\n",p); +} + +/******************************* + * Output a weak extern record. + */ + +void obj_wkext(Symbol *s1,Symbol *s2) +{ + //dbg_printf("obj_wkext(Symbol *%s,Symbol *s2)\n",s1->Sident,s2->Sident); +} + +/******************************* + * Output file name record. + * + * Currently assumes that obj_filename will not be called + * twice for the same file. + */ + +void obj_filename(const char *modname) +{ + //dbg_printf("obj_filename(char *%s)\n",modname); + unsigned strtab_idx = elf_addstr(symtab_strings,modname); + elf_addsym(strtab_idx,0,0,STT_FILE,STB_LOCAL,SHT_ABS); +} + +/******************************* + * Embed compiler version in .obj file. + */ + +void obj_compiler() +{ + //dbg_printf("obj_compiler\n"); + comment_data = new Outbuffer(); + comment_data->write(compiler,sizeof(compiler)); + //dbg_printf("Comment data size %d\n",comment_data->size()); +} + + +//#if NEWSTATICDTOR + +/************************************** + * Symbol is the function that calls the static constructors. + * Put a pointer to it into a special segment that the startup code + * looks at. + * Input: + * s static constructor function + * dtor !=0 if leave space for static destructor + * seg 1: user + * 2: lib + * 3: compiler + */ + +void obj_staticctor(Symbol *s,int dtor,int none) +{ +// Static constructors and destructors + IDXSEC seg; + Outbuffer *buf; + + //dbg_printf("obj_staticctor(%s) offset %x\n",s->Sident,s->Soffset); + //symbol_print(s); + s->Sseg = seg = + elf_getsegment(".ctors", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE, 4); + buf = SegData[seg]->SDbuf; + if (I64) + buf->write64(s->Soffset); + else + buf->write32(s->Soffset); + elf_addrel(seg,SegData[seg]->SDoffset,I64 ? R_X86_64_64 : RI_TYPE_SYM32,STI_TEXT,0); + SegData[seg]->SDoffset = buf->size(); +} + +/************************************** + * Symbol is the function that calls the static destructors. + * Put a pointer to it into a special segment that the exit code + * looks at. + * Input: + * s static destructor function + */ + +void obj_staticdtor(Symbol *s) +{ + IDXSEC seg; + Outbuffer *buf; + + //dbg_printf("obj_staticdtor(%s) offset %x\n",s->Sident,s->Soffset); + //symbol_print(s); + seg = elf_getsegment(".dtors", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE, 4); + buf = SegData[seg]->SDbuf; + if (I64) + buf->write64(s->Soffset); + else + buf->write32(s->Soffset); + elf_addrel(seg,SegData[seg]->SDoffset,I64 ? R_X86_64_64 : RI_TYPE_SYM32,s->Sxtrnnum,0); + SegData[seg]->SDoffset = buf->size(); +} + +//#else + +/*************************************** + * Stuff pointer to function in its own segment. + * Used for static ctor and dtor lists. + */ + +void obj_funcptr(Symbol *s) +{ + //dbg_printf("obj_funcptr(%s) \n",s->Sident); +} + +//#endif + +/*************************************** + * Stuff the following data in a separate segment: + * pointer to function + * pointer to ehsym + * length of function + */ + +void obj_ehtables(Symbol *sfunc,targ_size_t size,Symbol *ehsym) +{ + //dbg_printf("obj_ehtables(%s) \n",sfunc->Sident); + + symbol *ehtab_entry = symbol_generate(SCstatic,type_alloc(TYint)); + symbol_keep(ehtab_entry); + elf_getsegment(".deh_beg", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + int seg = elf_getsegment(".deh_eh", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + ehtab_entry->Sseg = seg; + Outbuffer *buf = SegData[seg]->SDbuf; + elf_getsegment(".deh_end", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + ehtab_entry->Stype->Tmangle = mTYman_c; + ehsym->Stype->Tmangle = mTYman_c; + + assert(sfunc->Sxtrnnum && sfunc->Sseg); + assert(ehsym->Sxtrnnum && ehsym->Sseg); + if (I64) + { + elf_addrel(seg, buf->size(), R_X86_64_64, MAP_SEG2SYMIDX(sfunc->Sseg), sfunc->Soffset); + buf->write64(0); + + elf_addrel(seg, buf->size(), R_X86_64_64, MAP_SEG2SYMIDX(ehsym->Sseg), ehsym->Soffset); + buf->write64(0); + + buf->write64(sfunc->Ssize); + } + else + { + elf_addrel(seg, buf->size(), RI_TYPE_SYM32, MAP_SEG2SYMIDX(sfunc->Sseg), 0); + buf->write32(sfunc->Soffset); + + elf_addrel(seg, buf->size(), RI_TYPE_SYM32, MAP_SEG2SYMIDX(ehsym->Sseg), 0); + buf->write32(ehsym->Soffset); + + buf->write32(sfunc->Ssize); + } +} + +/********************************************* + * Put out symbols that define the beginning/end of the .deh_eh section. + */ + +void obj_ehsections() +{ + int sec = elf_getsegment(".deh_beg", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + //obj_bytes(sec, 0, 4, NULL); + + IDXSTR namidx = elf_addstr(symtab_strings,"_deh_beg"); + elf_addsym(namidx, 0, 4, STT_OBJECT, STB_GLOBAL, MAP_SEG2SECIDX(sec)); + //elf_addsym(namidx, 0, 4, STT_OBJECT, STB_GLOBAL, MAP_SEG2SECIDX(sec)); + + elf_getsegment(".deh_eh", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + + sec = elf_getsegment(".deh_end", NULL, SHT_PROGDEF, SHF_ALLOC, NPTRSIZE); + namidx = elf_addstr(symtab_strings,"_deh_end"); + elf_addsym(namidx, 0, 4, STT_OBJECT, STB_GLOBAL, MAP_SEG2SECIDX(sec)); + + obj_tlssections(); +} + +/********************************************* + * Put out symbols that define the beginning/end of the thread local storage sections. + */ + +void obj_tlssections() +{ + IDXSTR namidx; + int align = I64 ? 16 : 4; + + int sec = elf_getsegment(".tdata", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE|SHF_TLS, align); + obj_bytes(sec, 0, align, NULL); + + namidx = elf_addstr(symtab_strings,"_tlsstart"); + elf_addsym(namidx, 0, align, STT_TLS, STB_GLOBAL, MAP_SEG2SECIDX(sec)); + + elf_getsegment(".tdata.", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE|SHF_TLS, align); + + sec = elf_getsegment(".tcommon", NULL, SHT_NOBITS, SHF_ALLOC|SHF_WRITE|SHF_TLS, align); + namidx = elf_addstr(symtab_strings,"_tlsend"); + elf_addsym(namidx, 0, align, STT_TLS, STB_GLOBAL, MAP_SEG2SECIDX(sec)); +} + +/********************************* + * Setup for Symbol s to go into a COMDAT segment. + * Output (if s is a function): + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * "segment index" of COMDAT + */ + +STATIC void setup_comdat(Symbol *s) +{ + const char *prefix; + int type; + int flags; + int align = 4; + + //printf("obj_comdat(Symbol *%s\n",s->Sident); + //symbol_print(s); + symbol_debug(s); + if (tyfunc(s->ty())) + { + //s->Sfl = FLcode; // was FLoncecode + //prefix = ".gnu.linkonce.t"; // doesn't work, despite documentation + prefix = ".text."; // undocumented, but works + type = SHT_PROGDEF; + flags = SHF_ALLOC|SHF_EXECINSTR; + } + else if ((s->ty() & mTYLINK) == mTYthread) + { + /* Ensure that ".tdata" precedes any other .tdata. section, as the ld + * linker script fails to work right. + */ + if (I64) + align = 16; + elf_getsegment(".tdata", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE|SHF_TLS, align); + + s->Sfl = FLtlsdata; + prefix = ".tdata."; + type = SHT_PROGDEF; + flags = SHF_ALLOC|SHF_WRITE|SHF_TLS; + } + else + { + if (I64) + align = 16; + s->Sfl = FLdata; + //prefix = ".gnu.linkonce.d."; + prefix = ".data."; + type = SHT_PROGDEF; + flags = SHF_ALLOC|SHF_WRITE; + } + + s->Sseg = elf_getsegment(prefix, cpp_mangle(s), type, flags, align); + // find or create new segment + SegData[s->Sseg]->SDsym = s; +} + +int obj_comdat(Symbol *s) +{ + setup_comdat(s); + if (s->Sfl == FLdata || s->Sfl == FLtlsdata) + { + objpubdef(s->Sseg,s,0); + searchfixlist(s); // backpatch any refs to this symbol + } + return s->Sseg; +} + +int obj_comdatsize(Symbol *s, targ_size_t symsize) +{ + setup_comdat(s); + if (s->Sfl == FLdata || s->Sfl == FLtlsdata) + { + objpubdefsize(s->Sseg,s,0,symsize); + searchfixlist(s); // backpatch any refs to this symbol + } + return s->Sseg; +} + +/******************************** + * Get a segment for a segment name. + * Input: + * name name of segment, if NULL then revert to default name + * suffix append to name + * align alignment + * Returns: + * segment index of found or newly created segment + */ + +int elf_getsegment2(IDXSEC shtidx, IDXSYM symidx, IDXSEC relidx) +{ + //printf("SegData = %p\n", SegData); + int seg = ++seg_count; + if (seg_count >= seg_max) + { // need more room in segment table + seg_max += OB_SEG_INC; + SegData = (seg_data **)mem_realloc(SegData,seg_max * sizeof(seg_data *)); + memset(&SegData[seg_count], 0, (seg_max - seg_count) * sizeof(seg_data *)); + } + assert(seg_count < seg_max); + if (!SegData[seg]) + { SegData[seg] = (seg_data *)mem_calloc(sizeof(seg_data)); + //printf("test2: SegData[%d] = %p\n", seg, SegData[seg]); + } + + seg_data *pseg = SegData[seg]; + pseg->SDseg = seg; + pseg->SDshtidx = shtidx; + pseg->SDoffset = 0; + if (pseg->SDbuf) + pseg->SDbuf->setsize(0); + else + { if (SecHdrTab[shtidx].sh_type != SHT_NOBITS) + { pseg->SDbuf = new Outbuffer(OB_XTRA_STR); + pseg->SDbuf->reserve(1024); + } + } + if (pseg->SDrel) + pseg->SDrel->setsize(0); + pseg->SDsymidx = symidx; + pseg->SDrelidx = relidx; + pseg->SDrelmaxoff = 0; + pseg->SDrelindex = 0; + pseg->SDrelcnt = 0; + pseg->SDshtidxout = 0; + pseg->SDsym = NULL; + pseg->SDaranges_offset = 0; + pseg->SDlinnum_count = 0; + return seg; +} + +int elf_getsegment(const char *name, const char *suffix, int type, int flags, + int align) +{ + //printf("elf_getsegment(%s,%s,flags %x, align %d)\n",name,suffix,flags,align); + + // Add name~suffix to the section_names table + IDXSTR namidx = section_names->size(); + section_names->writeString(name); + if (suffix) + { // Append suffix string + section_names->setsize(section_names->size() - 1); // back up over terminating 0 + section_names->writeString(suffix); + } + IDXSTR *pidx = (IDXSTR *)section_names_hashtable->get(&namidx); + if (*pidx) + { // this section name already exists + section_names->setsize(namidx); // remove addition + namidx = *pidx; + for (int seg = CODE; seg <= seg_count; seg++) + { // should be in segment table + if (MAP_SEG2SEC(seg)->sh_name == namidx) + { + return seg; // found section for segment + } + } + assert(0); // but it's not a segment + // FIX - should be an error message conflict with section names + } + *pidx = namidx; + + //dbg_printf("\tNew segment - %d size %d\n", seg,SegData[seg]->SDbuf); + IDXSEC shtidx = elf_newsection2(namidx,type,flags,0,0,0,0,0,0,0); + SecHdrTab[shtidx].sh_addralign = align; + IDXSYM symidx = elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, shtidx); + int seg = elf_getsegment2(shtidx, symidx, 0); + //printf("-elf_getsegment() = %d\n", seg); + return seg; +} + +/******************************** + * Define a new code segment. + * Input: + * name name of segment, if NULL then revert to default + * suffix 0 use name as is + * 1 append "_TEXT" to name + * Output: + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * segment index of newly created code segment + */ + +int obj_codeseg(char *name,int suffix) +{ + int seg; + const char *sfx; + + //dbg_printf("obj_codeseg(%s,%x)\n",name,suffix); + + sfx = (suffix) ? "_TEXT" : NULL; + + if (!name) // returning to default code segment + { + if (cseg != CODE) // not the current default + { + SegData[cseg]->SDoffset = Coffset; + Coffset = SegData[CODE]->SDoffset; + cseg = CODE; + } + return cseg; + } + + seg = elf_getsegment(name, sfx, SHT_PROGDEF, SHF_ALLOC|SHF_EXECINSTR, 4); + // find or create code segment + + cseg = seg; // new code segment index + Coffset = 0; + + return seg; +} + +/********************************* + * Define segments for Thread Local Storage. + * Here's what the elf tls spec says: + * Field .tbss .tdata + * sh_name .tbss .tdata + * sh_type SHT_NOBITS SHT_PROGBITS + * sh_flags SHF_ALLOC|SHF_WRITE| SHF_ALLOC|SHF_WRITE| + * SHF_TLS SHF_TLS + * sh_addr virtual addr of section virtual addr of section + * sh_offset 0 file offset of initialization image + * sh_size size of section size of section + * sh_link SHN_UNDEF SHN_UNDEF + * sh_info 0 0 + * sh_addralign alignment of section alignment of section + * sh_entsize 0 0 + * We want _tlsstart and _tlsend to bracket all the D tls data. + * The default linker script (ld -verbose) says: + * .tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) } + * .tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } + * so if we assign names: + * _tlsstart .tdata + * symbols .tdata. + * symbols .tbss + * _tlsend .tbss. + * this should work. + * Don't care about sections emitted by other languages, as we presume they + * won't be storing D gc roots in their tls. + * Output: + * seg_tlsseg set to segment number for TLS segment. + * Returns: + * segment for TLS segment + */ + +seg_data *obj_tlsseg() +{ + /* Ensure that ".tdata" precedes any other .tdata. section, as the ld + * linker script fails to work right. + */ + elf_getsegment(".tdata", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE|SHF_TLS, 4); + + static const char tlssegname[] = ".tdata."; + //dbg_printf("obj_tlsseg(\n"); + + if (seg_tlsseg == UNKNOWN) + { + seg_tlsseg = elf_getsegment(tlssegname, NULL, SHT_PROGDEF, + SHF_ALLOC|SHF_WRITE|SHF_TLS, I64 ? 16 : 4); + } + return SegData[seg_tlsseg]; +} + + +/********************************* + * Define segments for Thread Local Storage. + * Output: + * seg_tlsseg_bss set to segment number for TLS segment. + * Returns: + * segment for TLS segment + */ + +seg_data *obj_tlsseg_bss() +{ + static const char tlssegname[] = ".tbss"; + //dbg_printf("obj_tlsseg_bss(\n"); + + if (seg_tlsseg_bss == UNKNOWN) + { + seg_tlsseg_bss = elf_getsegment(tlssegname, NULL, SHT_NOBITS, + SHF_ALLOC|SHF_WRITE|SHF_TLS, I64 ? 16 : 4); + } + return SegData[seg_tlsseg_bss]; +} + + +/******************************* + * Output an alias definition record. + */ + +void obj_alias(const char *n1,const char *n2) +{ + dbg_printf("obj_alias(%s,%s)\n",n1,n2); + assert(0); +#if NOT_DONE + char *buffer = (char *) alloca(strlen(n1) + strlen(n2) + 2 * ONS_OHD); + unsigned len = obj_namestring(buffer,n1); + len += obj_namestring(buffer + len,n2); + objrecord(ALIAS,buffer,len); +#endif +} + +char *unsstr(unsigned value) +{ + static char buffer[64]; + + sprintf(buffer, "%d", value); + return buffer; +} + +/******************************* + * Mangle a name. + * Returns: + * mangled name + */ + +char *obj_mangle2(Symbol *s,char *dest) +{ + char *name; + + //dbg_printf("obj_mangle('%s'), mangle = x%x\n",s->Sident,type_mangle(s->Stype)); + symbol_debug(s); + assert(dest); +#if SCPP + name = CPP ? cpp_mangle(s) : s->Sident; +#elif MARS + name = cpp_mangle(s); +#else + name = s->Sident; +#endif + size_t len = strlen(name); // # of bytes in name + //dbg_printf("len %d\n",len); + switch (type_mangle(s->Stype)) + { + case mTYman_pas: // if upper case + case mTYman_for: + if (len >= DEST_LEN) + dest = (char *)mem_malloc(len + 1); + memcpy(dest,name,len + 1); // copy in name and ending 0 + for (int i = 0; 1; i++) + { char c = dest[i]; + if (!c) + break; + if (c >= 'a' && c <= 'z') + dest[i] = c + 'A' - 'a'; + } + break; + case mTYman_std: +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (tyfunc(s->ty()) && !variadic(s->Stype)) +#else + if (!(config.flags4 & CFG4oldstdmangle) && + config.exe == EX_NT && tyfunc(s->ty()) && + !variadic(s->Stype)) +#endif + { + char *pstr = unsstr(type_paramsize(s->Stype)); + size_t pstrlen = strlen(pstr); + size_t destlen = len + 1 + pstrlen + 1; + + if (destlen > DEST_LEN) + dest = (char *)mem_malloc(destlen); + memcpy(dest,name,len); + dest[len] = '@'; + memcpy(dest + 1 + len, pstr, pstrlen + 1); + break; + } + case mTYman_cpp: + case mTYman_c: + case mTYman_d: + case mTYman_sys: + case 0: + if (len >= DEST_LEN) + dest = (char *)mem_malloc(len + 1); + memcpy(dest,name,len+1);// copy in name and trailing 0 + break; + + default: +#ifdef DEBUG + printf("mangling %x\n",type_mangle(s->Stype)); + symbol_print(s); +#endif + printf("%d\n", type_mangle(s->Stype)); + assert(0); + } + //dbg_printf("\t %s\n",dest); + return dest; +} + +/******************************* + * Export a function name. + */ + +void obj_export(Symbol *s,unsigned argsize) +{ + //dbg_printf("obj_export(%s,%d)\n",s->Sident,argsize); +} + +/******************************* + * Update data information about symbol + * align for output and assign segment + * if not already specified. + * + * Input: + * sdata data symbol + * datasize output size + * seg default seg if not known + * Returns: + * actual seg + */ + +int elf_data_start(Symbol *sdata, targ_size_t datasize, int seg) +{ + targ_size_t alignbytes; + //printf("elf_data_start(%s,size %llx,seg %d)\n",sdata->Sident,datasize,seg); + //symbol_print(sdata); + + if (sdata->Sseg == UNKNOWN) // if we don't know then there + sdata->Sseg = seg; // wasn't any segment override + else + seg = sdata->Sseg; + targ_size_t offset = Offset(seg); + alignbytes = align(datasize, offset) - offset; + if (alignbytes) + obj_lidata(seg, offset, alignbytes); + sdata->Soffset = offset + alignbytes; + return seg; +} + +/******************************* + * Update function info before codgen + * + * If code for this function is in a different segment + * than the current default in cseg, switch cseg to new segment. + */ + +void elf_func_start(Symbol *sfunc) +{ + //dbg_printf("elf_func_start(%s)\n",sfunc->Sident); + symbol_debug(sfunc); + + if ((tybasic(sfunc->ty()) == TYmfunc) && (sfunc->Sclass == SCextern)) + { // create a new code segment + sfunc->Sseg = + elf_getsegment(".gnu.linkonce.t.", cpp_mangle(sfunc), SHT_PROGDEF, SHF_ALLOC|SHF_EXECINSTR,4); + + } + else if (sfunc->Sseg == UNKNOWN) + sfunc->Sseg = CODE; + //dbg_printf("sfunc->Sseg %d CODE %d cseg %d Coffset %d\n",sfunc->Sseg,CODE,cseg,Coffset); + cseg = sfunc->Sseg; + assert(cseg == CODE || cseg > COMD); + objpubdef(cseg, sfunc, Coffset); + sfunc->Soffset = Coffset; + + if (config.fulltypes) + dwarf_func_start(sfunc); +} + +/******************************* + * Update function info after codgen + */ + +void elf_func_term(Symbol *sfunc) +{ + //dbg_printf("elf_func_term(%s) offset %x, Coffset %x symidx %d\n", +// sfunc->Sident, sfunc->Soffset,Coffset,sfunc->Sxtrnnum); + + // fill in the function size + if (I64) + SymbolTable64[sfunc->Sxtrnnum].st_size = Coffset - sfunc->Soffset; + else + SymbolTable[sfunc->Sxtrnnum].st_size = Coffset - sfunc->Soffset; + if (config.fulltypes) + dwarf_func_term(sfunc); +} + +/******************************** + * Output a public definition. + * Input: + * seg = segment index that symbol is defined in + * s -> symbol + * offset = offset of name within segment + */ + +void objpubdef(int seg, Symbol *s, targ_size_t offset) +{ + const targ_size_t symsize= + tyfunc(s->ty()) ? Offset(s->Sseg) - offset : type_size(s->Stype); + objpubdefsize(seg, s, offset, symsize); +} + +/******************************** + * Output a public definition. + * Input: + * seg = segment index that symbol is defined in + * s -> symbol + * offset = offset of name within segment + * symsize size of symbol + */ + +void objpubdefsize(int seg, Symbol *s, targ_size_t offset, targ_size_t symsize) +{ + int bind; + switch (s->Sclass) + { + case SCglobal: + case SCinline: + bind = STB_GLOBAL; + break; + case SCcomdat: + case SCcomdef: + bind = STB_WEAK; + break; + default: + bind = STB_LOCAL; + break; + } + +#if 0 + //printf("\nobjpubdef(%d,%s,%d)\n",seg,s->Sident,offset); + //symbol_print(s); +#endif + + symbol_debug(s); + IDXSTR namidx = elf_addmangled(s); + //printf("\tnamidx %d,section %d\n",namidx,MAP_SEG2SECIDX(seg)); + if (tyfunc(s->ty())) + { + s->Sxtrnnum = elf_addsym(namidx, offset, symsize, + STT_FUNC, bind, MAP_SEG2SECIDX(seg)); + } + else + { + const unsigned typ = (s->ty() & mTYthread) ? STT_TLS : STT_OBJECT; + s->Sxtrnnum = elf_addsym(namidx, offset, symsize, + typ, bind, MAP_SEG2SECIDX(seg)); + } + fflush(NULL); +} + +/******************************* + * Output an external symbol for name. + * Input: + * name Name to do EXTDEF on + * (Not to be mangled) + * Returns: + * Symbol table index of the definition + * NOTE: Numbers will not be linear. + */ + +int objextern(const char *name) +{ + //dbg_printf("objextdef('%s')\n",name); + assert(name); + IDXSTR namidx = elf_addstr(symtab_strings,name); + IDXSYM symidx = elf_addsym(namidx, 0, 0, STT_NOTYPE, STB_GLOBAL, SHT_UNDEF); + return symidx; +} + +int objextdef(const char *name) +{ + return objextern(name); +} + +/******************************* + * Output an external for existing symbol. + * Input: + * s Symbol to do EXTDEF on + * (Name is to be mangled) + * Returns: + * Symbol table index of the definition + * NOTE: Numbers will not be linear. + */ + +int objextern(Symbol *s) +{ + int symtype,sectype; + unsigned size; + + //dbg_printf("objextern('%s') %x\n",s->Sident,s->Svalue); + symbol_debug(s); + IDXSTR namidx = elf_addmangled(s); + +#if SCPP + if (s->Sscope && !tyfunc(s->ty())) + { + symtype = STT_OBJECT; + sectype = SHT_COMMON; + size = type_size(s->Stype); + } + else +#endif + { + symtype = STT_NOTYPE; + sectype = SHT_UNDEF; + size = 0; + } + if (s->ty() & mTYthread) + { + //printf("objextern('%s') %x TLS\n",s->Sident,s->Svalue); + symtype = STT_TLS; + } + + s->Sxtrnnum = elf_addsym(namidx, size, size, symtype, + /*(s->ty() & mTYweak) ? STB_WEAK : */STB_GLOBAL, sectype); + return s->Sxtrnnum; + +} + +/******************************* + * Output a common block definition. + * Input: + * p -> external identifier + * size size in bytes of each elem + * count number of elems + * Returns: + * Symbol table index for symbol + */ + +int obj_comdef(Symbol *s,targ_size_t size,targ_size_t count) +{ + //printf("obj_comdef('%s',%d,%d)\n",s->Sident,size,count); + symbol_debug(s); + + int align = I64 ? 16 : 4; + if (s->ty() & mTYthread) + { + s->Sseg = elf_getsegment(".tbss.", cpp_mangle(s), + SHT_NOBITS, SHF_ALLOC|SHF_WRITE|SHF_TLS, align); + s->Sfl = FLtlsdata; + SegData[s->Sseg]->SDsym = s; + SegData[s->Sseg]->SDoffset += size * count; + objpubdef(s->Sseg, s, 0); + searchfixlist(s); + return s->Sseg; + } + else + { + s->Sseg = elf_getsegment(".bss.", cpp_mangle(s), + SHT_NOBITS, SHF_ALLOC|SHF_WRITE, align); + s->Sfl = FLudata; + SegData[s->Sseg]->SDsym = s; + SegData[s->Sseg]->SDoffset += size * count; + objpubdef(s->Sseg, s, 0); + searchfixlist(s); + return s->Sseg; + } +#if 0 + IDXSTR namidx = elf_addmangled(s); + alignOffset(UDATA,size); + IDXSYM symidx = elf_addsym(namidx, SegData[UDATA]->SDoffset, size*count, + (s->ty() & mTYthread) ? STT_TLS : STT_OBJECT, + STB_WEAK, SHI_BSS); + //dbg_printf("\tobj_comdef returning symidx %d\n",symidx); + s->Sseg = UDATA; + s->Sfl = FLudata; + SegData[UDATA]->SDoffset += size * count; + return symidx; +#endif +} + +int obj_comdef(Symbol *s, int flag, targ_size_t size, targ_size_t count) +{ + return obj_comdef(s, size, count); +} + +/*************************************** + * Append an iterated data block of 0s. + * (uninitialized data only) + */ + +void obj_write_zeros(seg_data *pseg, targ_size_t count) +{ + obj_lidata(pseg->SDseg, pseg->SDoffset, count); +} + +/*************************************** + * Output an iterated data block of 0s. + * + * For boundary alignment and initialization + */ + +void obj_lidata(int seg,targ_size_t offset,targ_size_t count) +{ + //printf("obj_lidata(%d,%x,%d)\n",seg,offset,count); + if (seg == UDATA || seg == UNKNOWN) + { // Use SDoffset to record size of .BSS section + SegData[UDATA]->SDoffset += count; + } + else if (MAP_SEG2SEC(seg)->sh_type == SHT_NOBITS) + { // Use SDoffset to record size of .TBSS section + SegData[seg]->SDoffset += count; + } + else + { + obj_bytes(seg, offset, count, NULL); + } +} + +/*********************************** + * Append byte to segment. + */ + +void obj_write_byte(seg_data *pseg, unsigned byte) +{ + obj_byte(pseg->SDseg, pseg->SDoffset, byte); +} + +/************************************ + * Output byte to object file. + */ + +void obj_byte(int seg,targ_size_t offset,unsigned byte) +{ + Outbuffer *buf = SegData[seg]->SDbuf; + int save = buf->size(); + //dbg_printf("obj_byte(seg=%d, offset=x%lx, byte=x%x)\n",seg,offset,byte); + buf->setsize(offset); + buf->writeByte(byte); + if (save > offset+1) + buf->setsize(save); + else + SegData[seg]->SDoffset = offset+1; + //dbg_printf("\tsize now %d\n",buf->size()); +} + +/*********************************** + * Append bytes to segment. + */ + +void obj_write_bytes(seg_data *pseg, unsigned nbytes, void *p) +{ + obj_bytes(pseg->SDseg, pseg->SDoffset, nbytes, p); +} + +/************************************ + * Output bytes to object file. + * Returns: + * nbytes + */ + +unsigned obj_bytes(int seg, targ_size_t offset, unsigned nbytes, void *p) +{ +#if 0 + if (!(seg >= 0 && seg <= seg_count)) + { printf("obj_bytes: seg = %d, seg_count = %d\n", seg, seg_count); + *(char*)0=0; + } +#endif + assert(seg >= 0 && seg <= seg_count); + Outbuffer *buf = SegData[seg]->SDbuf; + if (buf == NULL) + { + //dbg_printf("obj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", seg, offset, nbytes, p); + //raise(SIGSEGV); + assert(buf != NULL); + } + int save = buf->size(); + //dbg_printf("obj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", + //seg,offset,nbytes,p); + buf->setsize(offset); + buf->reserve(nbytes); + if (p) + { + buf->writen(p,nbytes); + } + else + { // Zero out the bytes + buf->clearn(nbytes); + } + if (save > offset+nbytes) + buf->setsize(save); + else + SegData[seg]->SDoffset = offset+nbytes; + return nbytes; +} + +/******************************* + * Output a relocation entry for a segment + * Input: + * seg = where the address is going + * offset = offset within seg + * type = ELF relocation type RI_TYPE_XXXX + * index = Related symbol table index + * val = addend or displacement from address + */ + +int relcnt=0; + +void elf_addrel(int seg, targ_size_t offset, unsigned type, + IDXSYM symidx, targ_size_t val) +{ + seg_data *segdata; + Outbuffer *buf; + IDXSEC secidx; + + //assert(val == 0); + relcnt++; + //dbg_printf("%d-elf_addrel(seg %d,offset x%x,type x%x,symidx %d,val %d)\n", + //relcnt,seg, offset, type, symidx,val); + + assert(seg >= 0 && seg <= seg_count); + segdata = SegData[seg]; + secidx = MAP_SEG2SECIDX(seg); + assert(secidx != 0); + + if (segdata->SDrel == NULL) + segdata->SDrel = new Outbuffer(); + if (segdata->SDrel->size() == 0) + { IDXSEC relidx; + + if (secidx == SHI_TEXT) + relidx = SHI_RELTEXT; + else if (secidx == SHI_DATA) + relidx = SHI_RELDATA; + else + { + // Get the section name, and make a copy because + // elf_newsection() may reallocate the string buffer. + char *section_name = (char *)GET_SECTION_NAME(secidx); + int len = strlen(section_name) + 1; + char *p = (char *)alloca(len); + memcpy(p, section_name, len); + + relidx = elf_newsection(I64 ? ".rela" : ".rel", p, I64 ? SHT_RELA : SHT_REL, 0); + segdata->SDrelidx = relidx; + } + + if (I64) + { + /* Note that we're using Elf32_Shdr here instead of Elf64_Shdr. This is to make + * the code a bit simpler. In obj_term(), we translate the Elf32_Shdr into the proper + * Elf64_Shdr. + */ + Elf32_Shdr *relsec = &SecHdrTab[relidx]; + relsec->sh_link = SHI_SYMTAB; + relsec->sh_info = secidx; + relsec->sh_entsize = sizeof(Elf64_Rela); + relsec->sh_addralign = 8; + } + else + { + Elf32_Shdr *relsec = &SecHdrTab[relidx]; + relsec->sh_link = SHI_SYMTAB; + relsec->sh_info = secidx; + relsec->sh_entsize = sizeof(Elf32_Rel); + relsec->sh_addralign = 4; + } + } + + if (I64) + { + Elf64_Rela rel; + rel.r_offset = offset; // build relocation information + rel.r_info = ELF64_R_INFO(symidx,type); + rel.r_addend = val; + buf = segdata->SDrel; + buf->write(&rel,sizeof(rel)); + segdata->SDrelcnt++; + + if (offset >= segdata->SDrelmaxoff) + segdata->SDrelmaxoff = offset; + else + { // insert numerically + Elf64_Rela *relbuf = (Elf64_Rela *)buf->buf; + int i = relbuf[segdata->SDrelindex].r_offset > offset ? 0 : segdata->SDrelindex; + while (i < segdata->SDrelcnt) + { + if (relbuf[i].r_offset > offset) + break; + i++; + } + assert(i != segdata->SDrelcnt); // slide greater offsets down + memmove(relbuf+i+1,relbuf+i,sizeof(Elf64_Rela) * (segdata->SDrelcnt - i - 1)); + *(relbuf+i) = rel; // copy to correct location + segdata->SDrelindex = i; // next entry usually greater + } + } + else + { + Elf32_Rel rel; + rel.r_offset = offset; // build relocation information + rel.r_info = ELF32_R_INFO(symidx,type); + buf = segdata->SDrel; + buf->write(&rel,sizeof(rel)); + segdata->SDrelcnt++; + + if (offset >= segdata->SDrelmaxoff) + segdata->SDrelmaxoff = offset; + else + { // insert numerically + Elf32_Rel *relbuf = (Elf32_Rel *)buf->buf; + int i = relbuf[segdata->SDrelindex].r_offset > offset ? 0 : segdata->SDrelindex; + while (i < segdata->SDrelcnt) + { + if (relbuf[i].r_offset > offset) + break; + i++; + } + assert(i != segdata->SDrelcnt); // slide greater offsets down + memmove(relbuf+i+1,relbuf+i,sizeof(Elf32_Rel) * (segdata->SDrelcnt - i - 1)); + *(relbuf+i) = rel; // copy to correct location + segdata->SDrelindex = i; // next entry usually greater + } + } +} + +/******************************* + * Refer to address that is in the data segment. + * Input: + * seg = where the address is going + * offset = offset within seg + * val = displacement from address + * targetdatum = DATA, CDATA or UDATA, depending where the address is + * flags = CFoff, CFseg, CFoffset64 + * Example: + * int *abc = &def[3]; + * to allocate storage: + * reftodatseg(DATA,offset,3 * sizeof(int *),UDATA); + */ + +void reftodatseg(int seg,targ_size_t offset,targ_size_t val, + unsigned targetdatum,int flags) +{ + Outbuffer *buf; + int save; + + buf = SegData[seg]->SDbuf; + save = buf->size(); + buf->setsize(offset); +#if 0 + printf("reftodatseg(seg=%d, offset=x%llx, val=x%llx,data %x, flags %x)\n", + seg,(unsigned long long)offset,(unsigned long long)val,targetdatum,flags); +#endif + /*if (OPT_IS_SET(OPTfwritable_strings)) + { + elf_addrel(seg,offset,RI_TYPE_SYM32,STI_DATA,0); + } + else*/ + { + int relinfo; + targ_size_t v = 0; + + if (I64) + { + if (flags & CFoffset64) + { + relinfo = R_X86_64_64; + elf_addrel(seg, offset, relinfo, STI_RODAT, val); + buf->write64(0); + if (save > offset + 8) + buf->setsize(save); + return; + } + else if (MAP_SEG2TYP(seg) == CODE && config.flags3 & CFG3pic) + { relinfo = R_X86_64_PC32; + //v = -4L; + } + else if (MAP_SEG2SEC(targetdatum)->sh_flags & SHF_TLS) + relinfo = config.flags3 & CFG3pic ? R_X86_64_TLSGD : R_X86_64_TPOFF32; + else + relinfo = R_X86_64_32; + } + else + { + if (MAP_SEG2TYP(seg) == CODE && config.flags3 & CFG3pic) + relinfo = RI_TYPE_GOTOFF; + else if (MAP_SEG2SEC(targetdatum)->sh_flags & SHF_TLS) + relinfo = config.flags3 & CFG3pic ? RI_TYPE_TLS_GD : RI_TYPE_TLS_LE; + else + relinfo = RI_TYPE_SYM32; + } + + elf_addrel(seg, offset, relinfo, STI_RODAT, v); + } + buf->write32(val); + if (save > offset + 4) + buf->setsize(save); +} + +/******************************* + * Refer to address that is in the code segment. + * Only offsets are output, regardless of the memory model. + * Used to put values in switch address tables. + * Input: + * seg = where the address is going (CODE or DATA) + * offset = offset within seg + * val = displacement from start of this module + */ + +void reftocodseg(int seg,targ_size_t offset,targ_size_t val) +{ + Outbuffer *buf; + int save; + int segtyp = MAP_SEG2TYP(seg); + + //dbg_printf("reftocodseg(seg=%d, offset=x%lx, val=x%lx )\n",seg,offset,val); + assert(seg > 0); // COMDATs not done yet + buf = SegData[seg]->SDbuf; + save = buf->size(); + buf->setsize(offset); +#if 0 + if (segtyp == CODE) + { + val = val - funcsym_p->Soffset; + elf_addrel(seg,offset,RI_TYPE_PC32,funcsym_p->Sxtrnnum,0); + } + else +#endif + { + val = val - funcsym_p->Soffset; + int relinfo; + targ_size_t v = 0; + if (I64) + relinfo = (config.flags3 & CFG3pic) ? R_X86_64_PC32 : R_X86_64_32; + else + relinfo = (config.flags3 & CFG3pic) ? RI_TYPE_GOTOFF : RI_TYPE_SYM32; + elf_addrel(seg,offset, relinfo, funcsym_p->Sxtrnnum, v); + } + buf->write32(val); + if (save > offset + 4) + buf->setsize(save); +} + +/******************************* + * Refer to an identifier. + * Input: + * segtyp = where the address is going (CODE or DATA) + * offset = offset within seg + * s -> Symbol table entry for identifier + * val = displacement from identifier + * flags = CFselfrel: self-relative + * CFseg: get segment + * CFoff: get offset + * CFoffset64: 64 bit fixup + * CFpc32: I64: PC relative 32 bit fixup + * Returns: + * number of bytes in reference (4 or 8) + */ + +int reftoident(int seg, targ_size_t offset, Symbol *s, targ_size_t val, + int flags) +{ + bool external = TRUE; + Outbuffer *buf; + elf_u32_f32 relinfo,refseg; + int segtyp = MAP_SEG2TYP(seg); + //assert(val == 0); + int retsize = (flags & CFoffset64) ? 8 : 4; + targ_size_t v = 0; + +#if 0 + printf("\nreftoident('%s' seg %d, offset x%llx, val x%llx, flags x%x)\n", + s->Sident,seg,offset,val,flags); + dbg_printf("Sseg = %d, Sxtrnnum = %d, retsize = %d\n",s->Sseg,s->Sxtrnnum,retsize); + symbol_print(s); +#endif + + tym_t ty = s->ty(); + if (s->Sxtrnnum) + { // identifier is defined somewhere else + if (I64) + { + if (SymbolTable64[s->Sxtrnnum].st_shndx != SHT_UNDEF) + external = FALSE; + } + else + { + if (SymbolTable[s->Sxtrnnum].st_shndx != SHT_UNDEF) + external = FALSE; + } + } + + switch (s->Sclass) + { + case SClocstat: + buf = SegData[seg]->SDbuf; + if (I64) + { + if (s->Sfl == FLtlsdata) + relinfo = config.flags3 & CFG3pic ? R_X86_64_TLSGD : R_X86_64_TPOFF32; + else + { relinfo = config.flags3 & CFG3pic ? R_X86_64_PC32 : R_X86_64_32; + if (flags & CFpc32) + relinfo = R_X86_64_PC32; + if (relinfo == R_X86_64_PC32) + { + assert(retsize == 4); + if (val > 0xFFFFFFFF) + { /* The value to be added is bigger than 32 bits, so we + * transfer it to the 64 bit addend of the fixup record + */ + v = val; + val = 0; + } + } + } + } + else + { + if (s->Sfl == FLtlsdata) + relinfo = config.flags3 & CFG3pic ? RI_TYPE_TLS_GD : RI_TYPE_TLS_LE; + else + relinfo = config.flags3 & CFG3pic ? RI_TYPE_GOTOFF : RI_TYPE_SYM32; + } + if (flags & CFoffset64 && relinfo == R_X86_64_32) + { + relinfo = R_X86_64_64; + elf_addrel(seg,offset,relinfo,STI_RODAT,val + s->Soffset); + buf->write64(0); + } + else + { + elf_addrel(seg,offset,relinfo,STI_RODAT,v); + if (retsize == 8) + buf->write64(val + s->Soffset); + else + buf->write32(val + s->Soffset); + } + break; + + case SCcomdat: + case_SCcomdat: + case SCstatic: +#if 0 + if ((s->Sflags & SFLthunk) && s->Soffset) + { // A thunk symbol that has be defined + assert(s->Sseg == seg); + val = (s->Soffset+val) - (offset+4); + goto outaddrval; + } + // FALL_THROUGH +#endif + + case SCextern: + case SCcomdef: + case_extern: + case SCglobal: + if (!s->Sxtrnnum) + { // not in symbol table yet - class might change + //dbg_printf("\tadding %s to fixlist\n",s->Sident); + addtofixlist(s,offset,seg,val,flags); + return retsize; + } + else + { + int save; + buf = SegData[seg]->SDbuf; + save = buf->size(); + buf->setsize(offset); + if (flags & CFselfrel) + { // only for function references within code segments + if (!external && // local definition found + s->Sseg == seg && // within same code segment + (!(config.flags3 & CFG3pic) || // not position indp code + s->Sclass == SCstatic)) // or is pic, but declared static + { // Can use PC relative + //dbg_printf("\tdoing PC relative\n"); + val = (s->Soffset+val) - (offset+4); + } + else + { + //dbg_printf("\tadding relocation\n"); + if (I64) + { relinfo = config.flags3 & CFG3pic ? R_X86_64_PLT32 : R_X86_64_PC32; + elf_addrel(seg,offset, relinfo, s->Sxtrnnum, -4); + val = 0; + } + else + { relinfo = config.flags3 & CFG3pic ? RI_TYPE_PLT32 : RI_TYPE_PC32; + elf_addrel(seg,offset, relinfo, s->Sxtrnnum, 0); + val = (targ_size_t)-4; + } + } + } + else + { // code to code code to data, data to code, data to data refs + refseg = s->Sxtrnnum; // default to name symbol table entry + if (s->Sclass == SCstatic) + { // offset into .data or .bss seg + refseg = MAP_SEG2SYMIDX(s->Sseg); + // use segment symbol table entry + val += s->Soffset; + if (!(config.flags3 & CFG3pic) || // all static refs from normal code + segtyp == DATA) // or refs from data from posi indp + { + if (I64) + relinfo = (flags & CFpc32) ? R_X86_64_PC32 : R_X86_64_32; + else + relinfo = RI_TYPE_SYM32; + } + else + { + relinfo = I64 ? R_X86_64_PC32 : RI_TYPE_GOTOFF; + } + } + else if (config.flags3 & CFG3pic && s == GOTsym) + { // relocation for Gbl Offset Tab + relinfo = I64 ? R_X86_64_NONE : RI_TYPE_GOTPC; + } + else if (segtyp == DATA) + { // relocation from within DATA seg + relinfo = I64 ? R_X86_64_32 : RI_TYPE_SYM32; + } + else + { // relocation from within CODE seg + if (I64) + { if (config.flags3 & CFG3pic) + relinfo = R_X86_64_GOTPCREL; + else + relinfo = (flags & CFpc32) ? R_X86_64_PC32 : R_X86_64_32; + } + else + relinfo = config.flags3 & CFG3pic ? RI_TYPE_GOT32 : RI_TYPE_SYM32; + } + if ((s->ty() & mTYLINK) & mTYthread) + { + if (I64) + { + if (config.flags3 & CFG3pic) + { + if (s->Sclass == SCstatic || s->Sclass == SClocstat) + relinfo = R_X86_64_TLSGD; // TLS_GD? + else + relinfo = R_X86_64_TLSGD; + } + else + { + if (s->Sclass == SCstatic || s->Sclass == SClocstat) + relinfo = R_X86_64_TPOFF32; + else + relinfo = R_X86_64_GOTTPOFF; + } + } + else + { + if (config.flags3 & CFG3pic) + { + if (s->Sclass == SCstatic) + relinfo = RI_TYPE_TLS_LE; // TLS_GD? + else + relinfo = RI_TYPE_TLS_IE; + } + else + { + if (s->Sclass == SCstatic) + relinfo = RI_TYPE_TLS_LE; + else + relinfo = RI_TYPE_TLS_IE; + } + } + } + targ_size_t v = 0; + if (flags & CFoffset64 && relinfo == R_X86_64_32) + { + // The value to be added must only reside in the 64 bit addend. + relinfo = R_X86_64_64; + v = val; + val = 0; + } + //printf("\t\t************* adding relocation\n"); + if (I64 && retsize == 4) + { + assert(retsize == 4); + if (val > 0xFFFFFFFF) + { /* The value to be added is bigger than 32 bits, so we + * transfer it to the 64 bit addend of the fixup record + */ + v = val; + val = 0; + } + } +#if 0 + targ_size_t v = (relinfo == R_X86_64_PC32) ? -4 : 0; + if (relinfo == R_X86_64_PC32 && flags & CFaddend8) + v = -8; +#endif + assert(!(I64 && relinfo == R_X86_64_64) || val == 0); + elf_addrel(seg,offset,relinfo,refseg,v); + } +outaddrval: + if (retsize == 8) + buf->write64(val); + else + buf->write32(val); + if (save > offset + retsize) + buf->setsize(save); + } + break; + + case SCsinline: + case SCeinline: + printf ("Undefined inline value <>\n"); + //warerr(WM_undefined_inline,s->Sident); + case SCinline: + if (tyfunc(ty)) + { + s->Sclass = SCextern; + goto case_extern; + } + else if (config.flags2 & CFG2comdat) + goto case_SCcomdat; // treat as initialized common block + + default: +#ifdef DEBUG + //symbol_print(s); +#endif + assert(0); + } + return retsize; +} + +/***************************************** + * Generate far16 thunk. + * Input: + * s Symbol to generate a thunk for + */ + +void obj_far16thunk(Symbol *s) +{ + //dbg_printf("obj_far16thunk('%s')\n", s->Sident); + assert(0); +} + +/************************************** + * Mark object file as using floating point. + */ + +void obj_fltused() +{ + //dbg_printf("obj_fltused()\n"); +} + +/************************************ + * Close and delete .OBJ file. + */ + +void objfile_delete() +{ + //remove(fobjname); // delete corrupt output file +} + +/********************************** + * Terminate. + */ + +void objfile_term() +{ +#if TERMCODE + mem_free(fobjname); + fobjname = NULL; +#endif +} + +/********************************** + * Write to the object file + */ +void objfile_write(FILE *fd, void *buffer, unsigned len) +{ + fobjbuf->write(buffer, len); +} + +long elf_align(FILE *fd, targ_size_t size,long foffset) +{ + long offset; + switch (size) + { + case 0: + case 1: + return foffset; + case 4: + offset = (foffset + 3) & ~3; + break; + case 8: + offset = (foffset + 7) & ~7; + break; + case 16: + offset = (foffset + 15) & ~15; + break; + case 32: + offset = (foffset + 31) & ~31; + break; + default: + dbg_printf("size was %d\n",(int)size); + assert(0); + break; + } + if (offset > foffset) + fobjbuf->writezeros(offset - foffset); + return offset; +} + +/*************************************** + * Stuff pointer to ModuleInfo in its own segment. + */ + +#if MARS + +void obj_moduleinfo(Symbol *scc) +{ +// if (I64) return; // for now, until Phobos64 works + + int codeOffset, refOffset; + + /* Put in the ModuleReference. */ + { + /* struct ModuleReference + * { + * void* next; + * ModuleReference* module; + * } + */ + const int seg = DATA; + alignOffset(seg, NPTRSIZE); + SegData[seg]->SDoffset = SegData[seg]->SDbuf->size(); + refOffset = SegData[seg]->SDoffset; + SegData[seg]->SDbuf->writezeros(NPTRSIZE); + SegData[seg]->SDoffset += NPTRSIZE; + SegData[seg]->SDoffset += reftoident(seg, SegData[seg]->SDoffset, scc, 0, CFoffset64 | CFoff); + } + + /* Constructor that links the ModuleReference to the head of + * the list pointed to by _Dmoduleref + */ + { + /* ret + * codeOffset: + * pushad + * mov EAX,&ModuleReference + * mov ECX,_DmoduleRef + * mov EDX,[ECX] + * mov [EAX],EDX + * mov [ECX],EAX + * popad + * ret + */ + + const int seg = CODE; + Outbuffer *buf = SegData[seg]->SDbuf; + SegData[seg]->SDoffset = buf->size(); + codeOffset = SegData[seg]->SDoffset; + + if (I64 && config.flags3 & CFG3pic) + { // LEA RAX,ModuleReference[RIP] + buf->writeByte(REX | REX_W); + buf->writeByte(0x8D); + buf->writeByte(modregrm(0,AX,5)); + buf->write32(refOffset); + elf_addrel(seg, codeOffset + 3, R_X86_64_PC32, STI_DATA, -4); + + // MOV RCX,_DmoduleRef@GOTPCREL[RIP] + buf->writeByte(REX | REX_W); + buf->writeByte(0x8B); + buf->writeByte(modregrm(0,CX,5)); + buf->write32(0); + elf_addrel(seg, codeOffset + 10, R_X86_64_GOTPCREL, objextern("_Dmodule_ref"), -4); + } + else + { + const int reltype = I64 ? R_X86_64_32 : RI_TYPE_SYM32; + + /* movl ModuleReference*, %eax */ + buf->writeByte(0xB8); + buf->write32(refOffset); + elf_addrel(seg, codeOffset + 1, reltype, STI_DATA, 0); + + /* movl _Dmodule_ref, %ecx */ + buf->writeByte(0xB9); + buf->write32(0); + elf_addrel(seg, codeOffset + 6, reltype, objextern("_Dmodule_ref"), 0); + } + + if (I64) + buf->writeByte(REX | REX_W); + buf->writeByte(0x8B); buf->writeByte(0x11); /* movl (%ecx), %edx */ + if (I64) + buf->writeByte(REX | REX_W); + buf->writeByte(0x89); buf->writeByte(0x10); /* movl %edx, (%eax) */ + if (I64) + buf->writeByte(REX | REX_W); + buf->writeByte(0x89); buf->writeByte(0x01); /* movl %eax, (%ecx) */ + + buf->writeByte(0xC3); /* ret */ + SegData[seg]->SDoffset = buf->size(); + } + + /* Add reference to constructor into ".ctors" segment + */ + const int seg = elf_getsegment(".ctors", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE, NPTRSIZE); + + Outbuffer *buf = SegData[seg]->SDbuf; + if (I64) + { + elf_addrel(seg, SegData[seg]->SDoffset, R_X86_64_64, STI_TEXT, codeOffset); + buf->write64(0); + } + else + { + elf_addrel(seg, SegData[seg]->SDoffset, RI_TYPE_SYM32, STI_TEXT, 0); + buf->write32(codeOffset); + } + SegData[seg]->SDoffset += NPTRSIZE; +} + +#endif + +/************************************* + */ + +void elfobj_gotref(symbol *s) +{ + //printf("elfobj_gotref(%x '%s', %d)\n",s,s->Sident, s->Sclass); + switch(s->Sclass) + { + case SCstatic: + case SClocstat: + s->Sfl = FLgotoff; + break; + + case SCextern: + case SCglobal: + case SCcomdat: + case SCcomdef: + s->Sfl = FLgot; + break; + + default: + break; + } +} + +#endif +#endif diff --git a/backend/evalu8.c b/backend/evalu8.c new file mode 100644 index 00000000..59600236 --- /dev/null +++ b/backend/evalu8.c @@ -0,0 +1,2089 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include +#include + +#if !defined(__OpenBSD__) +// Mysteriously missing from OpenBSD +#include +#endif + +#if __DMC__ +#include +#endif + +#if __FreeBSD__ || __OpenBSD__ +#define fmodl fmod +#endif + +#include "cc.h" +#include "oper.h" /* OPxxxx definitions */ +#include "global.h" +#include "el.h" +#include "type.h" + +#if SCPP +#include "parser.h" +#include "cpp.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +extern void error(const char *filename, unsigned linnum, const char *format, ...); + +#if linux || __APPLE__ || __FreeBSD__ || __sun&&__SVR4 +int _status87() +{ + return fetestexcept(FE_ALL_EXCEPT); +} + +void _clear87() +{ + feclearexcept(FE_ALL_EXCEPT); +} +#endif + +CEXTERN elem * evalu8(elem *); + +/* When this !=0, we do constant folding on floating point constants + * even if they raise overflow, underflow, invalid, etc. exceptions. + */ + +static int ignore_exceptions; + +/* When this is !=0, we try to fold out OPsizeof expressions. + */ + +static int resolve_sizeof; + +/************************************ + * Helper to do % for long doubles. + */ + +#if __DMC__ +long double _modulo(long double x, long double y) +{ short sw; + + __asm + { + fld tbyte ptr y + fld tbyte ptr x // ST = x, ST1 = y +FM1: // We don't use fprem1 because for some inexplicable + // reason we get -5 when we do _modulo(15, 10) + fprem // ST = ST % ST1 + fstsw word ptr sw + fwait + mov AH,byte ptr sw+1 // get msb of status word in AH + sahf // transfer to flags + jp FM1 // continue till ST < ST1 + fstp ST(1) // leave remainder on stack + } +} +#endif + +/********************** + * Return boolean result of constant elem. + */ + +HINT boolres(elem *e) +{ int b; + + //printf("boolres()\n"); + //elem_print(e); + elem_debug(e); +// assert((_status87() & 0x3800) == 0); + switch (e->Eoper) + { + case OPrelconst: + case OPstring: + return TRUE; + +#if SCPP + case OPvar: + assert(CPP && PARSER); + el_toconst(e); + assert(e->Eoper == OPconst); +#endif + case OPconst: + switch (tybasic(typemask(e))) + { case TYchar: + case TYuchar: + case TYschar: + case TYchar16: + case TYshort: + case TYushort: + case TYint: + case TYuint: + case TYbool: + case TYwchar_t: + case TYenum: +#if !MARS + case TYmemptr: +#endif + case TYlong: + case TYulong: + case TYdchar: + case TYllong: + case TYullong: +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYhptr: + case TYfptr: + case TYvptr: +#endif + case TYnptr: + b = el_tolong(e) != 0; + break; + case TYfloat: + case TYifloat: + case TYdouble: + case TYidouble: + case TYdouble_alias: + case TYildouble: + case TYldouble: + { targ_ldouble ld = el_toldouble(e); + + if (isnan((double)ld)) + b = 1; + else + b = (ld != 0); + break; + } + case TYcfloat: + if (isnan(e->EV.Vcfloat.re) || isnan(e->EV.Vcfloat.im)) + b = 1; + else + b = e->EV.Vcfloat.re != 0 || e->EV.Vcfloat.im != 0; + break; + case TYcdouble: + case TYdouble2: + if (isnan(e->EV.Vcdouble.re) || isnan(e->EV.Vcdouble.im)) + b = 1; + else + b = e->EV.Vcdouble.re != 0 || e->EV.Vcdouble.im != 0; + break; + case TYcldouble: + if (isnan(e->EV.Vcldouble.re) || isnan(e->EV.Vcldouble.im)) + b = 1; + else + b = e->EV.Vcldouble.re != 0 || e->EV.Vcldouble.im != 0; + break; + case TYstruct: // happens on syntax error of (struct x)0 +#if SCPP + assert(errcnt); +#else + assert(0); +#endif + case TYvoid: /* happens if we get syntax errors or + on RHS of && || expressions */ + b = 0; + break; + + case TYcent: + case TYucent: + case TYschar16: + case TYuchar16: + case TYshort8: + case TYushort8: + case TYlong4: + case TYulong4: + case TYllong2: + case TYullong2: + b = e->EV.Vcent.lsw || e->EV.Vcent.msw; + break; + + case TYfloat4: + { b = 0; + targ_float *pf = (targ_float *)&e->EV.Vcent; + for (size_t i = 0; i < 4; i++) + { + if (isnan(pf[i]) || pf[i] != 0) + { b = 1; + break; + } + } + break; + } + + default: +#ifdef DEBUG + WRTYxx(typemask(e)); +#endif + assert(0); + } + break; + default: + assert(0); + } + return b; +} + +/*************************** + * Return TRUE if expression will always evaluate to TRUE. + */ + +HINT iftrue(elem *e) +{ + while (1) + { + assert(e); + elem_debug(e); + switch (e->Eoper) + { case OPcomma: + case OPinfo: + e = e->E2; + break; + case OPrelconst: + case OPconst: + case OPstring: + return boolres(e); + default: + return FALSE; + } + } +} + +/*************************** + * Return TRUE if expression will always evaluate to FALSE. + */ + +HINT iffalse(elem *e) +{ + while (1) + { assert(e); + elem_debug(e); + switch (e->Eoper) + { case OPcomma: + case OPinfo: + e = e->E2; + break; + case OPconst: + return !boolres(e); + //case OPstring: + //case OPrelconst: + default: + return FALSE; + } + } +} + +/****************************** + * Constant fold expression tree. + * Calculate &symbol and &*e1 if we can. + */ + +#if SCPP + +elem *poptelem2(elem *e) +{ + // Same as poptelem(), but we ignore floating point exceptions + ignore_exceptions++; + e = poptelem(e); + ignore_exceptions--; + return e; +} + +elem *poptelem3(elem *e) +{ + resolve_sizeof++; + e = poptelem(e); + resolve_sizeof--; + return e; +} + +elem *poptelem4(elem *e) +{ + resolve_sizeof++; + ignore_exceptions++; + e = poptelem(e); + ignore_exceptions--; + resolve_sizeof--; + return e; +} + +elem *poptelem(elem *e) +{ + elem *e1,*e2; + unsigned op; + + //dbg_printf("poptelem(e = %p)\n", e); elem_print(e); +#ifdef DEBUG + assert(PARSER); + assert(e && e->ET); + + if (controlc_saw) + exit(1); +// static int xxx; if (++xxx == 1000) *(char *)0 = 0; +#endif + elem_debug(e); + type_debug(e->ET); + + op = e->Eoper; + +#ifdef DEBUG + if (OTunary(op)) + assert(!e->E2 || op == OPinfo); +#endif + + switch (op) + { + case OPvar: + if (CPP && e->EV.sp.Vsym->Sflags & SFLvalue) + el_toconst(e); + break; + + case OPsizeof: + if (resolve_sizeof) + { + e->Eoper = OPconst; + e->EV.Vlong = type_size(e->EV.sp.Vsym->Stype); + } + break; + + case OPconst: + case OPrelconst: + case OPstring: + break; + + case OPaddr: + e1 = e->E1; + if (e1->Eoper == OPvar) + goto L3; + e->E1 = e1 = poptelem(e1); + if (e1->Eoper == OPind) /* if &*exp */ + { type *t; + + L6: + t = e->ET; + e1->E1 = cast(e1->E1,t); + e = selecte1(selecte1(e,t),t); + } + else if (e1->Eoper == OPvar) + { /* convert &var to relconst */ + L3: + e = selecte1(e,e->ET); + e->Eoper = OPrelconst; +#if 1 + // If this is an address of a function template, + // try to expand the template if it's got an explicit + // parameter list. + if (e->PEFflags & PEFtemplate_id) + { symbol *s; + + s = e->EV.sp.Vsym; + s = cpp_lookformatch(s, NULL, NULL,NULL,NULL,NULL, + e->EV.sp.spu.Vtal, 1|8, NULL, NULL); + if (s) + { + e->EV.sp.Vsym = s; + param_free(&e->EV.sp.spu.Vtal); + e->PEFflags &= ~PEFtemplate_id; + type_settype(&e->ET, newpointer(s->Stype)); + } + } +#endif + } + break; + case OPind: + e->E1 = e1 = poptelem(e->E1); +#if TX86 + if (e1->Eoper == OPrelconst) + { /* convert *(&var) to var */ + + e = selecte1(e,e->ET); + e->Eoper = OPvar; + } +#else + if (e1->Eoper == OPrelconst) + { + unsigned to_sz = tysize(tym_conv(e->ET)); + unsigned frm_sz = tysize(tym_conv(e1->ET)); + + if (tyfunc(tybasic(e->ET->Tty))) + to_sz = LONGSIZE; + else if (tybasic(e->ET->Tty) == TYstruct || tybasic(e->ET->Tty) == TYarray) + { + to_sz = LONGSIZE; + e1->ET = e->ET; + } + if(to_sz == frm_sz) + { /* convert *(&var) to var */ +doit: + e = selecte1(e,e->ET); + e->Eoper = OPvar; + } + else /* handle the most common cases for now */ + { unsigned offset = e1->Eoffset; + switch(to_sz) + { + case SHORTSIZE: + if (frm_sz == LONGSIZE && (offset%LONGSIZE) == SHORTSIZE) + goto doit; + break; + case CHARSIZE: + if (frm_sz == LONGSIZE && + offset%(LONGSIZE-CHARSIZE) == CHARSIZE) + goto doit; + if (frm_sz == SHORTSIZE && offset&1) + goto doit; + break; + } + } + } +#endif + break; +#if TARGET_SEGMENTED + case OPnp_fp: + e->E1 = e1 = poptelem(e->E1); + // If casting a non-NULL constant pointer + if (e1->Eoper == OPconst && el_tolong(e1) != 0) + break; + goto L5; + case OPoffset: + e->E1 = e1 = poptelem(e->E1); + if (e1->Eoper == OPnp_fp) + goto L6; + goto L5; +#endif + case OP32_16: + e->E1 = e1 = poptelem(e->E1); + L5: + if (e1->Eoper == OPrelconst || e1->Eoper == OPstring) + e = selecte1(e,e->ET); + else + goto eval; + break; + case OPandand: + e->E1 = e1 = poptelem(e->E1); + if (iffalse(e1)) + goto L2; + else + goto def; + case OPoror: + e->E1 = e1 = poptelem(e->E1); + if (iftrue(e1)) + { + L2: el_free(e->E2); + e->E2 = NULL; + e->Eoper = OPbool; + e = poptelem(e); + } + else + goto def; + break; + case OPcond: + e->E1 = e1 = poptelem(e->E1); + if (e1->Eoper == OPconst) + { + e2 = e->E2; + type_free(e->ET); + if (boolres(e1)) + { el_copy(e,e2->E1); + e2->E1->Eoper = OPunde; + e2->E1->ET = NULL; + e2->E1->E1 = NULL; + e2->E1->E2 = NULL; + el_free(e2->E1); + e2->E1 = NULL; + } + else + { el_copy(e,e2->E2); + e2->E2->Eoper = OPunde; + e2->E2->ET = NULL; + e2->E2->E1 = NULL; + e2->E2->E2 = NULL; + el_free(e2->E2); + e2->E2 = NULL; + } + el_free(e2); + el_free(e1); + e = poptelem(e); + } + else + goto def; + break; + case OPadd: + e->E1 = e1 = poptelem(e->E1); + e->E2 = e2 = poptelem(e->E2); + if (e1->Eoper == OPconst) + { /* swap leaves */ + e->E1 = e2; + e2 = e->E2 = e1; + e1 = e->E1; + } + goto L4; + case OPmin: + e->E1 = e1 = poptelem(e->E1); + e->E2 = e2 = poptelem(e->E2); + L4: + if (e1->Eoper == OPrelconst || e1->Eoper == OPstring) + { + if (e2->Eoper == OPconst) + { targ_int i = e2->EV.Vint; + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (i && e1->EV.sp.Vsym->Sfl == FLgot) + break; +#endif + if (e->Eoper == OPmin) + i = -i; + e1->EV.sp.Voffset += i; + e = selecte1(e,e->ET); + break; + } + } + goto eval; + default: + if (OTleaf(op)) + goto ret; + e->E1 = poptelem(e->E1); + def: + if (OTbinary(op)) // if binary node + { + e->E2 = poptelem(e->E2); + } + eval: + e = evalu8(e); + break; + } +ret: + return e; +} + +/******************** + * Select E1 leaf of e, and give it type t. + */ + +elem *selecte1(elem *e,type *t) +{ elem *e1; + + elem_debug(e); + assert(EOP(e)); + e1 = e->E1; + el_settype(e1,t); + e->E1 = NULL; + el_free(e); + return e1; +} + +#endif + +/****************************** + * Evaluate a node with only constants as leaves. + * Return with the result. + */ + +elem * evalu8(elem *e) +{ elem *e1,*e2; + tym_t tym,tym2,uns; + unsigned op; + targ_int i1,i2; + int i; + targ_llong l1,l2; + targ_ldouble d1,d2; + elem esave; + +// assert((_status87() & 0x3800) == 0); + assert(e && EOP(e)); + op = e->Eoper; + elem_debug(e); + e1 = e->E1; + + //printf("evalu8(): "); elem_print(e); + elem_debug(e1); + if (e1->Eoper == OPconst && !tyvector(e1->Ety)) + { + tym2 = 0; + e2 = NULL; + if (EBIN(e)) + { e2 = e->E2; + elem_debug(e2); + if (e2->Eoper == OPconst && !tyvector(e2->Ety)) + { + i2 = l2 = el_tolong(e2); + d2 = el_toldouble(e2); + } + else + return e; + tym2 = tybasic(typemask(e2)); + } + else + { + tym2 = 0; + e2 = NULL; + i2 = 0; // not used, but static analyzer complains + l2 = 0; // " + d2 = 0; // " + } + i1 = l1 = el_tolong(e1); + d1 = el_toldouble(e1); + tym = tybasic(typemask(e1)); /* type of op is type of left child */ + +#if TX86 && SCPP + // Huge pointers are always evaluated at runtime + if (tym == TYhptr && (l1 != 0 || l2 != 0)) + return e; +#endif + esave = *e; +#if !__OpenBSD__ + _clear87(); +#endif + } + else + return e; + + /* if left or right leaf is unsigned, this is an unsigned operation */ + uns = tyuns(tym) | tyuns(tym2); + + /*elem_print(e);*/ + /*dbg_printf("x%lx ",l1); WROP(op); dbg_printf("x%lx = ",l2);*/ +#if 0 + if (0 && e2) + { + dbg_printf("d1 = %Lg, d2 = %Lg, op = %d, OPne = %d, tym = x%lx\n",d1,d2,op,OPne,tym); + dbg_printf("tym1 = x%lx, tym2 = x%lx, e2 = %g\n",tym,tym2,e2->EV.Vdouble); + + union eve u; + dbg_printf("d1 = x%16llx\n", (u.Vldouble = d1, u.Vullong)); + dbg_printf("d2 = x%16llx\n", (u.Vldouble = d2, u.Vullong)); + } +#endif + i = 0; + switch (op) + { + case OPadd: + switch (tym) + { + case TYfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vfloat = e1->EV.Vfloat + e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vcfloat.re = e1->EV.Vfloat; + e->EV.Vcfloat.im = e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = e1->EV.Vfloat + e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = 0 + e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYdouble: + case TYdouble_alias: + switch (tym2) + { + case TYdouble: + case TYdouble_alias: + e->EV.Vdouble = e1->EV.Vdouble + e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vcdouble.re = e1->EV.Vdouble; + e->EV.Vcdouble.im = e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = e1->EV.Vdouble + e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = 0 + e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vldouble = d1 + d2; + break; + case TYildouble: + e->EV.Vcldouble.re = d1; + e->EV.Vcldouble.im = d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = d1 + e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = 0 + e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case TYifloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vfloat; + break; + case TYifloat: + e->EV.Vfloat = e1->EV.Vfloat + e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = 0 + e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vfloat + e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYidouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vdouble; + break; + case TYidouble: + e->EV.Vdouble = e1->EV.Vdouble + e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = 0 + e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vdouble + e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYildouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = d2; + e->EV.Vcldouble.im = d1; + break; + case TYildouble: + e->EV.Vldouble = d1 + d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = 0 + e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = d1 + e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case TYcfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re + e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im; + break; + case TYifloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im + e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re + e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im + e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYcdouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re + e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im; + break; + case TYidouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im + e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re + e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im + e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYcldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re + d2; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im; + break; + case TYildouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im + d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re + e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im + e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + + default: +#if TX86 + if (intsize == 2) + { if (tyfv(tym)) + e->EV.Vlong = (l1 & 0xFFFF0000) | + (targ_ushort) ((targ_ushort) l1 + i2); + else if (tyfv(tym2)) + e->EV.Vlong = (l2 & 0xFFFF0000) | + (targ_ushort) (i1 + (targ_ushort) l2); + else if (tyintegral(tym) || typtr(tym)) + e->EV.Vllong = l1 + l2; + else + assert(0); + } + else +#endif + if (tyintegral(tym) || typtr(tym)) + e->EV.Vllong = l1 + l2; + else + assert(0); + break; + } + break; + + case OPmin: + switch (tym) + { + case TYfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vfloat = e1->EV.Vfloat - e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vcfloat.re = e1->EV.Vfloat; + e->EV.Vcfloat.im = -e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = e1->EV.Vfloat - e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = 0 - e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYdouble: + case TYdouble_alias: + switch (tym2) + { + case TYdouble: + case TYdouble_alias: + e->EV.Vdouble = e1->EV.Vdouble - e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vcdouble.re = e1->EV.Vdouble; + e->EV.Vcdouble.im = -e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = e1->EV.Vdouble - e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = 0 - e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vldouble = d1 - d2; + break; + case TYildouble: + e->EV.Vcldouble.re = d1; + e->EV.Vcldouble.im = -d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = d1 - e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = 0 - e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case TYifloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = -e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vfloat; + break; + case TYifloat: + e->EV.Vfloat = e1->EV.Vfloat - e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = 0 - e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vfloat - e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYidouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = -e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vdouble; + break; + case TYidouble: + e->EV.Vdouble = e1->EV.Vdouble - e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = 0 - e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vdouble - e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYildouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = -d2; + e->EV.Vcldouble.im = d1; + break; + case TYildouble: + e->EV.Vldouble = d1 - d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = 0 - e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = d1 - e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case TYcfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re - e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im; + break; + case TYifloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im - e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re - e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im - e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYcdouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re - e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im; + break; + case TYidouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im - e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re - e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im - e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYcldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re - d2; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im; + break; + case TYildouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im - d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re - e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im - e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + + default: +#if TX86 + if (intsize == 2 && + tyfv(tym) && tysize[tym2] == 2) + e->EV.Vllong = (l1 & 0xFFFF0000) | + (targ_ushort) ((targ_ushort) l1 - i2); + else +#endif + if (tyintegral(tym) || typtr(tym)) + e->EV.Vllong = l1 - l2; + else + assert(0); + break; + } + break; + case OPmul: + if (tyintegral(tym) || typtr(tym)) + e->EV.Vllong = l1 * l2; + else + { switch (tym) + { + case TYfloat: + switch (tym2) + { + case TYfloat: + case TYifloat: + e->EV.Vfloat = e1->EV.Vfloat * e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = e1->EV.Vfloat * e2->EV.Vcfloat.re; + e->EV.Vcfloat.im = e1->EV.Vfloat * e2->EV.Vcfloat.im; + break; + default: + assert(0); + } + break; + case TYdouble: + case TYdouble_alias: + switch (tym2) + { + case TYdouble: + case TYdouble_alias: + case TYidouble: + e->EV.Vdouble = e1->EV.Vdouble * e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = e1->EV.Vdouble * e2->EV.Vcdouble.re; + e->EV.Vcdouble.im = e1->EV.Vdouble * e2->EV.Vcdouble.im; + break; + default: + assert(0); + } + break; + case TYldouble: + switch (tym2) + { + case TYldouble: + case TYildouble: + e->EV.Vldouble = d1 * d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = d1 * e2->EV.Vcldouble.re; + e->EV.Vcldouble.im = d1 * e2->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case TYifloat: + switch (tym2) + { + case TYfloat: + e->EV.Vfloat = e1->EV.Vfloat * e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vfloat = -e1->EV.Vfloat * e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = -e1->EV.Vfloat * e2->EV.Vcfloat.im; + e->EV.Vcfloat.im = e1->EV.Vfloat * e2->EV.Vcfloat.re; + break; + default: + assert(0); + } + break; + case TYidouble: + switch (tym2) + { + case TYdouble: + e->EV.Vdouble = e1->EV.Vdouble * e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vdouble = -e1->EV.Vdouble * e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = -e1->EV.Vdouble * e2->EV.Vcdouble.im; + e->EV.Vcdouble.im = e1->EV.Vdouble * e2->EV.Vcdouble.re; + break; + default: + assert(0); + } + break; + case TYildouble: + switch (tym2) + { + case TYldouble: + e->EV.Vldouble = d1 * d2; + break; + case TYildouble: + e->EV.Vldouble = -d1 * d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = -d1 * e2->EV.Vcldouble.im; + e->EV.Vcldouble.im = d1 * e2->EV.Vcldouble.re; + break; + default: + assert(0); + } + break; + case TYcfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re * e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im * e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vcfloat.re = -e1->EV.Vcfloat.im * e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vcfloat.re * e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat = Complex_f::mul(e1->EV.Vcfloat, e2->EV.Vcfloat); + break; + default: + assert(0); + } + break; + case TYcdouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re * e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im * e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vcdouble.re = -e1->EV.Vcdouble.im * e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vcdouble.re * e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble = Complex_d::mul(e1->EV.Vcdouble, e2->EV.Vcdouble); + break; + default: + assert(0); + } + break; + case TYcldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re * d2; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im * d2; + break; + case TYildouble: + e->EV.Vcldouble.re = -e1->EV.Vcldouble.im * d2; + e->EV.Vcldouble.im = e1->EV.Vcldouble.re * d2; + break; + case TYcldouble: + e->EV.Vcldouble = Complex_ld::mul(e1->EV.Vcldouble, e2->EV.Vcldouble); + break; + default: + assert(0); + } + break; + default: +#ifdef DEBUG + dbg_printf("tym = x%x\n",tym); + elem_print(e); +#endif + assert(0); + } + } + break; + case OPdiv: + if (!boolres(e2)) // divide by 0 + { +#if SCPP + if (!tyfloating(tym)) +#endif + goto div0; + } + if (uns) + e->EV.Vullong = ((targ_ullong) l1) / ((targ_ullong) l2); + else + { switch (tym) + { + case TYfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vfloat = e1->EV.Vfloat / e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vfloat = -e1->EV.Vfloat / e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = d1; + e->EV.Vcfloat.im = 0; + e->EV.Vcfloat = Complex_f::div(e->EV.Vcfloat, e2->EV.Vcfloat); + break; + default: + assert(0); + } + break; + case TYdouble: + case TYdouble_alias: + switch (tym2) + { + case TYdouble: + case TYdouble_alias: + e->EV.Vdouble = e1->EV.Vdouble / e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vdouble = -e1->EV.Vdouble / e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = d1; + e->EV.Vcdouble.im = 0; + e->EV.Vcdouble = Complex_d::div(e->EV.Vcdouble, e2->EV.Vcdouble); + break; + default: + assert(0); + } + break; + case TYldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vldouble = d1 / d2; + break; + case TYildouble: + e->EV.Vldouble = -d1 / d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = d1; + e->EV.Vcldouble.im = 0; + e->EV.Vcldouble = Complex_ld::div(e->EV.Vcldouble, e2->EV.Vcldouble); + break; + default: + assert(0); + } + break; + case TYifloat: + switch (tym2) + { + case TYfloat: + case TYifloat: + e->EV.Vfloat = e1->EV.Vfloat / e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat.re = 0; + e->EV.Vcfloat.im = e1->EV.Vfloat; + e->EV.Vcfloat = Complex_f::div(e->EV.Vcfloat, e2->EV.Vcfloat); + break; + default: + assert(0); + } + break; + case TYidouble: + switch (tym2) + { + case TYdouble: + case TYidouble: + e->EV.Vdouble = e1->EV.Vdouble / e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble.re = 0; + e->EV.Vcdouble.im = e1->EV.Vdouble; + e->EV.Vcdouble = Complex_d::div(e->EV.Vcdouble, e2->EV.Vcdouble); + break; + default: + assert(0); + } + break; + case TYildouble: + switch (tym2) + { + case TYldouble: + case TYildouble: + e->EV.Vldouble = d1 / d2; + break; + case TYcldouble: + e->EV.Vcldouble.re = 0; + e->EV.Vcldouble.im = d1; + e->EV.Vcldouble = Complex_ld::div(e->EV.Vcldouble, e2->EV.Vcldouble); + break; + default: + assert(0); + } + break; + case TYcfloat: + switch (tym2) + { + case TYfloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.re / e2->EV.Vfloat; + e->EV.Vcfloat.im = e1->EV.Vcfloat.im / e2->EV.Vfloat; + break; + case TYifloat: + e->EV.Vcfloat.re = e1->EV.Vcfloat.im / e2->EV.Vfloat; + e->EV.Vcfloat.im = -e1->EV.Vcfloat.re / e2->EV.Vfloat; + break; + case TYcfloat: + e->EV.Vcfloat = Complex_f::div(e1->EV.Vcfloat, e2->EV.Vcfloat); + break; + default: + assert(0); + } + break; + case TYcdouble: + switch (tym2) + { + case TYdouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.re / e2->EV.Vdouble; + e->EV.Vcdouble.im = e1->EV.Vcdouble.im / e2->EV.Vdouble; + break; + case TYidouble: + e->EV.Vcdouble.re = e1->EV.Vcdouble.im / e2->EV.Vdouble; + e->EV.Vcdouble.im = -e1->EV.Vcdouble.re / e2->EV.Vdouble; + break; + case TYcdouble: + e->EV.Vcdouble = Complex_d::div(e1->EV.Vcdouble, e2->EV.Vcdouble); + break; + default: + assert(0); + } + break; + case TYcldouble: + switch (tym2) + { + case TYldouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.re / d2; + e->EV.Vcldouble.im = e1->EV.Vcldouble.im / d2; + break; + case TYildouble: + e->EV.Vcldouble.re = e1->EV.Vcldouble.im / d2; + e->EV.Vcldouble.im = -e1->EV.Vcldouble.re / d2; + break; + case TYcldouble: + e->EV.Vcldouble = Complex_ld::div(e1->EV.Vcldouble, e2->EV.Vcldouble); + break; + default: + assert(0); + } + break; + default: + e->EV.Vllong = l1 / l2; + break; + } + } + break; + case OPmod: + if (!boolres(e2)) + { + div0: +#if SCPP + synerr(EM_divby0); +#else // MARS + //error(e->Esrcpos.Sfilename, e->Esrcpos.Slinnum, "divide by zero"); +#endif + break; + } + if (uns) + e->EV.Vullong = ((targ_ullong) l1) % ((targ_ullong) l2); + else + { + // BUG: what do we do for imaginary, complex? + switch (tym) + { case TYdouble: + case TYidouble: + case TYdouble_alias: + e->EV.Vdouble = fmod(e1->EV.Vdouble,e2->EV.Vdouble); + break; + case TYfloat: + case TYifloat: + e->EV.Vfloat = fmodf(e1->EV.Vfloat,e2->EV.Vfloat); + break; + case TYldouble: + case TYildouble: +#if __DMC__ + e->EV.Vldouble = _modulo(d1, d2); +#else + e->EV.Vldouble = fmodl(d1, d2); +#endif + break; + case TYcfloat: + switch (tym2) + { + case TYfloat: + case TYifloat: + e->EV.Vcfloat.re = fmodf(e1->EV.Vcfloat.re, e2->EV.Vfloat); + e->EV.Vcfloat.im = fmodf(e1->EV.Vcfloat.im, e2->EV.Vfloat); + break; + default: + assert(0); + } + break; + case TYcdouble: + switch (tym2) + { + case TYdouble: + case TYidouble: + e->EV.Vcdouble.re = fmod(e1->EV.Vcdouble.re, e2->EV.Vdouble); + e->EV.Vcdouble.im = fmod(e1->EV.Vcdouble.im, e2->EV.Vdouble); + break; + default: + assert(0); + } + break; + case TYcldouble: + switch (tym2) + { + case TYldouble: + case TYildouble: +#if __DMC__ + e->EV.Vcldouble.re = _modulo(e1->EV.Vcldouble.re, d2); + e->EV.Vcldouble.im = _modulo(e1->EV.Vcldouble.im, d2); +#else + e->EV.Vcldouble.re = fmodl(e1->EV.Vcldouble.re, d2); + e->EV.Vcldouble.im = fmodl(e1->EV.Vcldouble.im, d2); +#endif + break; + default: + assert(0); + } + break; + default: + e->EV.Vllong = l1 % l2; + break; + } + } + break; + case OPremquo: + { + targ_llong rem, quo; + + if (!boolres(e2)) + goto div0; + if (uns) + { + rem = ((targ_ullong) l1) % ((targ_ullong) l2); + quo = ((targ_ullong) l1) / ((targ_ullong) l2); + } + else + { + rem = l1 % l2; + quo = l1 / l2; + } + switch (tysize(tym)) + { + case 2: + e->EV.Vllong = (rem << 16) | (quo & 0xFFFF); + break; + case 4: + e->EV.Vllong = (rem << 32) | (quo & 0xFFFFFFFF); + break; + case 8: + e->EV.Vcent.lsw = quo; + e->EV.Vcent.msw = rem; + break; + default: + assert(0); + break; + } + break; + } + case OPand: + e->EV.Vllong = l1 & l2; + break; + case OPor: + e->EV.Vllong = l1 | l2; + break; + case OPxor: + e->EV.Vllong = l1 ^ l2; + break; + case OPnot: + e->EV.Vint = boolres(e1) ^ TRUE; + break; + case OPcom: + e->EV.Vllong = ~l1; + break; + case OPcomma: + e->EV = e2->EV; + break; + case OPoror: + e->EV.Vint = boolres(e1) || boolres(e2); + break; + case OPandand: + e->EV.Vint = boolres(e1) && boolres(e2); + break; + case OPshl: + if ((targ_ullong) i2 < sizeof(targ_ullong) * 8) + e->EV.Vllong = l1 << i2; + else + e->EV.Vllong = 0; + break; + case OPshr: + if ((targ_ullong) i2 > sizeof(targ_ullong) * 8) + i2 = sizeof(targ_ullong) * 8; +#if SCPP + if (tyuns(tym)) + { //printf("unsigned\n"); + e->EV.Vullong = ((targ_ullong) l1) >> i2; + } + else + { //printf("signed\n"); + e->EV.Vllong = l1 >> i2; + } +#endif +#if MARS + // Always unsigned + e->EV.Vullong = ((targ_ullong) l1) >> i2; +#endif + break; + +#if MARS + case OPashr: + if ((targ_ullong) i2 > sizeof(targ_ullong) * 8) + i2 = sizeof(targ_ullong) * 8; + // Always signed + e->EV.Vllong = l1 >> i2; + break; +#endif + + case OPpair: + switch (tysize[tym]) + { + case 2: + e->EV.Vlong = (i2 << 16) | (i1 & 0xFFFF); + break; + case 4: + e->EV.Vllong = (l2 << 32) | (l1 & 0xFFFFFFFF); + break; + case 8: + e->EV.Vcent.lsw = l1; + e->EV.Vcent.msw = l2; + break; + default: + assert(0); + } + break; + + case OPneg: +#if TX86 + // Avoid converting NANS to NAN + memcpy(&e->EV.Vcldouble,&e1->EV.Vcldouble,sizeof(e->EV.Vcldouble)); + switch (tym) + { case TYdouble: + case TYidouble: + case TYdouble_alias: + e->EV.Vdouble = -e->EV.Vdouble; + break; + case TYfloat: + case TYifloat: + e->EV.Vfloat = -e->EV.Vfloat; + break; + case TYldouble: + case TYildouble: + e->EV.Vldouble = -e->EV.Vldouble; + break; + case TYcfloat: + e->EV.Vcfloat.re = -e->EV.Vcfloat.re; + e->EV.Vcfloat.im = -e->EV.Vcfloat.im; + break; + case TYcdouble: + e->EV.Vcdouble.re = -e->EV.Vcdouble.re; + e->EV.Vcdouble.im = -e->EV.Vcdouble.im; + break; + case TYcldouble: + e->EV.Vcldouble.re = -e->EV.Vcldouble.re; + e->EV.Vcldouble.im = -e->EV.Vcldouble.im; + break; + default: + e->EV.Vllong = -l1; + break; + } +#else + switch (tym) + { case TYdouble: + e->EV.Vdouble = -e1->EV.Vdouble; + break; + case TYfloat: + e->EV.Vfloat = -e1->EV.Vfloat; + break; + case TYldouble: + e->EV.Vldouble = -d1; + break; + default: + e->EV.Vllong = -l1; + break; + } +#endif + break; + case OPabs: +#if 1 + switch (tym) + { + case TYdouble: + case TYidouble: + case TYdouble_alias: + e->EV.Vdouble = fabs(e1->EV.Vdouble); + break; + case TYfloat: + case TYifloat: +#if __SC__ + e->EV.Vfloat = fabsf(e1->EV.Vfloat); +#else + e->EV.Vfloat = fabs(e1->EV.Vfloat); +#endif + break; + case TYldouble: + case TYildouble: + e->EV.Vldouble = fabsl(d1); + break; + case TYcfloat: + e->EV.Vfloat = Complex_f::abs(e1->EV.Vcfloat); + break; + case TYcdouble: + e->EV.Vdouble = Complex_d::abs(e1->EV.Vcdouble); + break; + case TYcldouble: + e->EV.Vldouble = Complex_ld::abs(e1->EV.Vcldouble); + break; + default: + e->EV.Vllong = labs(l1); + break; + } + break; +#endif + case OPsqrt: + case OPrndtol: + case OPsin: + case OPcos: + case OPrint: + return e; + case OPngt: + i++; + case OPgt: + if (!tyfloating(tym)) + goto Lnle; + i ^= (int)(d1 > d2); + e->EV.Vint = i; + break; + + case OPnle: + Lnle: + i++; + case OPle: + if (uns) + { + i ^= (int)(((targ_ullong) l1) <= ((targ_ullong) l2)); + } + else + { + if (tyfloating(tym)) + i ^= (int)(d1 <= d2); + else + i ^= (int)(l1 <= l2); + } + e->EV.Vint = i; + break; + + case OPnge: + i++; + case OPge: + if (!tyfloating(tym)) + goto Lnlt; + i ^= (int)(d1 >= d2); + e->EV.Vint = i; + break; + + case OPnlt: + Lnlt: + i++; + case OPlt: + if (uns) + { + i ^= (int)(((targ_ullong) l1) < ((targ_ullong) l2)); + } + else + { + if (tyfloating(tym)) + i ^= (int)(d1 < d2); + else + i ^= (int)(l1 < l2); + } + e->EV.Vint = i; + break; + + case OPne: + i++; + case OPeqeq: + if (tyfloating(tym)) + { + switch (tybasic(tym)) + { + case TYcfloat: + if (isnan(e1->EV.Vcfloat.re) || isnan(e1->EV.Vcfloat.im) || + isnan(e2->EV.Vcfloat.re) || isnan(e2->EV.Vcfloat.im)) + i ^= 1; + else + i ^= (int)((e1->EV.Vcfloat.re == e2->EV.Vcfloat.re) && + (e1->EV.Vcfloat.im == e2->EV.Vcfloat.im)); + break; + case TYcdouble: + if (isnan(e1->EV.Vcdouble.re) || isnan(e1->EV.Vcdouble.im) || + isnan(e2->EV.Vcdouble.re) || isnan(e2->EV.Vcdouble.im)) + i ^= 1; + else + i ^= (int)((e1->EV.Vcdouble.re == e2->EV.Vcdouble.re) && + (e1->EV.Vcdouble.im == e2->EV.Vcdouble.im)); + break; + case TYcldouble: + if (isnan(e1->EV.Vcldouble.re) || isnan(e1->EV.Vcldouble.im) || + isnan(e2->EV.Vcldouble.re) || isnan(e2->EV.Vcldouble.im)) + i ^= 1; + else + i ^= (int)((e1->EV.Vcldouble.re == e2->EV.Vcldouble.re) && + (e1->EV.Vcldouble.im == e2->EV.Vcldouble.im)); + break; + default: + i ^= (int)(d1 == d2); + break; + } + //printf("%Lg + %Lgi, %Lg + %Lgi\n", e1->EV.Vcldouble.re, e1->EV.Vcldouble.im, e2->EV.Vcldouble.re, e2->EV.Vcldouble.im); + } + else + i ^= (int)(l1 == l2); + e->EV.Vint = i; + break; + +#if __DMC__ + case OPord: + i++; + case OPunord: + // BUG: complex numbers + i ^= d1 !<>= d2; + e->EV.Vint = i; + break; + + case OPnlg: + i++; + case OPlg: + // BUG: complex numbers + i ^= d1 <> d2; + e->EV.Vint = i; + break; + + case OPnleg: + i++; + case OPleg: + // BUG: complex numbers + i ^= d1 <>= d2; + e->EV.Vint = i; + break; + + case OPnule: + i++; + case OPule: + // BUG: complex numbers + i ^= d1 !> d2; + e->EV.Vint = i; + break; + + case OPnul: + i++; + case OPul: + // BUG: complex numbers + i ^= d1 !>= d2; + e->EV.Vint = i; + break; + + case OPnuge: + i++; + case OPuge: + // BUG: complex numbers + i ^= d1 !< d2; + e->EV.Vint = i; + break; + + case OPnug: + i++; + case OPug: + // BUG: complex numbers + i ^= d1 !<= d2; + e->EV.Vint = i; + break; + + case OPnue: + i++; + case OPue: + // BUG: complex numbers + i ^= d1 !<> d2; + e->EV.Vint = i; + break; + +#endif + case OPs16_32: + e->EV.Vlong = (targ_short) i1; + break; +#if TARGET_SEGMENTED + case OPnp_fp: +#endif + case OPu16_32: + e->EV.Vulong = (targ_ushort) i1; + break; + case OPd_u32: + e->EV.Vulong = (targ_ulong)d1; + //printf("OPd_u32: dbl = %g, ulng = x%lx\n",d1,e->EV.Vulong); + break; + case OPd_s32: + e->EV.Vlong = (targ_long)d1; + break; + case OPu32_d: + e->EV.Vdouble = (unsigned) l1; + break; + case OPs32_d: + e->EV.Vdouble = (int) l1; + break; + case OPd_s16: + e->EV.Vint = (targ_int)d1; + break; + case OPs16_d: + e->EV.Vdouble = (targ_short) i1; + break; + case OPd_u16: + e->EV.Vushort = (targ_ushort)d1; + break; + case OPu16_d: + e->EV.Vdouble = (targ_ushort) i1; + break; + case OPd_s64: + e->EV.Vllong = (targ_llong)d1; + break; + case OPd_u64: + case OPld_u64: + e->EV.Vullong = (targ_ullong)d1; + break; + case OPs64_d: + e->EV.Vdouble = l1; + break; + case OPu64_d: + e->EV.Vdouble = (targ_ullong) l1; + break; + case OPd_f: + //assert((_status87() & 0x3800) == 0); + e->EV.Vfloat = e1->EV.Vdouble; + if (tycomplex(tym)) + e->EV.Vcfloat.im = e1->EV.Vcdouble.im; + //assert((_status87() & 0x3800) == 0); + break; + case OPf_d: + e->EV.Vdouble = e1->EV.Vfloat; + if (tycomplex(tym)) + e->EV.Vcdouble.im = e1->EV.Vcfloat.im; + break; + case OPd_ld: + e->EV.Vldouble = e1->EV.Vdouble; + if (tycomplex(tym)) + e->EV.Vcldouble.im = e1->EV.Vcdouble.im; + break; + case OPld_d: + e->EV.Vdouble = e1->EV.Vldouble; + if (tycomplex(tym)) + e->EV.Vcdouble.im = e1->EV.Vcldouble.im; + break; + case OPc_r: + e->EV = e1->EV; + break; + case OPc_i: + switch (tym) + { + case TYcfloat: + e->EV.Vfloat = e1->EV.Vcfloat.im; + break; + case TYcdouble: + e->EV.Vdouble = e1->EV.Vcdouble.im; + break; + case TYcldouble: + e->EV.Vldouble = e1->EV.Vcldouble.im; + break; + default: + assert(0); + } + break; + case OPs8_16: + e->EV.Vint = (targ_schar) i1; + break; + case OPu8_16: + e->EV.Vint = i1 & 0xFF; + break; + case OP16_8: + e->EV.Vint = i1; + break; + case OPbool: + e->EV.Vint = boolres(e1); + break; + case OP32_16: +#if TARGET_SEGMENTED + case OPoffset: +#endif + e->EV.Vint = l1; + break; + + case OP64_32: + e->EV.Vlong = l1; + break; + case OPs32_64: + e->EV.Vllong = (targ_long) l1; + break; + case OPu32_64: + e->EV.Vllong = (targ_ulong) l1; + break; + + case OP128_64: + e->EV.Vllong = e1->EV.Vcent.lsw; + break; + case OPs64_128: + e->EV.Vcent.lsw = e1->EV.Vllong; + e->EV.Vcent.msw = 0; + if ((targ_llong)e->EV.Vcent.lsw < 0) + e->EV.Vcent.msw = ~(targ_ullong)0; + break; + case OPu64_128: + e->EV.Vcent.lsw = e1->EV.Vullong; + e->EV.Vcent.msw = 0; + break; + + case OPmsw: + switch (tysize(tym)) + { + case 4: + e->EV.Vllong = (l1 >> 16) & 0xFFFF; + break; + case 8: + e->EV.Vllong = (l1 >> 32) & 0xFFFFFFFF; + break; + case 16: + e->EV.Vllong = e1->EV.Vcent.msw; + break; + default: + assert(0); + } + break; + case OPb_8: + e->EV.Vlong = i1 & 1; + break; + case OPbswap: + e->EV.Vint = ((i1 >> 24) & 0x000000FF) | + ((i1 >> 8) & 0x0000FF00) | + ((i1 << 8) & 0x00FF0000) | + ((i1 << 24) & 0xFF000000); + break; + case OProl: + case OPror: + { unsigned n = i2; + if (op == OPror) + n = -n; + switch (tysize(tym)) + { + case 1: + n &= 7; + e->EV.Vuchar = (unsigned char)((i1 << n) | ((i1 & 0xFF) >> (8 - n))); + break; + case 2: + n &= 0xF; + e->EV.Vushort = (targ_ushort)((i1 << n) | ((i1 & 0xFFFF) >> (16 - n))); + break; + case 4: + n &= 0x1F; + e->EV.Vulong = (targ_ulong)((i1 << n) | ((i1 & 0xFFFFFFFF) >> (32 - n))); + break; + case 8: + n &= 0x3F; + e->EV.Vullong = (targ_ullong)((l1 << n) | ((l1 & 0xFFFFFFFFFFFFFFFFLL) >> (64 - n))); + break; + //case 16: + default: + assert(0); + } + break; + } + case OPind: +#if 0 && MARS + /* The problem with this is that although the only reaching definition + * of the variable is null, it still may never get executed, as in: + * int* p = null; if (p) *p = 3; + * and the error will be spurious. + */ + if (l1 >= 0 && l1 < 4096) + { + error(e->Esrcpos.Sfilename, e->Esrcpos.Slinnum, "dereference of null pointer"); + e->E1->EV.Vlong = 4096; // suppress redundant messages + } +#endif + return e; + default: + return e; + } +#if TX86 + int flags; + + if (!ignore_exceptions && + (config.flags4 & CFG4fastfloat) == 0 && +#if __OpenBSD__ + 1 // until OpenBSD supports C standard fenv.h +#else + _status87() & 0x3F +#endif + ) + { + // Exceptions happened. Do not fold the constants. + *e = esave; + return e; + } +#if SCPP + else if ((flags = _status87()) & 0x3F) + { // Should also give diagnostic warning for: + // overflow, underflow, denormal, invalid + if (flags & 0x04) + warerr(WM_divby0); +// else if (flags & 0x08) // overflow +// warerr(WM_badnumber); + } +#endif +#endif + + /*dbg_printf("result = x%lx\n",e->EV.Vlong);*/ + e->Eoper = OPconst; + el_free(e1); + if (e2) + el_free(e2); +#if !__GNUC__ + //printf("2: %x\n", _status87()); + assert((_status87() & 0x3800) == 0); +#endif + //printf("evalu8() returns: "); elem_print(e); + return e; +} + +#endif /* !SPP */ diff --git a/backend/exh.h b/backend/exh.h new file mode 100644 index 00000000..12a15c7c --- /dev/null +++ b/backend/exh.h @@ -0,0 +1,47 @@ +// Copyright (C) 1993-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +//#pragma once +#ifndef EXCEPT_H +#define EXCEPT_H 1 + +struct Aobject +{ + symbol *AOsym; // symbol for active object + targ_size_t AOoffset; // offset from that object + symbol *AOfunc; // cleanup function +}; + + +/* except.c */ +void except_init(void); +void except_term(void); +elem *except_obj_ctor(elem *e,symbol *s,targ_size_t offset,symbol *sdtor); +elem *except_obj_dtor(elem *e,symbol *s,targ_size_t offset); +elem *except_throw_expression(void); +type *except_declaration(symbol *cv); +void except_exception_spec(type *t); +void except_index_set(int index); +int except_index_get(void); +void except_pair_setoffset(void *p,targ_size_t offset); +void except_pair_append(void *p, int index); +void except_push(void *p,elem *e,block *b); +void except_pop(void *p,elem *e,block *b); +void except_mark(); +void except_release(); +symbol *except_gensym(); +symbol *except_gentables(); +void except_fillInEHTable(symbol *s); +void except_reset(); + +#endif + diff --git a/backend/gdag.c b/backend/gdag.c new file mode 100644 index 00000000..9cd9af4c --- /dev/null +++ b/backend/gdag.c @@ -0,0 +1,852 @@ +// Copyright (C) 1986-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if (SCPP || MARS) && !HTOD + +#include +#include + +#include "cc.h" +#include "global.h" +#include "el.h" +#include "go.h" +#include "ty.h" +#include "oper.h" +#include "vec.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +STATIC void aewalk(elem **pn , vec_t ae); +STATIC elem * delcse(elem **pe); +STATIC void removecses(elem **pe); +STATIC void boundscheck(elem *e, vec_t ae); + +enum Aetype { AEcse, AEarraybounds }; +static Aetype aetype; + +/************************************* + * Determine if floating point should be cse'd. + */ + +inline int cse_float(elem *e) +{ +#if TX86 + // Don't CSE floating stuff if generating + // inline 8087 code, the code generator + // can't handle it yet + return !(tyfloating(e->Ety) && config.inline8087 && + e->Eoper != OPvar && e->Eoper != OPconst); +#else + return 1; +#endif +} + +/************************************ + * Build DAGs (basically find all the common subexpressions). + * Must be done after all other optimizations, because most + * of them depend on the trees being trees, not DAGs. + * The general strategy is: + * Compute available expressions (AEs) + * For each block + * stick together nodes that match, keeping AEs up to date + * For each block + * unstick unprofitable common subexpressions + * (this is generally target-dependent) + */ + +void builddags() +{ register unsigned i; + register vec_t aevec; + + cmes("builddags()\n"); + assert(dfo); + flowae(); /* compute available expressions */ + if (exptop <= 1) /* if no AEs */ + return; + aetype = AEcse; +#ifdef DEBUG + for (i = 0; i < exptop; i++) + { + //dbg_printf("expnod[%d] = %p\n",i,expnod[i]); + if (expnod[i]) + elem_debug(expnod[i]); + } +#endif +#if 0 + dbg_printf("defkill "); vec_println(defkill,exptop); + dbg_printf("starkill "); vec_println(starkill,exptop); + dbg_printf("vptrkill "); vec_println(vptrkill,exptop); +#endif + +#if 0 + /* This is the 'correct' algorithm for CSEs. We can't use it */ + /* till we fix the code generator. */ + for (i = 0; i < dfotop; i++) + { register block *b; + + b = dfo[i]; + if (b->Belem) + { +#if 0 + dbg_printf("dfo[%d] = %p\n",i,b); + dbg_printf("b->Bin "); vec_println(b->Bin,exptop); + dbg_printf("b->Bout "); vec_println(b->Bout,exptop); + aewalk(&(b->Belem),b->Bin); + dbg_printf("b->Bin "); vec_println(b->Bin,exptop); + dbg_printf("b->Bout "); vec_println(b->Bout,exptop); +#else + aewalk(&(b->Belem),b->Bin); +#endif + /* Bin and Bout would be equal at this point */ + /* except that we deleted some elems from */ + /* expnod[] and so it's a subset of Bout */ + /* assert(veceq(b->Bin,b->Bout)); */ + } + } +#else + /* Do CSEs across extended basic blocks only. This is because */ + /* the code generator can only track register contents */ + /* properly across extended basic blocks. */ + aevec = vec_calloc(exptop); + for (i = 0; i < dfotop; i++) + { register block *b; + + b = dfo[i]; + /* if not first block and (there are more than one */ + /* predecessor or the only predecessor is not the */ + /* previous block), then zero out the available */ + /* expressions. */ + if ((i != 0 && + (list_block(b->Bpred) != dfo[i - 1] || + list_next(b->Bpred) != NULL)) + || b->BC == BCasm + || b->BC == BC_finally +#if SCPP + || b->BC == BCcatch +#endif +#if MARS + || b->BC == BCjcatch +#endif + ) + vec_clear(aevec); + if (b->Belem) /* if there is an expression */ + aewalk(&(b->Belem),aevec); + + } + vec_free(aevec); +#endif + // Need 2 passes to converge on solution + for (int j = 0; j < 2; j++) + for (i = 0; i < dfotop; i++) + { register block *b; + + b = dfo[i]; + if (b->Belem) + { +#if 0 + dbg_printf("b = 0x%x\n",b); +#endif + removecses(&(b->Belem)); + } + } +} + +/********************************** + */ + +STATIC void aeclear(elem *n,vec_t ae) +{ int i; + + i = n->Eexp; + assert(i); + if (n->Ecount == 0) + { + expnod[i] = 0; + vec_clearbit(i,ae); + if (EUNA(n)) + aeclear(n->E1,ae); + else if (EBIN(n)) + { aeclear(n->E1,ae); + aeclear(n->E2,ae); + } + } +} + +/**************************** + * Walk tree, building DAG as we go. + * ae = vector of available expressions + */ + +STATIC void aewalk(register elem **pn,register vec_t ae) +{ register vec_t aer; + register unsigned i,op; + register elem *n,*t; + + n = *pn; + assert(n && ae); + //printf("visiting %d: (",n->Eexp); WReqn(*pn); dbg_printf(")\n"); + //chkvecdim(exptop); + op = n->Eoper; + if (n->Eexp) // if an AE + { // Try to find an equivalent AE, and point to it instead + assert(expnod[n->Eexp] == n); + if (aetype == AEcse) + { + foreach (i,exptop,ae) + { elem *e = expnod[i]; + + // Attempt to replace n with e + if (e == NULL) // if elem no longer exists + vec_clearbit(i,ae); // it's not available + else if (n != e && + el_match(n,e) && + e->Ecount < 0xFF-1 && // must fit in unsigned char + cse_float(n) + ) + { + *pn = e; // replace n with e + //dbg_printf("cse: %p (",n); WReqn(*pn); dbg_printf(")\n"); + e->Ecount++; +#ifdef DEBUG + assert(e->Ecount != 0); +#endif + aeclear(n,ae); + el_free(n); + return; + } + } + } + } + switch (op) + { case OPcolon: + case OPcolon2: + // ae = ae & ael & aer + // AEs gened by ael and aer are mutually exclusive + aer = vec_clone(ae); + aewalk(&(n->E1),ae); + aewalk(&(n->E2),aer); + vec_andass(ae,aer); + vec_free(aer); + break; + case OPandand: + case OPoror: + aewalk(&(n->E1),ae); + /* ae &= aer */ + aer = vec_clone(ae); + aewalk(&(n->E2),aer); + if (!el_noreturn(n->E2)) + vec_andass(ae,aer); + vec_free(aer); + break; + case OPnegass: + t = Elvalue(n); + if (t->Eoper == OPind) + aewalk(&(t->E1),ae); + break; + case OPctor: + case OPdtor: + case OPdctor: + break; + case OPasm: + vec_clear(ae); // kill everything + return; + + default: + if (OTbinary(op)) + { if (ERTOL(n)) + { + // Don't CSE constants that will turn into + // an INC or DEC anyway + if (n->E2->Eoper == OPconst && + n->E2->EV.Vint == 1 && + (op == OPaddass || op == OPminass || + op == OPpostinc || op == OPpostdec) + ) + ; + else + aewalk(&(n->E2),ae); + } + if (OTassign(op)) + { t = Elvalue(n); + if (t->Eoper == OPind) + aewalk(&(t->E1),ae); + } + else + aewalk(&(n->E1),ae); + if (!ERTOL(n)) + aewalk(&(n->E2),ae); + } + else if (OTunary(op)) + { assert(op != OPnegass); + aewalk(&(n->E1),ae); + } + } + + if (OTdef(op)) + { + assert(n->Eexp == 0); // should not be an AE + /* remove all AEs that could be affected by this def */ + if (Eunambig(n)) // if unambiguous definition + { symbol *s; + + assert(t->Eoper == OPvar); + s = t->EV.sp.Vsym; + if (!(s->Sflags & SFLunambig)) + vec_subass(ae,starkill); + foreach (i,exptop,ae) /* for each ae elem */ + { register elem *e = expnod[i]; + + if (!e) continue; + if (OTunary(e->Eoper)) + { + if (vec_testbit(e->E1->Eexp,ae)) + continue; + } + else if (OTbinary(e->Eoper)) + { + if (vec_testbit(e->E1->Eexp,ae) && + vec_testbit(e->E2->Eexp,ae)) + continue; + } + else if (e->Eoper == OPvar) + { if (e->EV.sp.Vsym != s) + continue; + } + else + continue; + vec_clearbit(i,ae); + } + } + else /* else ambiguous definition */ + { + vec_subass(ae,defkill); + if (OTcalldef(op)) + vec_subass(ae,vptrkill); + } + + // GEN the lvalue of an assignment operator + if (OTassign(op) && !OTpost(op) && t->Eexp) + vec_setbit(t->Eexp,ae); + } + if (n->Eexp) // if an AE + { +#if TARGET_SEGMENTED + if (op == OPvp_fp || op == OPcvp_fp) + /* Invalidate all other OPvp_fps */ + vec_subass(ae,vptrkill); +#endif + + /*dbg_printf("available: ("); WReqn(n); dbg_printf(")\n"); + elem_print(n);*/ + vec_setbit(n->Eexp,ae); /* mark this elem as available */ + } +} + +/************************** + * Remove a CSE. + * Input: + * pe pointer to pointer to CSE + * Output: + * *pe new elem to replace the old + * Returns: + * *pe + */ + +STATIC elem * delcse(elem **pe) +{ elem *e; + + e = el_calloc(); + el_copy(e,*pe); +#ifdef DEBUG + if (debugc) + { dbg_printf("deleting unprofitable CSE ("); + WReqn(e); + dbg_printf(")\n"); + } +#endif + assert(e->Ecount != 0); + if (EOP(e)) + { + if (e->E1->Ecount == 0xFF-1) + { elem *ereplace; + ereplace = el_calloc(); + el_copy(ereplace,e->E1); + e->E1 = ereplace; + ereplace->Ecount = 0; + } + else + { + e->E1->Ecount++; +#ifdef DEBUG + assert(e->E1->Ecount != 0); +#endif + } + if (EBIN(e)) + { + if (e->E2->Ecount == 0xFF-1) + { elem *ereplace; + ereplace = el_calloc(); + el_copy(ereplace,e->E2); + e->E2 = ereplace; + ereplace->Ecount = 0; + } + else + { e->E2->Ecount++; +#ifdef DEBUG + assert(e->E2->Ecount != 0); +#endif + } + + } + } + --(*pe)->Ecount; +#ifdef DEBUG + assert((*pe)->Ecount != 0xFF); +#endif + (*pe)->Nflags |= NFLdelcse; // not generating node + e->Ecount = 0; +#if FLOATS_IN_CODE + if (FLT_CODESEG_CELEM(e)) + flt_record_const(e); +#endif + *pe = e; + return *pe; +} + +/****************************** + * 'Unstick' CSEs that would be unprofitable to do. These are usually + * things like addressing modes, and are usually target-dependent. + */ + +STATIC void removecses(elem **pe) +{ unsigned op; + elem *e; + +L1: e = *pe; + assert(e); + elem_debug(e); + if (e->Nflags & NFLdelcse && e->Ecount) + { + delcse(pe); + goto L1; + } + op = e->Eoper; + if (OTunary(op)) + { + if (op == OPind) + { elem *e1; + + e1 = e->E1; + if (e1->Eoper == OPadd && + e1->Ecount // == 1 + ) + { + if (I32) + { + e1 = delcse(&e->E1); + if (e1->E1->Ecount) // == 1) + delcse(&e1->E1); + if (e1->E2->Ecount && e1->E2->Eoper != OPind) + delcse(&e1->E2); + } + // Look for *(var + const). The + and the const + // shouldn't be CSEs. + else if (e1->E2->Eoper == OPconst && + (e1->E1->Eoper == OPvar || (e1->E1->Eoper == OPind && e1->E1->Ety & (mTYconst | mTYimmutable))) + ) + { + e1 = delcse(&e->E1); + } + } + + if (I32 && e1->Eoper == OPadd && + e1->E1->Eoper == OPadd && + e1->E1->E1->Ecount && + e1->E1->E1->Eoper == OPshl && + e1->E1->E1->E2->Eoper == OPconst && + e1->E1->E1->E2->EV.Vuns <= 3 + ) + { + delcse(&e1->E1->E1); + } + + if (I32 && e1->Eoper == OPadd && + e1->E1->Eoper == OPadd && + e1->E1->Ecount && + e1->E1->E1->Eoper == OPshl && + e1->E1->E1->E2->Eoper == OPconst && + e1->E1->E1->E2->EV.Vuns <= 3 + ) + { + delcse(&e1->E1); + } + + else if (I32 && e1->Eoper == OPadd && + e1->E1->Ecount && + e1->E1->Eoper == OPshl && + e1->E1->E2->Eoper == OPconst && + e1->E1->E2->EV.Vuns <= 3 + ) + { + delcse(&e1->E1); + } + + // Remove *e1 where it's a double + if (e->Ecount && tyfloating(e->Ety)) + e = delcse(pe); + } + // This CSE is too easy to regenerate + else if (op == OPu16_32 && !I32 && e->Ecount) + e = delcse(pe); + } + else if (OTbinary(op)) + { + if (e->Ecount > 0 && OTrel(op) && e->Ecount < 4 +#if TX86 + /* Don't CSE floating stuff if generating */ + /* inline 8087 code, the code generator */ + /* can't handle it yet */ + && !(tyfloating(e->E1->Ety) && config.inline8087) +#endif + ) + e = delcse(pe); + removecses(&(e->E2)); + } + else /* leaf node */ + { + return; + } + pe = &(e->E1); + goto L1; +} + +/***************************************** + * Do optimizations based on if we know an expression is + * 0 or !=0, even though we don't know anything else. + */ + +STATIC void abewalk(elem *n,vec_t ae,vec_t aeval); +STATIC void abeboolres(elem *n,vec_t abe,vec_t abeval); +STATIC void abefree(elem *e,vec_t abe); +STATIC void abeset(elem *n,vec_t abe,vec_t abeval,int flag); + +void boolopt() +{ unsigned i; + vec_t aevec; + vec_t aevecval; + + cmes("boolopt()\n"); + if (!dfo) + compdfo(); + flowae(); /* compute available expressions */ + if (exptop <= 1) /* if no AEs */ + return; +#if 0 + for (i = 0; i < exptop; i++) + dbg_printf("expnod[%d] = 0x%x\n",i,expnod[i]); + dbg_printf("defkill "); vec_println(defkill,exptop); + dbg_printf("starkill "); vec_println(starkill,exptop); + dbg_printf("vptrkill "); vec_println(vptrkill,exptop); +#endif + + /* Do CSEs across extended basic blocks only. This is because */ + /* the code generator can only track register contents */ + /* properly across extended basic blocks. */ + aevec = vec_calloc(exptop); + aevecval = vec_calloc(exptop); + + // Mark each expression that we know starts off with a non-zero value + for (i = 0; i < exptop; i++) + { elem *e = expnod[i]; + + if (e) + { elem_debug(e); + if (e->Eoper == OPvar && e->EV.sp.Vsym->Sflags & SFLtrue) + { vec_setbit(i,aevec); + vec_setbit(i,aevecval); + } + } + } + + for (i = 0; i < dfotop; i++) + { register block *b; + + b = dfo[i]; + /* if not first block and (there are more than one */ + /* predecessor or the only predecessor is not the */ + /* previous block), then zero out the available */ + /* expressions. */ + if ((i != 0 && + (list_block(b->Bpred) != dfo[i - 1] || + list_next(b->Bpred) != NULL)) + || b->BC == BCasm + ) + vec_clear(aevec); + if (b->Belem) /* if there is an expression */ + abewalk(b->Belem,aevec,aevecval); + + } + vec_free(aevec); + vec_free(aevecval); +} + +/**************************** + * Walk tree, replacing bool expressions that we know + * ae = vector of available boolean expressions + * aeval = parallel vector of values corresponding to whether bool + * value is 1 or 0 + * n = elem tree to look at + */ + +STATIC void abewalk(elem *n,vec_t ae,vec_t aeval) +{ vec_t aer,aerval; + unsigned i,op; + unsigned i1,i2; + elem *t; + + assert(n && ae); + elem_debug(n); + /*dbg_printf("visiting: ("); WReqn(*pn); dbg_printf("), Eexp = %d\n",n->Eexp);*/ + /*chkvecdim(exptop);*/ + op = n->Eoper; + switch (op) + { case OPcolon: + case OPcolon2: + /* ae = ae & ael & aer */ + /* AEs gened by ael and aer are mutually exclusive */ + aer = vec_clone(ae); + aerval = vec_clone(aeval); + abewalk(n->E1,ae,aeval); + goto L1; + case OPandand: + case OPoror: + abewalk(n->E1,ae,aeval); + abeboolres(n->E1,ae,aeval); + /* ae &= aer */ + aer = vec_clone(ae); + aerval = vec_clone(aeval); + abeset(n->E1,aer,aerval,(op == OPandand)); + L1: + abewalk(n->E2,aer,aerval); + if (!el_noreturn(n->E2)) + { vec_xorass(aerval,aeval); + vec_subass(aer,aerval); + vec_andass(ae,aer); + } + vec_free(aer); + vec_free(aerval); + break; + case OPbool: + case OPnot: + abewalk(n->E1,ae,aeval); + abeboolres(n->E1,ae,aeval); + break; + case OPnegass: + t = Elvalue(n); + if (t->Eoper == OPind) + abewalk(t->E1,ae,aeval); + break; + + case OPasm: + vec_clear(ae); // kill everything + return; + + default: + if (OTbinary(op)) + { if (ERTOL(n)) + abewalk(n->E2,ae,aeval); + if (OTassign(op)) + { t = Elvalue(n); + if (t->Eoper == OPind) + abewalk(t->E1,ae,aeval); + } + else + abewalk(n->E1,ae,aeval); + if (!ERTOL(n)) + abewalk(n->E2,ae,aeval); + } + else if (OTunary(op)) + abewalk(n->E1,ae,aeval); + break; + } + + if (OTdef(op)) + { assert(n->Eexp == 0); // should not be an AE + /* remove all AEs that could be affected by this def */ + if (Eunambig(n)) /* if unambiguous definition */ + { symbol *s; + + assert(t->Eoper == OPvar); + s = t->EV.sp.Vsym; + if (!(s->Sflags & SFLunambig)) + vec_subass(ae,starkill); + foreach (i,exptop,ae) /* for each ae elem */ + { register elem *e = expnod[i]; + + if (!e) continue; + if (OTunary(e->Eoper)) + { + if (vec_testbit(e->E1->Eexp,ae)) + continue; + } + else if (OTbinary(e->Eoper)) + { + if (vec_testbit(e->E1->Eexp,ae) && + vec_testbit(e->E2->Eexp,ae)) + continue; + } + else if (e->Eoper == OPvar) + { if (e->EV.sp.Vsym != s) + continue; + } + else + continue; + vec_clearbit(i,ae); + } + } + else /* else ambiguous definition */ + { + vec_subass(ae,defkill); + if (OTcalldef(op)) + vec_subass(ae,vptrkill); + } + /* GEN the lvalue of an assignment operator */ +#if 1 + if (op == OPeq && (i1 = t->Eexp) != 0 && (i2 = n->E2->Eexp) != 0) + { + if (vec_testbit(i2,ae)) + { + vec_setbit(i1,ae); + if (vec_testbit(i2,aeval)) + vec_setbit(i1,aeval); + else + vec_clearbit(i1,aeval); + } + } +#else + if ((OTopeq(op) || op == OPeq || op == OPnegass) && n->E1->Eexp) + { vec_setbit(t->Eexp,ae); + if (n->E1->Eoper == OPbit) + vec_setbit(n->E1->Eexp,ae); + } +#endif + } + else if (n->Eexp) /* if an AE */ + { +#if TARGET_SEGMENTED + if (op == OPvp_fp || op == OPcvp_fp) + /* Invalidate all other OPvp_fps */ + vec_subass(ae,vptrkill); +#endif + + /*dbg_printf("available: ("); WReqn(n); dbg_printf(")\n"); + elem_print(n);*/ +// vec_setbit(n->Eexp,ae); /* mark this elem as available */ + } +} + +/************************************ + * Elem e is to be evaluated for a boolean result. + * See if we already know its value. + */ + +STATIC void abeboolres(elem *n,vec_t ae,vec_t aeval) +{ unsigned i; + + elem_debug(n); + if (n->Eexp) + { /* Try to find an equivalent AE, and point to it instead */ + assert(expnod[n->Eexp] == n); + foreach (i,exptop,ae) + { elem *e = expnod[i]; + + // Attempt to replace n with e + //dbg_printf("Looking at expnod[%d] = %p\n",i,e); + assert(e); + elem_debug(e); + if (n != e && el_match(n,e)) + { +#ifdef DEBUG + if (debugc) + { dbg_printf("Elem %p: ",n); + WReqn(n); + dbg_printf(" is replaced by %d\n",vec_testbit(i,aeval) != 0); + } +#endif + abefree(n,ae); + n->EV.Vlong = vec_testbit(i,aeval) != 0; + n->Eoper = OPconst; + n->Ety = TYint; + changes++; + break; + } + } + } +} + +/**************************** + * Remove e from available expressions, and its children. + */ + +STATIC void abefree(elem *e,vec_t ae) +{ + //dbg_printf("abefree %p: "); WReqn(e); dbg_printf("\n"); + assert(e->Eexp); + vec_clearbit(e->Eexp,ae); + expnod[e->Eexp] = NULL; + if (EOP(e)) + { if (EBIN(e)) + { abefree(e->E2,ae); + el_free(e->E2); + e->E2 = NULL; + } + abefree(e->E1,ae); + el_free(e->E1); + e->E1 = NULL; + } +} + +/************************************ + * Elem e is to be evaluated for a boolean result. + * Set its result according to flag. + */ + +STATIC void abeset(elem *e,vec_t ae,vec_t aeval,int flag) +{ unsigned i; + + while (1) + { + i = e->Eexp; + if (i && expnod[i]) + { + //dbg_printf("abeset for expnod[%d] = %p: ",i,e); WReqn(e); dbg_printf("\n"); + vec_setbit(i,ae); + if (flag) + vec_setbit(i,aeval); + else + vec_clearbit(i,aeval); + } + switch (e->Eoper) + { case OPnot: + flag ^= 1; + case OPbool: + case OPeq: + e = e->E1; + continue; + } + break; + } +} + +#endif diff --git a/backend/gflow.c b/backend/gflow.c new file mode 100644 index 00000000..5a92125a --- /dev/null +++ b/backend/gflow.c @@ -0,0 +1,1721 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if (SCPP || MARS) && !HTOD + +#include +#include + +#include "cc.h" +#include "global.h" +#include "el.h" +#include "go.h" +#include "type.h" +#include "oper.h" +#include "vec.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/* Since many routines are nearly identical, we can combine them with */ +/* this flag: */ + +#define AE 1 +#define CP 2 +#define VBE 3 + +static int flowxx; /* one of the above values */ + +static vec_t ambigsym = NULL; + +STATIC void rdgenkill(void); +STATIC void numdefelems(elem *n); +STATIC void asgdefelems(block *b , elem *n); +STATIC void aecpgenkill(void); +STATIC int numaeelems(elem *n); +STATIC void numcpelems(elem *n); +STATIC void asgexpelems(elem *n); +STATIC void defstarkill(void); +STATIC void rdelem(vec_t *pgen , vec_t *pkill , elem *n); +STATIC void aecpelem(vec_t *pgen , vec_t *pkill , elem *n); +STATIC void accumaecp(vec_t GEN , vec_t KILL , elem *n); +STATIC void accumaecpx(elem *n); +STATIC void lvgenkill(void); +STATIC void lvelem(vec_t *pgen , vec_t *pkill , elem *n); +STATIC void accumlv(vec_t GEN , vec_t KILL , elem *n); +STATIC void accumvbe(vec_t GEN , vec_t KILL , elem *n); +STATIC void accumrd(vec_t GEN , vec_t KILL , elem *n); +STATIC void flowaecp(void); + +/***************** REACHING DEFINITIONS *********************/ + +/************************************ + * Compute reaching definitions (RDs). + * That is, for each block B and each program variable X + * find all elems that could be the last elem that defines + * X along some path to B. + * Binrd = the set of defs reaching the beginning of B. + * Boutrd = the set of defs reaching the end of B. + * Bkillrd = set of defs that are killed by some def in B. + * Bgenrd = set of defs in B that reach the end of B. + */ + +void flowrd() +{ register vec_t tmp; + register unsigned i; + register bool anychng; + + rdgenkill(); /* Compute Bgen and Bkill for RDs */ + if (deftop == 0) /* if no definition elems */ + return; /* no analysis to be done */ + + /* The transfer equation is: */ + /* Bin = union of Bouts of all predecessors of B. */ + /* Bout = (Bin - Bkill) | Bgen */ + /* Using Ullman's algorithm: */ + + for (i = 0; i < dfotop; i++) + vec_copy(dfo[i]->Boutrd,dfo[i]->Bgen); + + tmp = vec_calloc(deftop); + do + { anychng = FALSE; + for (i = 0; i < dfotop; i++) /* for each block */ + { register block *b; + register list_t bp; + + b = dfo[i]; + + /* Binrd = union of Boutrds of all predecessors of b */ + vec_clear(b->Binrd); + if (b->BC != BCcatch /*&& b->BC != BCjcatch*/) + { + /* Set Binrd to 0 to account for: + * i = 0; + * try { i = 1; throw; } catch () { x = i; } + */ + for (bp = b->Bpred; bp; bp = list_next(bp)) + vec_orass(b->Binrd,list_block(bp)->Boutrd); + } + /* Bout = (Bin - Bkill) | Bgen */ + vec_sub(tmp,b->Binrd,b->Bkill); + vec_orass(tmp,b->Bgen); + if (!anychng) + anychng = !vec_equal(tmp,b->Boutrd); + vec_copy(b->Boutrd,tmp); + } + } while (anychng); /* while any changes to Boutrd */ + vec_free(tmp); + +#if 0 + dbg_printf("Reaching definitions\n"); + for (i = 0; i < dfotop; i++) + { register block *b = dfo[i]; + + assert(vec_numbits(b->Binrd) == deftop); + dbg_printf("B%d Bin ",i); vec_println(b->Binrd); + dbg_printf(" Bgen "); vec_println(b->Bgen); + dbg_printf(" Bkill "); vec_println(b->Bkill); + dbg_printf(" Bout "); vec_println(b->Boutrd); + } +#endif +} + +/*************************** + * Compute Bgen and Bkill for RDs. + */ + +STATIC void rdgenkill() +{ register unsigned i,deftopsave; + + util_free(defnod); /* free existing junk */ + + defnod = NULL; + + /* Compute number of definition elems. */ + deftop = 0; + for (i = 0; i < dfotop; i++) + if (dfo[i]->Belem) + { + numdefelems(dfo[i]->Belem); + } + if (deftop == 0) + return; + + /* Allocate array of pointers to all definition elems */ + /* The elems are in dfo order. */ + /* defnod[]s consist of a elem pointer and a pointer */ + /* to the enclosing block. */ + defnod = (dn *) util_calloc(sizeof(dn),deftop); + deftopsave = deftop; + deftop = 0; + for (i = 0; i < dfotop; i++) + if (dfo[i]->Belem) + asgdefelems(dfo[i],dfo[i]->Belem); + assert(deftop == deftopsave); + + for (i = 0; i < dfotop; i++) /* for each block */ + { register block *b = dfo[i]; + + /* dump any existing vectors */ + vec_free(b->Bgen); + vec_free(b->Bkill); + vec_free(b->Binrd); + vec_free(b->Boutrd); + + /* calculate and create new vectors */ + rdelem(&(b->Bgen),&(b->Bkill),b->Belem); + if (b->BC == BCasm) + { vec_clear(b->Bkill); // KILL nothing + vec_set(b->Bgen); // GEN everything + } + b->Binrd = vec_calloc(deftop); + b->Boutrd = vec_calloc(deftop); + } +} + +/********************** + * Compute # of definition elems (deftop). + */ + +STATIC void numdefelems(register elem *n) +{ + while (1) + { assert(n); + if (OTdef(n->Eoper)) + deftop++; + if (OTbinary(n->Eoper)) + { + numdefelems(n->E1); + n = n->E2; + } + else if (OTunary(n->Eoper)) + { + n = n->E1; + } + else + break; + } +} + +/************************** + * Load defnod[] array. + * Loaded in order of execution of the elems. Not sure if this is + * necessary. + */ + +STATIC void asgdefelems(block *b,register elem *n) +{ register unsigned op; + + assert(b && n); + op = n->Eoper; + if (ERTOL(n)) + { asgdefelems(b,n->E2); + asgdefelems(b,n->E1); + } + else if (OTbinary(op)) + { asgdefelems(b,n->E1); + asgdefelems(b,n->E2); + } + else if (OTunary(op)) + asgdefelems(b,n->E1); + if (OTdef(op)) + { assert(defnod); + defnod[deftop].DNblock = b; + defnod[deftop].DNelem = n; + deftop++; + } +} + +/************************************* + * Allocate and compute rd GEN and KILL. + */ + +STATIC void rdelem(vec_t *pgen,vec_t *pkill, /* where to put result */ + elem *n ) /* tree to evaluate for GEN and KILL */ +{ + *pgen = vec_calloc(deftop); + *pkill = vec_calloc(deftop); + if (n) + accumrd(*pgen,*pkill,n); +} + +/************************************** + * Accumulate GEN and KILL vectors for this elem. + */ + +STATIC void accumrd(vec_t GEN,vec_t KILL,elem *n) +{ vec_t Gl,Kl,Gr,Kr; + unsigned op; + + assert(GEN && KILL && n); + op = n->Eoper; + if (OTunary(op)) + accumrd(GEN,KILL,n->E1); + else if (OTbinary(op)) + { + if (op == OPcolon || op == OPcolon2) + { + rdelem(&Gl,&Kl,n->E1); + rdelem(&Gr,&Kr,n->E2); + + /* GEN = (GEN - Kl) | Gl | */ + /* (GEN - Kr) | Gr */ + /* KILL |= Kl & Kr */ + + vec_orass(Gl,Gr); + vec_sub(Gr,GEN,Kl); + vec_orass(Gl,Gr); + vec_sub(Gr,GEN,Kr); + vec_or(GEN,Gl,Gr); + + vec_andass(Kl,Kr); + vec_orass(KILL,Kl); + + vec_free(Gl); + vec_free(Kl); + vec_free(Gr); + vec_free(Kr); + } + else if (op == OPandand || op == OPoror) + { + accumrd(GEN,KILL,n->E1); + rdelem(&Gr,&Kr,n->E2); + vec_orass(GEN,Gr); /* GEN |= Gr */ + + vec_free(Gr); + vec_free(Kr); + } + else if (OTrtol(op) && ERTOL(n)) + { accumrd(GEN,KILL,n->E2); + accumrd(GEN,KILL,n->E1); + } + else + { accumrd(GEN,KILL,n->E1); + accumrd(GEN,KILL,n->E2); + } + } + + if (OTdef(op)) /* if definition elem */ + updaterd(n,GEN,KILL); +} + +/******************** AVAILABLE EXPRESSIONS ***********************/ + +/************************************ + * Compute available expressions (AEs). + * That is, expressions whose result is still current. + * Bin = the set of AEs reaching the beginning of B. + * Bout = the set of AEs reaching the end of B. + */ + +void flowae() +{ + flowxx = AE; + flowaecp(); +} + +/**************************** COPY PROPAGATION ************************/ + +/*************************************** + * Compute copy propagation info (CPs). + * Very similar to AEs (the same code is used). + * Using RDs for copy propagation is WRONG! + * That is, set of copy statements still valid. + * Bin = the set of CPs reaching the beginning of B. + * Bout = the set of CPs reaching the end of B. + */ + +void flowcp() +{ + flowxx = CP; + flowaecp(); +} + +/***************************************** + * Common flow analysis routines for Available Expressions and + * Copy Propagation. + * Input: + * flowxx + */ + +STATIC void flowaecp() +{ vec_t tmp; + register unsigned i; + bool anychng; + + aecpgenkill(); /* Compute Bgen and Bkill for AEs or CPs */ + if (exptop <= 1) /* if no expressions */ + return; + + /* The transfer equation is: */ + /* Bin = & Bout(all predecessors P of B) */ + /* Bout = (Bin - Bkill) | Bgen */ + /* Using Ullman's algorithm: */ + + vec_clear(startblock->Bin); + vec_copy(startblock->Bout,startblock->Bgen); /* these never change */ + if (startblock->BC == BCiftrue) + vec_copy(startblock->Bout2,startblock->Bgen2); // these never change + + /* For all blocks except startblock */ + for (i = 1; i < dfotop; i++) + { register block *b = dfo[i]; + + vec_set(b->Bin); /* Bin = all expressions */ + + /* Bout = (Bin - Bkill) | Bgen */ + vec_sub(b->Bout,b->Bin,b->Bkill); + vec_orass(b->Bout,b->Bgen); + if (b->BC == BCiftrue) + { vec_sub(b->Bout2,b->Bin,b->Bkill2); + vec_orass(b->Bout2,b->Bgen2); + } + } + + tmp = vec_calloc(exptop); + do + { anychng = FALSE; + + // For all blocks except startblock + for (i = 1; i < dfotop; i++) + { block *b = dfo[i]; + list_t bl = b->Bpred; + block *bp; + + // Bin = & of Bout of all predecessors + // Bout = (Bin - Bkill) | Bgen + + assert(bl); // it must have predecessors + bp = list_block(bl); + if (bp->BC == BCiftrue && list_block(bp->Bsucc) != b) + vec_copy(b->Bin,bp->Bout2); + else + vec_copy(b->Bin,bp->Bout); + while (TRUE) + { bl = list_next(bl); + if (!bl) + break; + bp = list_block(bl); + if (bp->BC == BCiftrue && list_block(bp->Bsucc) != b) + vec_andass(b->Bin,bp->Bout2); + else + vec_andass(b->Bin,bp->Bout); + } + + if (anychng) + { vec_sub(b->Bout,b->Bin,b->Bkill); + vec_orass(b->Bout,b->Bgen); + } + else + { vec_sub(tmp,b->Bin,b->Bkill); + vec_orass(tmp,b->Bgen); + if (!vec_equal(tmp,b->Bout)) + { // Swap Bout and tmp instead of + // copying tmp over Bout + vec_t v; + + v = tmp; + tmp = b->Bout; + b->Bout = v; + anychng = TRUE; + } + } + + if (b->BC == BCiftrue) + { // Bout2 = (Bin - Bkill2) | Bgen2 + if (anychng) + { vec_sub(b->Bout2,b->Bin,b->Bkill2); + vec_orass(b->Bout2,b->Bgen2); + } + else + { vec_sub(tmp,b->Bin,b->Bkill2); + vec_orass(tmp,b->Bgen2); + if (!vec_equal(tmp,b->Bout2)) + { // Swap Bout and tmp instead of + // copying tmp over Bout2 + vec_t v; + + v = tmp; + tmp = b->Bout2; + b->Bout2 = v; + anychng = TRUE; + } + } + } + } + } while (anychng); + vec_free(tmp); +} + +/****************************** + * A variable to avoid parameter overhead to asgexpelems(). + */ + +static block *this_block; + +/*********************************** + * Compute Bgen and Bkill for AEs, CPs, and VBEs. + */ + +STATIC void aecpgenkill() +{ register unsigned i; + unsigned exptopsave; + + util_free(expnod); /* dump any existing one */ + + expnod = NULL; + + /* Compute number of expressions */ + exptop = 1; /* start at 1 */ + for (i = 0; i < dfotop; i++) + if (dfo[i]->Belem) + { if (flowxx == CP) + numcpelems(dfo[i]->Belem); + else // AE || VBE + numaeelems(dfo[i]->Belem); + } + if (exptop <= 1) /* if no expressions */ + return; + + /* Allocate array of pointers to all expression elems. */ + /* (The elems are in order. Also, these expressions must not */ + /* have any side effects, and possibly should not be machine */ + /* dependent primitive addressing modes.) */ + expnod = (elem **) util_calloc(sizeof(elem *),exptop); + util_free(expblk); + expblk = (flowxx == VBE) + ? (block **) util_calloc(sizeof(block *),exptop) : NULL; + + exptopsave = exptop; + exptop = 1; + for (i = 0; i < dfotop; i++) + { this_block = dfo[i]; /* so asgexpelems knows about this */ + if (this_block->Belem) + asgexpelems(this_block->Belem); + } + assert(exptop == exptopsave); + + defstarkill(); /* compute defkill and starkill */ + +#if 0 + assert(vec_numbits(defkill) == exptop); + assert(vec_numbits(starkill) == exptop); + assert(vec_numbits(vptrkill) == exptop); + dbg_printf("defkill "); vec_println(defkill); + if (starkill) + { dbg_printf("starkill "); vec_println(starkill);} + if (vptrkill) + { dbg_printf("vptrkill "); vec_println(vptrkill); } +#endif + + for (i = 0; i < dfotop; i++) /* for each block */ + { register block *b = dfo[i]; + elem *e; + + /* dump any existing vectors */ + vec_free(b->Bin); + vec_free(b->Bout); + vec_free(b->Bgen); + vec_free(b->Bkill); + b->Bgen = vec_calloc(exptop); + b->Bkill = vec_calloc(exptop); + switch (b->BC) + { + case BCiftrue: + vec_free(b->Bout2); + vec_free(b->Bgen2); + vec_free(b->Bkill2); + for (e = b->Belem; e->Eoper == OPcomma; e = e->E2) + accumaecp(b->Bgen,b->Bkill,e); + if (e->Eoper == OPandand || e->Eoper == OPoror) + { vec_t Kr,Gr; + + accumaecp(b->Bgen,b->Bkill,e->E1); + Kr = vec_calloc(exptop); + Gr = vec_calloc(exptop); + accumaecp(Gr,Kr,e->E2); + + // We might or might not have executed E2 + // KILL1 = KILL | Kr + // GEN1 = GEN & ((GEN - Kr) | Gr) + + // We definitely executed E2 + // KILL2 = (KILL - Gr) | Kr + // GEN2 = (GEN - Kr) | Gr + + unsigned j,dim; + dim = vec_dim(Kr); + vec_t KILL = b->Bkill; + vec_t GEN = b->Bgen; + + for (j = 0; j < dim; j++) + { vec_base_t KILL1,KILL2,GEN1,GEN2; + + KILL1 = KILL[j] | Kr[j]; + GEN1 = GEN[j] & ((GEN[j] & ~Kr[j]) | Gr[j]); + + KILL2 = (KILL[j] & ~Gr[j]) | Kr[j]; + GEN2 = (GEN[j] & ~Kr[j]) | Gr[j]; + + KILL[j] = KILL1; + GEN[j] = GEN1; + Kr[j] = KILL2; + Gr[j] = GEN2; + } + + if (e->Eoper == OPandand) + { b->Bkill = Kr; + b->Bgen = Gr; + b->Bkill2 = KILL; + b->Bgen2 = GEN; + } + else + { b->Bkill = KILL; + b->Bgen = GEN; + b->Bkill2 = Kr; + b->Bgen2 = Gr; + } + } + else + { + accumaecp(b->Bgen,b->Bkill,e); + b->Bgen2 = vec_clone(b->Bgen); + b->Bkill2 = vec_clone(b->Bkill); + } + b->Bout2 = vec_calloc(exptop); + break; + + case BCasm: + vec_set(b->Bkill); // KILL everything + vec_clear(b->Bgen); // GEN nothing + break; + + default: + // calculate GEN & KILL vectors + if (b->Belem) + accumaecp(b->Bgen,b->Bkill,b->Belem); + break; + } +#if 0 + dbg_printf("block %d Bgen ",i); vec_println(b->Bgen); + dbg_printf(" Bkill "); vec_println(b->Bkill); +#endif + b->Bin = vec_calloc(exptop); + b->Bout = vec_calloc(exptop); + } +} + +/***************************** + * Accumulate number of expressions in exptop. + * Set NFLaecp as a flag indicating an AE elem. + * Returns: + * TRUE if this elem is a possible AE elem. + */ + +STATIC int numaeelems(register elem *n) +{ register unsigned op; + unsigned ae; + + assert(n); + op = n->Eoper; + if (OTunary(op)) + { ae = numaeelems(n->E1); + // Disallow starred references to avoid problems with VBE's + // being hoisted before tests of an invalid pointer. + if (flowxx == VBE && op == OPind) + goto L1; + } + else if (OTbinary(op)) + ae = numaeelems(n->E1) & numaeelems(n->E2); + else + ae = TRUE; + + if (ae && OTae(op) && !(n->Ety & mTYvolatile) && + // Disallow struct AEs, because we can't handle CSEs that are structs + tybasic(n->Ety) != TYstruct) + { n->Nflags |= NFLaecp; /* remember for asgexpelems() */ + exptop++; + } + else + L1: + n->Nflags &= ~NFLaecp; + return n->Nflags & NFLaecp; +} + + +/**************************** + * Compute number of cp elems into exptop. + * Mark cp elems by setting NFLaecp flag. + */ + +STATIC void numcpelems(elem *n) +{ unsigned op; + + op = n->Eoper; + if (OTunary(op)) + numcpelems(n->E1); + else if (OTbinary(op)) + { numcpelems(n->E1); + numcpelems(n->E2); + + /* look for elem of the form OPvar=OPvar, where they aren't the */ + /* same variable. */ + if (op == OPeq && + n->E1->Eoper == OPvar && + n->E2->Eoper == OPvar && + !((n->E1->Ety | n->E2->Ety) & mTYvolatile) && + n->E1->EV.sp.Vsym != n->E2->EV.sp.Vsym) + { exptop++; + n->Nflags |= NFLaecp; + return; + } + } + n->Nflags &= ~NFLaecp; +} + +/******************************** + * Assign ae (or cp) elems to expnod[] (in order of evaluation). + */ + +STATIC void asgexpelems(elem *n) +{ + assert(n); + if (OTunary(n->Eoper)) + asgexpelems(n->E1); + else if (ERTOL(n)) + { asgexpelems(n->E2); + asgexpelems(n->E1); + } + else if (OTbinary(n->Eoper)) + { asgexpelems(n->E1); + asgexpelems(n->E2); + } + + if (n->Nflags & NFLaecp) /* if an ae, cp or vbe elem */ + { n->Eexp = exptop; /* remember index into expnod[] */ + expnod[exptop] = n; + if (expblk) + expblk[exptop] = this_block; + exptop++; + } + else + n->Eexp = 0; +} + +/******************************** + * Compute defkill, starkill and vptrkill vectors. + * starkill: set of expressions killed when a variable is + * changed that somebody could be pointing to. + * (not needed for cp) + * starkill is a subset of defkill. + * defkill: set of expressions killed by an ambiguous + * definition. + * vptrkill: set of expressions killed by an access to a vptr. + */ + +STATIC void defstarkill() +{ register unsigned i,op; + register elem *n; + + vec_free(vptrkill); + vec_free(defkill); + vec_free(starkill); /* dump any existing ones */ + defkill = vec_calloc(exptop); + if (flowxx != CP) + { starkill = vec_calloc(exptop); /* and create new ones */ + vptrkill = vec_calloc(exptop); /* and create new ones */ + } + else /* CP */ + { starkill = NULL; + vptrkill = NULL; + } + + if (flowxx == CP) + { + for (i = 1; i < exptop; i++) + { n = expnod[i]; + op = n->Eoper; + assert(op == OPeq); + assert(n->E1->Eoper==OPvar && n->E2->Eoper==OPvar); + + // Set bit in defkill if either the left or the + // right variable is killed by an ambiguous def. + + Symbol *s1 = n->E1->EV.sp.Vsym; + if (!(s1->Sflags & SFLunambig) || + !(n->E2->EV.sp.Vsym->Sflags & SFLunambig)) + { + vec_setbit(i,defkill); + } + } + } + else + { + for (i = 1; i < exptop; i++) + { n = expnod[i]; + op = n->Eoper; + switch (op) + { + case OPvar: + if (!(n->EV.sp.Vsym->Sflags & SFLunambig)) + vec_setbit(i,defkill); + break; + + case OPind: // if a 'starred' ref + +#if 1 +/* The following program fails for this: +import std.c.stdio; + +class Foo +{ + string foo = "abc"; + size_t i = 0; + + void bar() + { + printf("%c\n", foo[i]); + i++; + printf("%c\n", foo[i]); + } +} + +void main() +{ + auto f = new Foo(); + f.bar(); +} +*/ + // For C/C++, casting to 'const' doesn't mean it + // actually is const, + // but immutable really doesn't change + if ((n->Ety & (mTYimmutable | mTYvolatile)) == mTYimmutable && + n->E1->Eoper == OPvar && + n->E1->EV.sp.Vsym->Sflags & SFLunambig + ) + break; +#endif +#if TX86 + case OPstrlen: + case OPstrcmp: + case OPmemcmp: + case OPbt: // OPbt is like OPind +#endif + vec_setbit(i,defkill); + vec_setbit(i,starkill); + break; + +#if TARGET_SEGMENTED + case OPvp_fp: + case OPcvp_fp: + vec_setbit(i,vptrkill); + goto Lunary; +#endif + + default: + if (OTunary(op)) + { + Lunary: + if (vec_testbit(n->E1->Eexp,defkill)) + vec_setbit(i,defkill); + if (vec_testbit(n->E1->Eexp,starkill)) + vec_setbit(i,starkill); + } + else if (OTbinary(op)) + { + if (vec_testbit(n->E1->Eexp,defkill) || + vec_testbit(n->E2->Eexp,defkill)) + vec_setbit(i,defkill); + if (vec_testbit(n->E1->Eexp,starkill) || + vec_testbit(n->E2->Eexp,starkill)) + vec_setbit(i,starkill); + } + break; + } + } + } +} + +/******************************** + * Compute GEN and KILL vectors only for AEs. + * defkill and starkill are assumed to be already set up correctly. + * expnod[] is assumed to be set up correctly. + */ + +void genkillae() +{ register unsigned i; + + flowxx = AE; + assert(exptop > 1); + for (i = 0; i < dfotop; i++) + { register block *b = dfo[i]; + + assert(b); + vec_clear(b->Bgen); + vec_clear(b->Bkill); + if (b->Belem) + accumaecp(b->Bgen,b->Bkill,b->Belem); + else if (b->BC == BCasm) + { vec_set(b->Bkill); // KILL everything + vec_clear(b->Bgen); // GEN nothing + } + } +} + +/************************************ + * Allocate and compute KILL and GEN vectors for a elem. + */ + +STATIC void aecpelem(vec_t *pgen,vec_t *pkill, elem *n) +{ *pgen = vec_calloc(exptop); + *pkill = vec_calloc(exptop); + if (n) + { if (flowxx == VBE) + accumvbe(*pgen,*pkill,n); + else + accumaecp(*pgen,*pkill,n); + } +} + +/************************************* + * Accumulate GEN and KILL sets for AEs and CPs for this elem. + */ + +static vec_t GEN; // use static copies to save on parameter passing +static vec_t KILL; + +STATIC void accumaecp(vec_t g,vec_t k,elem *n) +{ vec_t GENsave,KILLsave; + + assert(g && k); + GENsave = GEN; + KILLsave = KILL; + GEN = g; + KILL = k; + accumaecpx(n); + GEN = GENsave; + KILL = KILLsave; +} + +STATIC void accumaecpx(elem *n) +{ unsigned i,op; + elem *t; + + assert(n); + elem_debug(n); + op = n->Eoper; + + switch (op) + { + case OPvar: + case OPconst: + case OPrelconst: + if ((flowxx == AE) && n->Eexp) + { unsigned b; +#ifdef DEBUG + assert(expnod[n->Eexp] == n); +#endif + b = n->Eexp; + vec_setclear(b,GEN,KILL); + } + return; + case OPcolon: + case OPcolon2: + { vec_t Gl,Kl,Gr,Kr; + + aecpelem(&Gl,&Kl,n->E1); + aecpelem(&Gr,&Kr,n->E2); + + /* KILL |= Kl | Kr */ + /* GEN =((GEN - Kl) | Gl) & */ + /* ((GEN - Kr) | Gr) */ + + vec_orass(KILL,Kl); + vec_orass(KILL,Kr); + + vec_sub(Kl,GEN,Kl); + vec_sub(Kr,GEN,Kr); + vec_orass(Kl,Gl); + vec_orass(Kr,Gr); + vec_and(GEN,Kl,Kr); + + vec_free(Gl); + vec_free(Gr); + vec_free(Kl); + vec_free(Kr); + break; + } + case OPandand: + case OPoror: + { vec_t Gr,Kr; + + accumaecpx(n->E1); + aecpelem(&Gr,&Kr,n->E2); + + if (!el_noreturn(n->E2)) + { + // KILL |= Kr + // GEN &= (GEN - Kr) | Gr + + vec_orass(KILL,Kr); + vec_sub(Kr,GEN,Kr); + vec_orass(Kr,Gr); + vec_andass(GEN,Kr); + } + + vec_free(Gr); + vec_free(Kr); + break; + } + case OPasm: + assert(!n->Eexp); // no ASM available expressions + vec_set(KILL); // KILL everything + vec_clear(GEN); // GEN nothing + return; + + case OPeq: + case OPstreq: + accumaecpx(n->E2); + case OPnegass: + accumaecpx(n->E1); + t = Elvalue(n); + break; + +#if TARGET_SEGMENTED + case OPvp_fp: + case OPcvp_fp: // if vptr access + if ((flowxx == AE) && n->Eexp) + vec_orass(KILL,vptrkill); // kill all other vptr accesses + break; +#endif + + default: + if (OTunary(op)) + { + case OPind: // most common unary operator + accumaecpx(n->E1); +#ifdef DEBUG + assert(!OTassign(op)); +#endif + } + else if (OTbinary(op)) + { + if (OTrtol(op) && ERTOL(n)) + { accumaecpx(n->E2); + accumaecpx(n->E1); + } + else + { accumaecpx(n->E1); + accumaecpx(n->E2); + } + if (OTassign(op)) // if assignment operator + t = Elvalue(n); + } + break; + } + + + /* Do copy propagation stuff first */ + + if (flowxx == CP) + { + if (!OTdef(op)) /* if not def elem */ + return; + if (!Eunambig(n)) /* if ambiguous def elem */ + { vec_orass(KILL,defkill); + vec_subass(GEN,defkill); + } + else /* unambiguous def elem */ + { symbol *s; + + assert(t->Eoper == OPvar); + s = t->EV.sp.Vsym; // ptr to var being def'd + for (i = 1; i < exptop; i++) /* for each ae elem */ + { register elem *e = expnod[i]; + + /* If it could be changed by the definition, */ + /* set bit in KILL. */ + + if (e->E1->EV.sp.Vsym == s || e->E2->EV.sp.Vsym == s) + vec_setclear(i,KILL,GEN); + } + } + + /* GEN CP elems */ + if (n->Eexp) + { unsigned b = n->Eexp; + + vec_setclear(b,GEN,KILL); + } + + return; + } + + /* Else Available Expression stuff */ + + if (n->Eexp) + { unsigned b = n->Eexp; // add elem to GEN + + assert(expnod[b] == n); + vec_setclear(b,GEN,KILL); + } + else if (OTdef(op)) /* else if definition elem */ + { + if (!Eunambig(n)) /* if ambiguous def elem */ + { vec_orass(KILL,defkill); + vec_subass(GEN,defkill); + if (OTcalldef(op)) + { vec_orass(KILL,vptrkill); + vec_subass(GEN,vptrkill); + } + } + else /* unambiguous def elem */ + { symbol *s; + + assert(t->Eoper == OPvar); + s = t->EV.sp.Vsym; /* idx of var being def'd */ + if (!(s->Sflags & SFLunambig)) + { vec_orass(KILL,starkill); /* kill all 'starred' refs */ + vec_subass(GEN,starkill); + } + for (i = 1; i < exptop; i++) /* for each ae elem */ + { elem *e = expnod[i]; + int eop = e->Eoper; + + /* If it could be changed by the definition, */ + /* set bit in KILL. */ + if (eop == OPvar) + { if (e->EV.sp.Vsym != s) + continue; + } + else if (OTunary(eop)) + { if (!vec_testbit(e->E1->Eexp,KILL)) + continue; + } + else if (OTbinary(eop)) + { if (!vec_testbit(e->E1->Eexp,KILL) && + !vec_testbit(e->E2->Eexp,KILL)) + continue; + } + else + continue; + + vec_setclear(i,KILL,GEN); + } + } + + /* GEN the lvalue of an assignment operator */ + if (OTassign(op) && !OTpost(op) && t->Eexp) + { unsigned b = t->Eexp; + + vec_setclear(b,GEN,KILL); + } + } +} + +/************************* LIVE VARIABLES **********************/ + +/********************************* + * Do live variable analysis (LVs). + * A variable is 'live' at some point if there is a + * subsequent use of it before a redefinition. + * Binlv = the set of variables live at the beginning of B. + * Boutlv = the set of variables live at the end of B. + * Bgen = set of variables used before any definition in B. + * Bkill = set of variables unambiguously defined before + * any use in B. + * Note that Bgen & Bkill = 0. + */ + +void flowlv() +{ vec_t tmp,livexit; + register unsigned i; + bool anychng; + unsigned cnt; + + lvgenkill(); /* compute Bgen and Bkill for LVs. */ + //assert(globsym.top); /* should be at least some symbols */ + + /* Create a vector of all the variables that are live on exit */ + /* from the function. */ + + livexit = vec_calloc(globsym.top); + for (i = 0; i < globsym.top; i++) + { if (globsym.tab[i]->Sflags & SFLlivexit) + vec_setbit(i,livexit); + } + + /* The transfer equation is: */ + /* Bin = (Bout - Bkill) | Bgen */ + /* Bout = union of Bin of all successors to B. */ + /* Using Ullman's algorithm: */ + + for (i = 0; i < dfotop; i++) /* for each block B */ + { + vec_copy(dfo[i]->Binlv,dfo[i]->Bgen); /* Binlv = Bgen */ + } + + tmp = vec_calloc(globsym.top); + cnt = 0; + do + { anychng = FALSE; + + /* For each block B in reverse DFO order */ + for (i = dfotop; i--;) + { register block *b = dfo[i]; + register list_t bl = b->Bsucc; + + /* Bout = union of Bins of all successors to B. */ + if (bl) + { vec_copy(b->Boutlv,list_block(bl)->Binlv); + while ((bl = list_next(bl)) != NULL) + { vec_orass(b->Boutlv,list_block(bl)->Binlv); + } + } + else /* no successors, Boutlv = livexit */ + { //assert(b->BC==BCret||b->BC==BCretexp||b->BC==BCexit); + vec_copy(b->Boutlv,livexit); + } + + /* Bin = (Bout - Bkill) | Bgen */ + vec_sub(tmp,b->Boutlv,b->Bkill); + vec_orass(tmp,b->Bgen); + if (!anychng) + anychng = !vec_equal(tmp,b->Binlv); + vec_copy(b->Binlv,tmp); + } + cnt++; + assert(cnt < 50); + } while (anychng); + vec_free(tmp); + vec_free(livexit); +#if 0 + dbg_printf("Live variables\n"); + for (i = 0; i < dfotop; i++) + { dbg_printf("B%d IN\t",i); + vec_println(dfo[i]->Binlv); + dbg_printf("B%d GEN\t",i); + vec_println(dfo[i]->Bgen); + dbg_printf(" KILL\t"); + vec_println(dfo[i]->Bkill); + dbg_printf(" OUT\t"); + vec_println(dfo[i]->Boutlv); + } +#endif +} + +/*********************************** + * Compute Bgen and Bkill for LVs. + * Allocate Binlv and Boutlv vectors. + */ + +STATIC void lvgenkill() +{ unsigned i; + + /* Compute ambigsym, a vector of all variables that could be */ + /* referenced by a *e or a call. */ + + assert(ambigsym == NULL); + ambigsym = vec_calloc(globsym.top); + for (i = 0; i < globsym.top; i++) + if (!(globsym.tab[i]->Sflags & SFLunambig)) + vec_setbit(i,ambigsym); + + for (i = 0; i < dfotop; i++) + { block *b = dfo[i]; + + vec_free(b->Bgen); + vec_free(b->Bkill); + lvelem(&(b->Bgen),&(b->Bkill),b->Belem); + if (b->BC == BCasm) + { vec_set(b->Bgen); + vec_clear(b->Bkill); + } + + vec_free(b->Binlv); + vec_free(b->Boutlv); + b->Binlv = vec_calloc(globsym.top); + b->Boutlv = vec_calloc(globsym.top); + } + + vec_free(ambigsym); /* dump any existing one */ + ambigsym = NULL; +} + +/***************************** + * Allocate and compute KILL and GEN for live variables. + */ + +STATIC void lvelem(vec_t *pgen,vec_t *pkill,elem *n) +{ + *pgen = vec_calloc(globsym.top); + *pkill = vec_calloc(globsym.top); + if (n && globsym.top) + accumlv(*pgen,*pkill,n); +} + +/********************************************** + * Accumulate GEN and KILL sets for LVs for this elem. + */ + +STATIC void accumlv(vec_t GEN,vec_t KILL,elem *n) +{ vec_t Gl,Kl,Gr,Kr; + register unsigned op; + elem *t; + + assert(GEN && KILL && n); + + while (1) + { elem_debug(n); + op = n->Eoper; + switch (op) + { + case OPvar: + if (symbol_isintab(n->EV.sp.Vsym)) + { SYMIDX si = n->EV.sp.Vsym->Ssymnum; + + assert((unsigned)si < globsym.top); + if (!vec_testbit(si,KILL)) // if not in KILL + vec_setbit(si,GEN); // put in GEN + } + break; + + case OPcolon: + case OPcolon2: + lvelem(&Gl,&Kl,n->E1); + lvelem(&Gr,&Kr,n->E2); + + /* GEN |= (Gl | Gr) - KILL */ + /* KILL |= (Kl & Kr) - GEN */ + + vec_orass(Gl,Gr); + vec_subass(Gl,KILL); + vec_orass(GEN,Gl); + vec_andass(Kl,Kr); + vec_subass(Kl,GEN); + vec_orass(KILL,Kl); + + vec_free(Gl); + vec_free(Gr); + vec_free(Kl); + vec_free(Kr); + break; + + case OPandand: + case OPoror: + accumlv(GEN,KILL,n->E1); + lvelem(&Gr,&Kr,n->E2); + + /* GEN |= Gr - KILL */ + /* KILL |= 0 */ + + vec_subass(Gr,KILL); + vec_orass(GEN,Gr); + + vec_free(Gr); + vec_free(Kr); + break; + + case OPasm: + vec_set(GEN); /* GEN everything not already KILLed */ + vec_subass(GEN,KILL); + break; + + case OPnewarray: + case OPmultinewarray: + accumlv(GEN,KILL,n->E1); + accumlv(GEN,KILL,n->E2); + goto L1; + + case OPcall: + case OPcallns: +#if TX86 + case OPstrcpy: + case OPmemcpy: + case OPmemset: +#endif +#ifdef DEBUG + assert(OTrtol(op)); +#endif + accumlv(GEN,KILL,n->E2); + accumlv(GEN,KILL,n->E1); + goto L1; + +#if TX86 + case OPstrcat: +#ifdef DEBUG + assert(!OTrtol(op)); +#endif + accumlv(GEN,KILL,n->E1); + accumlv(GEN,KILL,n->E2); +#endif + L1: + vec_orass(GEN,ambigsym); + vec_subass(GEN,KILL); + break; + + case OPeq: + /* Avoid GENing the lvalue of an = */ + accumlv(GEN,KILL,n->E2); + t = Elvalue(n); + if (t->Eoper != OPvar) + accumlv(GEN,KILL,t->E1); + else /* unambiguous assignment */ + { symbol *s; + + s = t->EV.sp.Vsym; + symbol_debug(s); + + /* if not GENed already, KILL it */ + if (symbol_isintab(s) && + !vec_testbit(s->Ssymnum,GEN) && + /* assignments to aggregates are */ + /* not unambiguous */ + !tyaggregate(s->ty()) && + t->EV.sp.Voffset == 0 && + tysize(t->Ety) == tysize(s->ty()) + ) + { assert((unsigned)s->Ssymnum < globsym.top); + vec_setbit(s->Ssymnum,KILL); + } + } + break; + + case OPind: + case OPucall: + case OPucallns: + case OPstrlen: + accumlv(GEN,KILL,n->E1); + + /* If it was a *p elem, set bits in GEN for all symbols */ + /* it could have referenced, but only if bits in KILL */ + /* are not already set. */ + + vec_orass(GEN,ambigsym); + vec_subass(GEN,KILL); + break; + + default: + if (OTunary(op)) + { n = n->E1; + continue; + } + else if (OTrtol(op) && ERTOL(n)) + { + accumlv(GEN,KILL,n->E2); + + /* Note that lvalues of op=,i++,i-- elems */ + /* are GENed. */ + n = n->E1; + continue; + } + else if (OTbinary(op)) + { + accumlv(GEN,KILL,n->E1); + n = n->E2; + continue; + } + break; + } + break; + } +} + +/********************* VERY BUSY EXPRESSIONS ********************/ + +/********************************************** + * Compute very busy expressions(VBEs). + * That is,expressions that are evaluated along + * separate paths. + * Bin = the set of VBEs at the beginning of B. + * Bout = the set of VBEs at the end of B. + * Bgen = set of expressions X+Y such that X+Y is + * evaluated before any def of X or Y. + * Bkill = set of expressions X+Y such that X or Y could + * be defined before X+Y is computed. + * Note that gen and kill are mutually exclusive. + */ + +void flowvbe() +{ vec_t tmp; + unsigned i; + bool anychng; + + flowxx = VBE; + aecpgenkill(); /* compute Bgen and Bkill for VBEs */ + if (exptop <= 1) /* if no candidates for VBEs */ + return; + + /*for (i = 0; i < exptop; i++) + dbg_printf("expnod[%d] = 0x%x\n",i,expnod[i]);*/ + + /* The transfer equation is: */ + /* Bout = & Bin(all successors S of B) */ + /* Bin =(Bout - Bkill) | Bgen */ + /* Using Ullman's algorithm: */ + + /*dbg_printf("defkill = "); vec_println(defkill); + dbg_printf("starkill = "); vec_println(starkill);*/ + + for (i = 0; i < dfotop; i++) + { block *b = dfo[i]; + + /*dbg_printf("block 0x%x\n",b); + dbg_printf("Bgen = "); vec_println(b->Bgen); + dbg_printf("Bkill = "); vec_println(b->Bkill);*/ + + if (b->BC == BCret || b->BC == BCretexp || b->BC == BCexit) + vec_clear(b->Bout); + else + vec_set(b->Bout); + + /* Bin = (Bout - Bkill) | Bgen */ + vec_sub(b->Bin,b->Bout,b->Bkill); + vec_orass(b->Bin,b->Bgen); + } + + tmp = vec_calloc(exptop); + do + { anychng = FALSE; + + /* for all blocks except return blocks in reverse dfo order */ + for (i = dfotop; i--;) + { block *b = dfo[i]; + list_t bl; + + if (b->BC == BCret || b->BC == BCretexp || b->BC == BCexit) + continue; + + /* Bout = & of Bin of all successors */ + bl = b->Bsucc; + assert(bl); /* must have successors */ + vec_copy(b->Bout,list_block(bl)->Bin); + while (TRUE) + { bl = list_next(bl); + if (!bl) + break; + vec_andass(b->Bout,list_block(bl)->Bin); + } + + /* Bin = (Bout - Bkill) | Bgen */ + vec_sub(tmp,b->Bout,b->Bkill); + vec_orass(tmp,b->Bgen); + if (!anychng) + anychng = !vec_equal(tmp,b->Bin); + vec_copy(b->Bin,tmp); + } + } while (anychng); /* while any changes occurred to any Bin */ + vec_free(tmp); +} + +/************************************* + * Accumulate GEN and KILL sets for VBEs for this elem. + */ + +STATIC void accumvbe(vec_t GEN,vec_t KILL,elem *n) +{ register unsigned op,i; + register elem *t; + + assert(GEN && KILL && n); + op = n->Eoper; + + switch (op) + { + case OPcolon: + case OPcolon2: + { vec_t Gl,Gr,Kl,Kr; + + aecpelem(&Gl,&Kl,n->E1); + aecpelem(&Gr,&Kr,n->E2); + + /* GEN |=((Gr - Kl) | (Gl - Kr)) - KILL */ + vec_subass(Gr,Kl); + vec_subass(Gl,Kr); + vec_orass(Gr,Gl); + vec_subass(Gr,KILL); + vec_orass(GEN,Gr); + + /* KILL |=(Kl | Kr) - GEN */ + vec_orass(Kl,Kr); + vec_subass(Kl,GEN); + vec_orass(KILL,Kl); + + vec_free(Gl); + vec_free(Kl); + vec_free(Gr); + vec_free(Kr); + break; + } + + case OPandand: + case OPoror: + accumvbe(GEN,KILL,n->E1); + /* WARNING: just so happens that it works this way. */ + /* Be careful about (b+c)||(b+c) being VBEs, only the */ + /* first should be GENed. Doing things this way instead */ + /* of (GEN |= Gr - KILL) and (KILL |= Kr - GEN) will */ + /* ensure this. */ + accumvbe(GEN,KILL,n->E2); + break; + + case OPnegass: + t = n->E1; + if (t->Eoper != OPvar) + { accumvbe(GEN,KILL,t->E1); + if (OTbinary(t->Eoper)) + accumvbe(GEN,KILL,t->E2); + } + break; + + case OPnewarray: + case OPmultinewarray: + accumvbe(GEN,KILL,n->E1); + accumvbe(GEN,KILL,n->E2); + break; + + case OPcall: + case OPcallns: + accumvbe(GEN,KILL,n->E2); + case OPucall: + case OPucallns: + t = n->E1; + // Do not VBE indirect function calls + if (t->Eoper == OPind) + t = t->E1; + accumvbe(GEN,KILL,t); + break; + + case OPasm: // if the dreaded OPasm elem + vec_set(KILL); // KILL everything + vec_subass(KILL,GEN); // except for GENed stuff + return; + + default: + if (OTunary(op)) + { + t = n->E1; + accumvbe(GEN,KILL,t); + } + else if (ERTOL(n)) + { accumvbe(GEN,KILL,n->E2); + t = n->E1; + // do not GEN the lvalue of an assignment op + if (OTassign(op)) + { t = Elvalue(n); + if (t->Eoper != OPvar) + { accumvbe(GEN,KILL,t->E1); + if (OTbinary(t->Eoper)) + accumvbe(GEN,KILL,t->E2); + } + } + else + accumvbe(GEN,KILL,t); + } + else if (OTbinary(op)) + { + /* do not GEN the lvalue of an assignment op */ + if (OTassign(op)) + { t = Elvalue(n); + if (t->Eoper != OPvar) + { accumvbe(GEN,KILL,t->E1); + if (OTbinary(t->Eoper)) + accumvbe(GEN,KILL,t->E2); + } + } + else + accumvbe(GEN,KILL,n->E1); + accumvbe(GEN,KILL,n->E2); + } + break; + } + + if (n->Eexp) /* if a vbe elem */ + { int ne = n->Eexp; + + assert(expnod[ne] == n); + if (!vec_testbit(ne,KILL)) /* if not already KILLed */ + { + /* GEN this expression only if it hasn't */ + /* already been GENed in this block. */ + /* (Don't GEN common subexpressions.) */ + if (vec_testbit(ne,GEN)) + vec_clearbit(ne,GEN); + else + { vec_setbit(ne,GEN); /* GEN this expression */ + /* GEN all identical expressions */ + /* (operators only, as there is no point */ + /* to hoisting out variables and constants) */ + if (!OTleaf(op)) + { for (i = 1; i < exptop; i++) + { if (op == expnod[i]->Eoper && + i != ne && + el_match(n,expnod[i])) + { vec_setbit(i,GEN); + assert(!vec_testbit(i,KILL)); + } + } + } + } + } +#if TARGET_SEGMENTED + if (op == OPvp_fp || op == OPcvp_fp) + { + vec_orass(KILL,vptrkill); /* KILL all vptr accesses */ + vec_subass(KILL,GEN); /* except for GENed stuff */ + } +#endif + } + else if (OTdef(op)) /* if definition elem */ + { + if (!Eunambig(n)) /* if ambiguous definition */ + { vec_orass(KILL,defkill); + if (OTcalldef(op)) + vec_orass(KILL,vptrkill); + } + else /* unambiguous definition */ + { symbol *s; + + assert(t->Eoper == OPvar); + s = t->EV.sp.Vsym; // ptr to var being def'd + if (!(s->Sflags & SFLunambig)) + vec_orass(KILL,starkill);/* kill all 'starred' refs */ + for (i = 1; i < exptop; i++) /* for each vbe elem */ + { elem *e = expnod[i]; + unsigned eop = e->Eoper; + + /* If it could be changed by the definition, */ + /* set bit in KILL. */ + if (eop == OPvar) + { if (e->EV.sp.Vsym != s) + continue; + } + else if (OTbinary(eop)) + { if (!vec_testbit(e->E1->Eexp,KILL) && + !vec_testbit(e->E2->Eexp,KILL)) + continue; + } + else if (OTunary(eop)) + { if (!vec_testbit(e->E1->Eexp,KILL)) + continue; + } + else /* OPconst or OPrelconst or OPstring or OPhstring */ + continue; + + vec_setbit(i,KILL); // KILL it + } /* for */ + } /* if */ + vec_subass(KILL,GEN); + } /* if */ +} + +#endif diff --git a/backend/global.h b/backend/global.h new file mode 100644 index 00000000..c0f361f9 --- /dev/null +++ b/backend/global.h @@ -0,0 +1,589 @@ +// Copyright (C) 1984-1996 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Globals + +//#pragma once +#ifndef GLOBAL_H +#define GLOBAL_H 1 + +#ifndef EL_H +#include "el.h" +#endif + +#ifdef DEBUG +CEXTERN char debuga; /* cg - watch assignaddr() */ +CEXTERN char debugb; /* watch block optimization */ +CEXTERN char debugc; /* watch code generated */ +CEXTERN char debugd; /* watch debug information generated */ +CEXTERN char debuge; // dump eh info +CEXTERN char debugf; /* trees after dooptim */ +CEXTERN char debugg; /* trees for code generator */ +CEXTERN char debugo; // watch optimizer +CEXTERN char debugr; // watch register allocation +CEXTERN char debugs; /* watch common subexp eliminator */ +CEXTERN char debugt; /* do test points */ +CEXTERN char debugu; +CEXTERN char debugw; /* watch progress */ +CEXTERN char debugx; /* suppress predefined CPP stuff */ +CEXTERN char debugy; /* watch output to il buffer */ +#endif /* DEBUG */ + +#define CR '\r' // Used because the MPW version of the compiler warps +#define LF '\n' // \n into \r and \r into \n. The translator version + // does not and this causes problems with the compilation + // with the translator +#define CR_STR "\r" +#define LF_STR "\n" + +struct seg_data; + +/************************ + * Bit masks + */ + +CEXTERN const unsigned mask[32]; +CEXTERN const unsigned long maskl[32]; + +extern char *argv0; +CEXTERN char *finname,*foutname,*foutdir; + +CEXTERN char OPTIMIZER,PARSER; +CEXTERN symtab_t globsym; +#if AUTONEST +CEXTERN int pushcount; +#endif + +CEXTERN Config config; // precompiled part of configuration +CEXTERN Configv configv; // non-ph part of configuration +CEXTERN char sytab[]; + +CEXTERN volatile int controlc_saw; /* a control C was seen */ +CEXTERN unsigned maxblks; /* array max for all block stuff */ +CEXTERN unsigned numblks; /* number of basic blocks (if optimized) */ +CEXTERN block *startblock; /* beginning block of function */ + +CEXTERN block **dfo; /* array of depth first order */ +CEXTERN unsigned dfotop; /* # of items in dfo[] */ +CEXTERN block **labelarr; /* dynamically allocated array, index is label #*/ +CEXTERN unsigned labelmax; /* size of labelarr[] */ +CEXTERN unsigned labeltop; /* # of used entries in labelarr[] */ +CEXTERN block *curblock; /* current block being read in */ +CEXTERN block *block_last; + +CEXTERN int errcnt; +CEXTERN regm_t fregsaved; + +#if SCPP +CEXTERN targ_size_t dsout; /* # of bytes actually output to data */ +#endif +CEXTERN tym_t pointertype; /* default data pointer type */ + +// cg.c +extern symbol *localgot; +extern symbol *tls_get_addr_sym; + +// iasm.c +Symbol *asm_define_label(const char *id); + +// cpp.c +#if SCPP || MARS +char *cpp_mangle(Symbol *s); +#else +#define cpp_mangle(s) ((s)->Sident) +#endif + +// ee.c +void eecontext_convs(unsigned marksi); +void eecontext_parse(); + +// exp2.c +#define REP_THRESHOLD (REGSIZE * (6+ (REGSIZE == 4))) + /* doesn't belong here, but func to OPxxx is in exp2 */ +void exp2_setstrthis(elem *e,Symbol *s,targ_size_t offset,type *t); +symbol *exp2_qualified_lookup(Classsym *sclass, int flags, int *pflags); +elem *exp2_copytotemp(elem *e); + +/* util.c */ +#if __clang__ +void util_exit(int) __attribute__((analyzer_noreturn)); +void util_assert(char *, int) __attribute__((analyzer_noreturn)); +#else +void util_exit(int); +void util_assert(char *, int); +#if __DMC__ +#pragma ZTC noreturn(util_exit) +#pragma ZTC noreturn(util_assert) +#endif +#endif + +void util_progress(); +void util_set16(void); +void util_set32(void); +void util_set64(void); +int ispow2(targ_ullong); + +#if TX86 +#if __GNUC__ +#define util_malloc(n,size) mem_malloc((n)*(size)) +#define util_calloc(n,size) mem_calloc((n)*(size)) +#define util_free mem_free +#define util_realloc(oldp,n,size) mem_realloc(oldp,(n)*(size)) +#define parc_malloc mem_malloc +#define parc_calloc mem_calloc +#define parc_realloc mem_realloc +#define parc_strdup mem_strdup +#define parc_free mem_free +#else +void *util_malloc(unsigned n,unsigned size); +void *util_calloc(unsigned n,unsigned size); +void util_free(void *p); +void *util_realloc(void *oldp,unsigned n,unsigned size); +void *parc_malloc(size_t len); +void *parc_calloc(size_t len); +void *parc_realloc(void *oldp,size_t len); +char *parc_strdup(const char *s); +void parc_free(void *p); +#endif +#endif + +void swap(int *,int *); +void crlf(FILE *); +char *unsstr(unsigned); +int isignore(int); +int isillegal(int); + +#if !defined(__SC__) && !defined(_MSC_VER) +int ishex(int); +#endif + +/* from cgcs.c */ +extern void comsubs(void); +void cgcs_term(); + +/* errmsgs.c */ +CEXTERN char *dlcmsgs(int); +extern void errmsgs_term(); + +/* from evalu8.c */ +int boolres(elem *); +int iftrue(elem *); +int iffalse(elem *); +elem *poptelem(elem *); +elem *poptelem2(elem *); +elem *poptelem3(elem *); +elem *poptelem4(elem *); +elem *selecte1(elem *,type *); + +//CEXTERN type *declar(type *,char *,int); + +/* from err.c */ +void err_message(const char *format,...); +void dll_printf(const char *format,...); +void cmderr(unsigned,...); +int synerr(unsigned,...); +void preerr(unsigned,...); + +#if __clang__ +void err_exit(void) __attribute__((analyzer_noreturn)); +void err_nomem(void) __attribute__((analyzer_noreturn)); +void err_fatal(unsigned,...) __attribute__((analyzer_noreturn)); +#else +void err_exit(void); +void err_nomem(void); +void err_fatal(unsigned,...); +#if __DMC__ +#pragma ZTC noreturn(err_exit) +#pragma ZTC noreturn(err_nomem) +#pragma ZTC noreturn(err_fatal) +#endif +#endif + +int cpperr(unsigned,...); +#if TX86 +int tx86err(unsigned,...); +extern int errmsgs_tx86idx; +#endif +void warerr(unsigned,...); +void err_warning_enable(unsigned warnum, int on); +CEXTERN void lexerr(unsigned,...); + +int typerr(int,type *,type *,...); +void err_noctor(Classsym *stag,list_t arglist); +void err_nomatch(const char *, list_t); +void err_ambiguous(Symbol *,Symbol *); +void err_noinstance(Symbol *s1,Symbol *s2); +void err_redeclar(Symbol *s,type *t1,type *t2); +void err_override(Symbol *sfbase,Symbol *sfder); +void err_notamember(const char *id, Classsym *s, symbol *alternate = NULL); + +/* exp.c */ +elem *expression(void),*const_exp(void),*assign_exp(void); +elem *exp_simplecast(type *); + +/* file.c */ +char *file_getsource(const char *iname); +int file_isdir(const char *fname); +void file_progress(void); +void file_remove(char *fname); +int file_stat(const char *fname,struct stat *pbuf); +int file_exists(const char *fname); +long file_size(const char *fname); +void file_term(void); +#if __NT__ && _WINDLL +char *file_nettranslate(const char *filename,const char *mode); +#else +#define file_nettranslate(f,m) ((char *)(f)) +#endif +char *file_unique(); + +/* from msc.c */ +type *newpointer(type *), + *newpointer_share(type *), + *reftoptr(type *t), + *newref(type *), + *topointer(type *), + *type_ptr(elem *, type *); +int type_chksize(unsigned long); +tym_t tym_conv(type *); +type * type_arrayroot(type *); +void chklvalue(elem *); +int tolvalue(elem **); +void chkassign(elem *); +void chknosu(elem *); +void chkunass(elem *); +void chknoabstract(type *); +CEXTERN targ_llong msc_getnum(void); +CEXTERN targ_size_t alignmember(type *,targ_size_t,targ_size_t); +CEXTERN targ_size_t align(targ_size_t,targ_size_t); + +/* nteh.c */ +unsigned char *nteh_context_string(); +void nteh_declarvars(Blockx *bx); +elem *nteh_setScopeTableIndex(Blockx *blx, int scope_index); +Symbol *nteh_contextsym(); +unsigned nteh_contextsym_size(); +Symbol *nteh_ecodesym(); +code *nteh_unwind(regm_t retregs,unsigned index); +code *linux_unwind(regm_t retregs,unsigned index); +int nteh_offset_sindex(); +int nteh_offset_sindex_seh(); +int nteh_offset_info(); + +/* os.c */ +void *globalrealloc(void *oldp,size_t nbytes); +void *vmem_baseaddr(); +void vmem_reservesize(unsigned long *psize); +unsigned long vmem_physmem(); +void *vmem_reserve(void *ptr,unsigned long size); +int vmem_commit(void *ptr, unsigned long size); +void vmem_decommit(void *ptr,unsigned long size); +void vmem_release(void *ptr,unsigned long size); +void *vmem_mapfile(const char *filename,void *ptr,unsigned long size,int flag); +void vmem_setfilesize(unsigned long size); +void vmem_unmapfile(); +void os_loadlibrary(const char *dllname); +void os_freelibrary(); +void *os_getprocaddress(const char *funcname); +void os_heapinit(); +void os_heapterm(); +void os_term(); +unsigned long os_unique(); +int os_file_exists(const char *name); +long os_file_size(int fd); +char *file_8dot3name(const char *filename); +int file_write(char *name, void *buffer, unsigned len); +int file_createdirs(char *name); +int os_critsecsize32(); +int os_critsecsize64(); + +#ifdef PSEUDO_REGS +/* pseudo.c */ +Symbol *pseudo_declar(char *); + +CEXTERN unsigned char pseudoreg[]; +CEXTERN regm_t pseudomask[]; +#endif /* PSEUDO_REGS */ + +/* Symbol.c */ +symbol **symtab_realloc(symbol **tab, size_t symmax); +symbol **symtab_malloc(size_t symmax); +symbol **symtab_calloc(size_t symmax); +void symtab_free(symbol **tab); +#if TERMCODE +void symbol_keep(Symbol *s); +#else +#define symbol_keep(s) ((void)(s)) +#endif +void symbol_print(Symbol *s); +void symbol_term(void); +char *symbol_ident(symbol *s); +Symbol *symbol_calloc(const char *id); +Symbol *symbol_name(const char *name, int sclass, type *t); +Symbol *symbol_generate(int sclass, type *t); +Symbol *symbol_genauto(type *t); +Symbol *symbol_genauto(elem *e); +Symbol *symbol_genauto(tym_t ty); +void symbol_func(Symbol *); +Funcsym *symbol_funcalias(Funcsym *sf); +Symbol *defsy(const char *p, Symbol **parent); +void symbol_addtotree(Symbol **parent,Symbol *s); +//Symbol *lookupsym(const char *p); +Symbol *findsy(const char *p, Symbol *rover); +void createglobalsymtab(void); +void createlocalsymtab(void); +void deletesymtab(void); +void meminit_free(meminit_t *m); +baseclass_t *baseclass_find(baseclass_t *bm,Classsym *sbase); +baseclass_t *baseclass_find_nest(baseclass_t *bm,Classsym *sbase); +int baseclass_nitems(baseclass_t *b); +void symbol_free(Symbol *s); +SYMIDX symbol_add(Symbol *s); +void freesymtab(Symbol **stab, SYMIDX n1, SYMIDX n2); +Symbol * symbol_copy(Symbol *s); +Symbol * symbol_searchlist(symlist_t sl, const char *vident); + + +#if TX86 +// cg87.c +void cg87_reset(); +#endif + +unsigned char loadconst(elem *e, int im); + +/* From cgopt.c */ +CEXTERN void opt(void); + +/* cgobj.c */ +void obj_init(Outbuffer *, const char *filename, const char *csegname); +void obj_initfile(const char *filename, const char *csegname, const char *modname); +size_t obj_mangle(Symbol *s,char *dest); +void obj_termfile(void); +void obj_term(void); +void obj_import(elem *e); +void objlinnum(Srcpos srcpos, targ_size_t offset); +void obj_dosseg(void); +void obj_startaddress(Symbol *); +void obj_includelib(const char *); +void obj_exestr(const char *p); +void obj_user(const char *p); +void obj_compiler(); +void obj_wkext(Symbol *,Symbol *); +void obj_lzext(Symbol *,Symbol *); +void obj_alias(const char *n1,const char *n2); +void obj_theadr(const char *modname); +void objseggrp(targ_size_t codesize, targ_size_t datasize, targ_size_t cdatasize, targ_size_t udatasize); +void obj_staticctor(Symbol *s,int dtor,int seg); +void obj_staticdtor(Symbol *s); +void obj_funcptr(Symbol *s); +void obj_ehtables(Symbol *sfunc,targ_size_t size,Symbol *ehsym); +void obj_ehsections(); +void obj_moduleinfo(Symbol *scc); +int obj_comdat(Symbol *); +int obj_comdatsize(Symbol *, targ_size_t symsize); +void obj_setcodeseg(int seg,targ_size_t offset); +int obj_codeseg(char *name,int suffix); +seg_data *obj_tlsseg(); +seg_data *obj_tlsseg_bss(); +int obj_fardata(char *name, targ_size_t size, targ_size_t *poffset); +void obj_browse(char *, unsigned); +void objend(void); +void obj_export(Symbol *s, unsigned argsize); +void objpubdef(int seg, Symbol *s, targ_size_t offset); +#if ELFOBJ +void objpubdefsize(int seg, Symbol *s, targ_size_t offset, targ_size_t symsize); +#elif MACHOBJ + #define objpubdefsize(seg, s, offset, symsize) objpubdef(seg, s, offset) +#endif +int objextdef(const char *); +int elf_data_start(Symbol *sdata, targ_size_t datasize, int seg); +int objextern(Symbol *); +int obj_comdef(Symbol *s, int flag, targ_size_t size, targ_size_t count); +void obj_lidata(int seg, targ_size_t offset, targ_size_t count); +void obj_write_zeros(seg_data *pseg, targ_size_t count); +void obj_write_byte(seg_data *pseg, unsigned byte); +void obj_write_bytes(seg_data *pseg, unsigned nbytes, void *p); +void obj_byte(int seg, targ_size_t offset, unsigned byte); +unsigned obj_bytes(int seg, targ_size_t offset, unsigned nbytes, void *p); +void objledata(int seg, targ_size_t offset, targ_size_t data, unsigned lcfd, unsigned idx1, unsigned idx2); +void obj_long(int seg, targ_size_t offset, unsigned long data, unsigned lcfd, unsigned idx1, unsigned idx2); +void reftodatseg(int seg, targ_size_t offset, targ_size_t val, unsigned targetdatum, int flags); +void reftofarseg(int seg, targ_size_t offset, targ_size_t val, int farseg, int flags); +void reftocodseg(int seg, targ_size_t offset, targ_size_t val); +int reftoident(int seg, targ_size_t offset, Symbol *s, targ_size_t val, int flags); +void obj_far16thunk(Symbol *s); +void obj_fltused(); + +// objrecor.c +void objfile_open(const char *); +void objfile_close(void *data, unsigned len); +void objfile_delete(); +void objfile_term(); + +/* cod3.c */ +void cod3_thunk(Symbol *sthunk,Symbol *sfunc,unsigned p,tym_t thisty, + targ_size_t d,int i,targ_size_t d2); + +/* out.c */ +void outfilename(char *name,int linnum); +void outcsegname(char *csegname); +void outthunk(Symbol *sthunk, Symbol *sfunc, unsigned p, tym_t thisty, targ_size_t d, int i, targ_size_t d2); +void outdata(Symbol *s); +void outcommon(Symbol *s, targ_size_t n); +void out_regcand(symtab_t *); +void writefunc(Symbol *sfunc); +void alignOffset(int seg,targ_size_t datasize); +void out_reset(); +symbol *out_readonly_sym(tym_t ty, void *p, int len); + +/* blockopt.c */ +extern unsigned bc_goal[BCMAX]; + +block *block_calloc(); +void block_init(); +void block_term(); +#if MARS +void block_next(Blockx *bctx,enum BC bc,block *bn); +block *block_goto(Blockx *bctx,enum BC bc,block *bn); +#else +void block_next(enum BC,block *); +#endif +void block_setlabel(unsigned lbl); +void block_goto(); +void block_goto(block *); +void block_goto(block *bgoto, block *bnew); +void block_ptr(void); +void block_pred(void); +void block_clearvisit(); +void block_visit(block *b); +void block_compbcount(void); +void blocklist_free(block **pb); +void block_optimizer_free(block *b); +void block_free(block *b); +void blocklist_hydrate(block **pb); +void blocklist_dehydrate(block **pb); +void block_appendexp(block *b, elem *e); +void block_initvar(Symbol *s); +void block_endfunc(int flag); +void brcombine(void); +void blockopt(int); +void compdfo(void); + +#define block_initvar(s) (curblock->Binitvar = (s)) + +#ifdef DEBUG + +/* debug.c */ +CEXTERN const char *regstring[]; + +void WRclass(enum SC c); +void WRTYxx(tym_t t); +void WROP(unsigned oper); +void WRBC(unsigned bc); +void WRarglst(list_t a); +void WRblock(block *b); +void WRblocklist(list_t bl); +void WReqn(elem *e); +void WRfunc(void); +void WRdefnod(void); +void WRFL(enum FL); +char *sym_ident(SYMIDX si); + +#endif + +/* cgelem.c */ +elem *doptelem(elem *,int); +void postoptelem(elem *); +unsigned swaprel(unsigned); +int elemisone(elem *); + +/* msc.c */ +targ_size_t size(tym_t); +Symbol *symboldata(targ_size_t offset,tym_t ty); +int dom(block *A , block *B); +unsigned revop(unsigned op); +unsigned invrel(unsigned op); +int binary(const char *p, const char __near * __near *tab, int high); + +/* go.c */ +void go_term(void); +int go_flag(char *cp); +void optfunc(void); + +/* filename.c */ +#if !MARS +extern Srcfiles srcfiles; +Sfile **filename_indirect(Sfile *sf); +Sfile *filename_search( const char *name ); +Sfile *filename_add( const char *name ); +void filename_hydrate( Srcfiles *fn ); +void filename_dehydrate( Srcfiles *fn ); +void filename_merge( Srcfiles *fn ); +void filename_mergefl(Sfile *sf); +void filename_translate(Srcpos *); +void filename_free( void ); +int filename_cmp(const char *f1,const char *f2); +void srcpos_hydrate(Srcpos *); +void srcpos_dehydrate(Srcpos *); +#endif + +// tdb.c +unsigned long tdb_gettimestamp(); +void tdb_write(void *buf,unsigned size,unsigned numindices); +unsigned long tdb_typidx(void *buf); +//unsigned long tdb_typidx(unsigned char *buf,unsigned length); +void tdb_term(); + +// rtlsym.c +void rtlsym_init(); +void rtlsym_reset(); +void rtlsym_term(); + +#if ELFOBJ || MACHOBJ +void elf_add_cdata(); +symbol * elf_sym_cdata(tym_t, char *, int ); +int elf_data_cdata(char *str,int len,int *pseg); +#if ELFOBJ +int elf_getsegment(const char *name, const char *suffix, + int type, int flags, int align); +void elf_addrel(int seg, targ_size_t offset, unsigned type, + unsigned symidx, targ_size_t val); +#endif +#if MACHOBJ +int mach_getsegment(const char *sectname, const char *segname, + int align, int flags, int flags2 = 0); +void mach_addrel(int seg, targ_size_t offset, symbol *targsym, + unsigned targseg, int rtype, int val = 0); +#endif +void elf_func_start(Symbol *sfunc); +void elf_func_term(Symbol *sfunc); +unsigned elf_addstr(Outbuffer *strtab, const char *); + +void dwarf_CFA_set_loc(size_t location); +void dwarf_CFA_set_reg_offset(int reg, int offset); +void dwarf_CFA_offset(int reg, int offset); +void dwarf_CFA_args_size(size_t sz); +#endif + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +void elfobj_gotref(symbol *s); +symbol *elfobj_getGOTsym(); +void elfobj_refGOTsym(); +elem * exp_isconst(); +elem *lnx_builtin_next_arg(elem *efunc,list_t arglist); +char *lnx_redirect_funcname(const char *); +void lnx_funcdecl(symbol *,enum SC,enum_SC,int); +int lnx_attributes(int hinttype,const void *hint, type **ptyp, tym_t *ptym,int *pattrtype); +#endif + +#endif /* GLOBAL_H */ + diff --git a/backend/glocal.c b/backend/glocal.c new file mode 100644 index 00000000..10fd0373 --- /dev/null +++ b/backend/glocal.c @@ -0,0 +1,741 @@ +// Copyright (C) 1993-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !DEMO && !SPP + +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "cc.h" +#include "global.h" +#include "el.h" +#include "go.h" +#include "type.h" +#include "oper.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +typedef struct loc_t +{ + elem *e; + int flags; +# define LFvolatile 1 // contains volatile refs or defs +# define LFambigref 2 // references ambiguous data +# define LFambigdef 4 // defines ambiguous data +# define LFsymref 8 // reference to symbol s +# define LFsymdef 0x10 // definition of symbol s +# define LFunambigref 0x20 // references unambiguous data other than s +# define LFunambigdef 0x40 // defines unambiguous data other than s +#if TX86 +# define LFinp 0x80 // input from I/O port +# define LFoutp 0x100 // output to I/O port +#endif +# define LFfloat 0x200 // sets float flags and/or depends on + // floating point settings +} loc_t; + +static loc_t *loctab; +static unsigned locmax; +static unsigned loctop; + +STATIC void local_exp(elem *e,int goal); +STATIC int local_chkrem(elem *e,elem *eu); +STATIC void local_ins(elem *e); +STATIC void local_rem(unsigned u); +STATIC int local_getflags(elem *e,symbol *s); +STATIC void local_remove(int flags); +STATIC void local_ambigref(void); +STATIC void local_ambigdef(void); +STATIC void local_symref(symbol *s); +STATIC void local_symdef(symbol *s); + +/////////////////////////////// +// This optimization attempts to replace sequences like: +// x = func(); +// y = 3; +// z = x + 5; +// with: +// y = 3; +// z = (x = func()) + 5; +// In other words, we attempt to localize expressions by moving them +// as near as we can to where they are used. This should minimize +// temporary generation and register usage. + +void localize() +{ block *b; + + cmes("localize()\n"); + + // Table should not get any larger than the symbol table + locmax = globsym.symmax; + loctab = (loc_t *) alloca(locmax * sizeof(*loctab)); + + for (b = startblock; b; b = b->Bnext) /* for each block */ + { + loctop = 0; // start over for each block + if (b->Belem && + /* Overly broad way to account for the case: + * try + * { i++; + * foo(); // throws exception + * i++; // shouldn't combine previous i++ with this one + * } + */ + !b->Btry) + { + local_exp(b->Belem,0); + } + } +} + +////////////////////////////////////// +// Input: +// goal !=0 if we want the result of the expression +// + +STATIC void local_exp(elem *e,int goal) +{ symbol *s; + unsigned u; + elem *e1; + int op1; + +Loop: + elem_debug(e); + int op = e->Eoper; + switch (op) + { case OPcomma: + local_exp(e->E1,0); + e = e->E2; + goto Loop; + + case OPandand: + case OPoror: + local_exp(e->E1,1); + loctop = 0; // we can do better than this, fix later + break; + + case OPcolon: + case OPcolon2: + loctop = 0; // we can do better than this, fix later + break; + + case OPinfo: + if (e->E1->Eoper == OPmark) + { loctop = 0; + e = e->E2; + goto Loop; + } + goto case_bin; + + case OPdtor: + case OPctor: + case OPdctor: + loctop = 0; // don't move expressions across ctor/dtor + break; // boundaries, it would goof up EH cleanup + + case OPddtor: + loctop = 0; // don't move expressions across ctor/dtor + // boundaries, it would goof up EH cleanup + local_exp(e->E1,0); + loctop = 0; + break; + + case OPeq: + case OPstreq: + e1 = e->E1; + local_exp(e->E2,1); + if (e1->Eoper == OPvar) + { s = e1->EV.sp.Vsym; + if (s->Sflags & SFLunambig) + { local_symdef(s); + if (!goal) + local_ins(e); + } + else + local_ambigdef(); + } + else + { + assert(!OTleaf(e1->Eoper)); + local_exp(e1->E1,1); + if (OTbinary(e1->Eoper)) + local_exp(e1->E2,1); + local_ambigdef(); + } + break; + + case OPpostinc: + case OPpostdec: + case OPaddass: + case OPminass: + case OPmulass: + case OPdivass: + case OPmodass: + case OPashrass: + case OPshrass: + case OPshlass: + case OPandass: + case OPxorass: + case OPorass: + if (ERTOL(e)) + { local_exp(e->E2,1); + case OPnegass: + e1 = e->E1; + op1 = e1->Eoper; + if (op1 != OPvar) + { + local_exp(e1->E1,1); + if (OTbinary(op1)) + local_exp(e1->E2,1); + } + else if (loctop && (op == OPaddass || op == OPxorass)) + { unsigned u; + + s = e1->EV.sp.Vsym; + for (u = 0; u < loctop; u++) + { elem *em; + + em = loctab[u].e; + if (em->Eoper == op && + em->E1->EV.sp.Vsym == s && + tysize(em->Ety) == tysize(e1->Ety) && + em->E1->EV.sp.Voffset == e1->EV.sp.Voffset && + !el_sideeffect(em->E2) + ) + { // Change (x += a),(x += b) to + // (x + a),(x += a + b) + changes++; + e->E2 = el_bin(opeqtoop(op),e->E2->Ety,em->E2,e->E2); + em->Eoper = opeqtoop(op); + em->E2 = el_copytree(em->E2); + local_rem(u); +#ifdef DEBUG + if (debugc) + { dbg_printf("Combined equation "); + WReqn(e); + dbg_printf(";\n"); + e = doptelem(e,GOALvalue); + } +#endif + + break; + } + } + } + } + else + { + e1 = e->E1; + op1 = e1->Eoper; + if (op1 != OPvar) + { + local_exp(e1->E1,1); + if (OTbinary(op1)) + local_exp(e1->E2,1); + } + if (loctop) + { if (op1 == OPvar && + ((s = e1->EV.sp.Vsym)->Sflags & SFLunambig)) + local_symref(s); + else + local_ambigref(); + } + local_exp(e->E2,1); + } + if (op1 == OPvar && + ((s = e1->EV.sp.Vsym)->Sflags & SFLunambig)) + { local_symref(s); + local_symdef(s); + if (op == OPaddass || op == OPxorass) + local_ins(e); + } + else if (loctop) + { + local_remove(LFambigdef | LFambigref); + } + break; +#if TX86 + case OPstrlen: +#endif + case OPind: + local_exp(e->E1,1); + local_ambigref(); + break; + + case OPnewarray: + case OPmultinewarray: + local_exp(e->E1,1); + local_exp(e->E2,1); + goto Lrd; + + case OPstrcmp: + case OPmemcmp: + case OPbt: + case OParray: + case OPfield: + local_exp(e->E1,1); + local_exp(e->E2,1); + local_ambigref(); + break; + + case OPstrcpy: + case OPmemcpy: + case OPstrcat: + case OPcall: + case OPcallns: + local_exp(e->E2,1); + case OPstrctor: + case OPucall: + case OPucallns: + local_exp(e->E1,1); + goto Lrd; + + case OPbtc: + case OPbtr: + case OPbts: + local_exp(e->E1,1); + local_exp(e->E2,1); + goto Lrd; + case OPasm: + Lrd: + local_remove(LFfloat | LFambigref | LFambigdef); + break; + +#if TX86 + case OPmemset: + local_exp(e->E2,1); + if (e->E1->Eoper == OPvar) + { + /* Don't want to rearrange (p = get(); p memset 0;) + * as elemxxx() will rearrange it back. + */ + s = e->E1->EV.sp.Vsym; + if (s->Sflags & SFLunambig) + local_symref(s); + else + local_ambigref(); // ambiguous reference + } + else + local_exp(e->E1,1); + local_ambigdef(); + break; +#endif + + case OPvar: + s = e->EV.sp.Vsym; + if (loctop) + { unsigned u; + + // If potential candidate for replacement + if (s->Sflags & SFLunambig) + { + for (u = 0; u < loctop; u++) + { elem *em; + + em = loctab[u].e; + if (em->E1->EV.sp.Vsym == s && + (em->Eoper == OPeq || em->Eoper == OPstreq)) + { + if (tysize(em->Ety) == tysize(e->Ety) && + em->E1->EV.sp.Voffset == e->EV.sp.Voffset && + (tyfloating(em->Ety) != 0) == (tyfloating(e->Ety) != 0)) + { +#ifdef DEBUG + if (debugc) + { dbg_printf("Moved equation "); + WReqn(em); + dbg_printf(";\n"); + } +#endif + changes++; + em->Ety = e->Ety; + el_copy(e,em); + em->E1 = em->E2 = NULL; + em->Eoper = OPconst; + } + local_rem(u); + break; + } + } + local_symref(s); + } + else + local_ambigref(); // ambiguous reference + } + break; + + case OPremquo: + if (e->E1->Eoper != OPvar) + goto case_bin; + s = e->E1->EV.sp.Vsym; + if (loctop) + { + if (s->Sflags & SFLunambig) + local_symref(s); + else + local_ambigref(); // ambiguous reference + } + goal = 1; + e = e->E2; + goto Loop; + + default: + if (OTcommut(e->Eoper)) + { // Since commutative operators may get their leaves + // swapped, we eliminate any that may be affected by that. + + for (u = 0; u < loctop;) + { + int f1,f2,f; + elem *eu; + + f = loctab[u].flags; + eu = loctab[u].e; + s = eu->E1->EV.sp.Vsym; + f1 = local_getflags(e->E1,s); + f2 = local_getflags(e->E2,s); + if (f1 & f2 & LFsymref || // if both reference or + (f1 | f2) & LFsymdef || // either define + f & LFambigref && (f1 | f2) & LFambigdef || + f & LFambigdef && (f1 | f2) & (LFambigref | LFambigdef) + ) + local_rem(u); + else if (f & LFunambigdef && local_chkrem(e,eu->E2)) + local_rem(u); + else + u++; + } + } + if (EUNA(e)) + { goal = 1; + e = e->E1; + goto Loop; + } + case_bin: + if (EBIN(e)) + { local_exp(e->E1,1); + goal = 1; + e = e->E2; + goto Loop; + } + break; + } // end of switch (e->Eoper) +} + +/////////////////////////////////// +// Examine expression tree eu to see if it defines any variables +// that e refs or defs. +// Note that e is a binary operator. +// Returns: +// !=0 if it does + +STATIC int local_chkrem(elem *e,elem *eu) +{ int f1,f2; + int op; + symbol *s; + int result = 0; + + while (1) + { elem_debug(eu); + op = eu->Eoper; + if (OTassign(op) && eu->E1->Eoper == OPvar) + { s = eu->E1->EV.sp.Vsym; + f1 = local_getflags(e->E1,s); + f2 = local_getflags(e->E2,s); + if ((f1 | f2) & (LFsymref | LFsymdef)) // if either reference or define + { result = 1; + break; + } + } + if (OTbinary(op)) + { if (local_chkrem(e,eu->E2)) + { result = 1; + break; + } + } + else if (!OTunary(op)) + break; // leaf node + eu = eu->E1; + } + return result; +} + +////////////////////////////////////// +// Add entry e to loctab[] + +STATIC void local_ins(elem *e) +{ + elem_debug(e); + if (e->E1->Eoper == OPvar) + { symbol *s; + + s = e->E1->EV.sp.Vsym; + symbol_debug(s); + if (s->Sflags & SFLunambig) // if can only be referenced directly + { int flags; + + flags = local_getflags(e->E2,NULL); +#if TX86 + if (!(flags & (LFvolatile | LFinp | LFoutp)) && +#else + if (!(flags & LFvolatile) && +#endif + !(e->E1->Ety & mTYvolatile)) + { + // Add e to the candidate array + //dbg_printf("local_ins('%s'), loctop = %d, locmax = %d\n",s->Sident,loctop,locmax); + assert(loctop < locmax); + loctab[loctop].e = e; + loctab[loctop].flags = flags; + loctop++; + } + } + } +} + +////////////////////////////////////// +// Remove entry i from loctab[], and then compress the table. +// + +STATIC void local_rem(unsigned u) +{ + //dbg_printf("local_rem(%u)\n",u); + assert(u < loctop); + if (u + 1 != loctop) + { assert(u < loctop); + loctab[u] = loctab[loctop - 1]; + } + loctop--; +} + +////////////////////////////////////// +// Analyze and gather LFxxxx flags about expression e and symbol s. + +STATIC int local_getflags(elem *e,symbol *s) +{ int flags; + + elem_debug(e); + if (s) + symbol_debug(s); + flags = 0; + while (1) + { + if (e->Ety & mTYvolatile) + flags |= LFvolatile; + switch (e->Eoper) + { + case OPeq: + case OPstreq: + if (e->E1->Eoper == OPvar) + { symbol *s1; + + s1 = e->E1->EV.sp.Vsym; + if (s1->Sflags & SFLunambig) + flags |= (s1 == s) ? LFsymdef : LFunambigdef; + else + flags |= LFambigdef; + } + else + flags |= LFambigdef; + goto L1; + + case OPpostinc: + case OPpostdec: + case OPaddass: + case OPminass: + case OPmulass: + case OPdivass: + case OPmodass: + case OPashrass: + case OPshrass: + case OPshlass: + case OPandass: + case OPxorass: + case OPorass: + if (e->E1->Eoper == OPvar) + { symbol *s1; + + s1 = e->E1->EV.sp.Vsym; + if (s1->Sflags & SFLunambig) + flags |= (s1 == s) ? LFsymdef | LFsymref + : LFunambigdef | LFunambigref; + else + flags |= LFambigdef | LFambigref; + } + else + flags |= LFambigdef | LFambigref; + L1: + flags |= local_getflags(e->E2,s); + e = e->E1; + break; + + case OPucall: + case OPucallns: + case OPcall: + case OPcallns: + case OPnewarray: + case OPmultinewarray: +#if TX86 + case OPstrcat: + case OPstrcpy: + case OPmemcpy: + case OPbtc: + case OPbtr: + case OPbts: +#endif + case OPstrctor: + flags |= LFambigref | LFambigdef; + break; + +#if TX86 + case OPmemset: + flags |= LFambigdef; + break; +#endif + + case OPvar: + if (e->EV.sp.Vsym == s) + flags |= LFsymref; + else if (!(e->EV.sp.Vsym->Sflags & SFLunambig)) + flags |= LFambigref; + break; + + case OPind: + case OParray: + case OPfield: +#if TX86 + case OPstrlen: + case OPstrcmp: + case OPmemcmp: + case OPbt: +#endif + flags |= LFambigref; + break; + +#if TX86 + case OPinp: + flags |= LFinp; + break; + + case OPoutp: + flags |= LFoutp; + break; +#endif + } + if (EUNA(e)) + { + if (tyfloating(e->Ety)) + flags |= LFfloat; + e = e->E1; + } + else if (EBIN(e)) + { + if (tyfloating(e->Ety)) + flags |= LFfloat; + flags |= local_getflags(e->E2,s); + e = e->E1; + } + else + break; + } + return flags; +} + +////////////////////////////////////// +// Remove all entries with flags set. +// + +STATIC void local_remove(int flags) +{ unsigned u; + + for (u = 0; u < loctop;) + { + if (loctab[u].flags & flags) + local_rem(u); + else + u++; + } +} + +////////////////////////////////////// +// Ambiguous reference. Remove all with ambiguous defs +// + +STATIC void local_ambigref() +{ unsigned u; + + for (u = 0; u < loctop;) + { + if (loctab[u].flags & LFambigdef) + local_rem(u); + else + u++; + } +} + +////////////////////////////////////// +// Ambigous definition. Remove all with ambiguous refs. +// + +STATIC void local_ambigdef() +{ unsigned u; + + for (u = 0; u < loctop;) + { + if (loctab[u].flags & (LFambigref | LFambigdef)) + local_rem(u); + else + u++; + } +} + +////////////////////////////////////// +// Reference to symbol. +// Remove any that define that symbol. + +STATIC void local_symref(symbol *s) +{ unsigned u; + + symbol_debug(s); + for (u = 0; u < loctop;) + { + if (local_getflags(loctab[u].e,s) & LFsymdef) + local_rem(u); + else + u++; + } +} + +////////////////////////////////////// +// Definition of symbol. +// Remove any that reference that symbol. + +STATIC void local_symdef(symbol *s) +{ unsigned u; + + symbol_debug(s); + for (u = 0; u < loctop;) + { + if (local_getflags(loctab[u].e,s) & (LFsymref | LFsymdef)) + local_rem(u); + else + u++; + } +} + +#endif diff --git a/backend/gloop.c b/backend/gloop.c new file mode 100644 index 00000000..d8600ac9 --- /dev/null +++ b/backend/gloop.c @@ -0,0 +1,3628 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if (SCPP || MARS) && !HTOD + +#include +#include +#include + +#include "cc.h" +#include "el.h" +#include "go.h" +#include "oper.h" +#include "global.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/*#define vec_copy(t,f) (dbg_printf("line %d\n",__LINE__),vec_copy((t),(f)))*/ + +extern mftype mfoptim; + +struct Iv; + +/********************************* + * Loop data structure. + */ + +struct loop +{ loop *Lnext; // Next loop in list (startloop -> start of list) + vec_t Lloop; // Vector of blocks in this loop + vec_t Lexit; // Vector of exit blocks of loop + block *Lhead; // Pointer to header of loop + block *Ltail; // Pointer to tail + block *Lpreheader; // Pointer to preheader (if any) + list_t Llis; // loop invariant elems moved to Lpreheader, so + // redundant temporaries aren't created + Iv *Livlist; // basic induction variables + Iv *Lopeqlist; // list of other op= variables + void print(); + static loop *mycalloc(); + + static loop *freelist; +}; + +struct famlist +{ elem **FLpelem; /* parent of elem in the family */ + elem *c1,*c2; /* c1*(basic IV) + c2 */ +#define FLELIM ((symbol *)-1) + symbol *FLtemp; // symbol index of temporary (FLELIM if */ + /* this entry has no temporary) */ + tym_t FLty; /* type of this induction variable */ + tym_t FLivty; /* type of the basic IV elem (which is */ + /* not necessarilly the type of the IV */ + /* elem!) */ + famlist *FLnext; // next in list + void print(); + + static famlist *mycalloc(); + + static famlist *freelist; +}; + +struct Iv +{ + symbol *IVbasic; // symbol of basic IV + elem **IVincr; // pointer to parent of IV increment elem + famlist *IVfamily; // variables in this family + Iv *IVnext; // next iv in list + void print(); + + static Iv *mycalloc(); + + static Iv *freelist; +}; + +STATIC void freeloop(loop **pl); +STATIC void buildloop(loop **pl, block *head, block *tail); +STATIC void insert(block *b , vec_t lv); +STATIC void movelis(elem *n,block *b,loop *l,int *pdomexit); +STATIC int looprotate(loop *l); +STATIC void markinvar(elem *n , vec_t rd); +STATIC bool refs(symbol *v , elem *n , elem *nstop); +STATIC void appendelem(elem *n , elem **pn); +STATIC void freeivlist(Iv *biv); +STATIC void unmarkall(elem *e); +void filterrd(vec_t f,vec_t rd,symbol *s); +STATIC void filterrdind(vec_t f,vec_t rd,elem *e); +STATIC famlist * simfl(famlist *fl , tym_t tym); +STATIC famlist * newfamlist(tym_t ty); +STATIC void loopiv(loop *l); +STATIC void findbasivs(loop *l); +STATIC void findopeqs(loop *l); +STATIC void findivfams(loop *l); +STATIC void ivfamelems(Iv *biv , elem **pn); +STATIC void elimfrivivs(loop *l); +STATIC void intronvars(loop *l); +STATIC bool funcprev(Iv *biv , famlist *fl); +STATIC void elimbasivs(loop *l); +STATIC void elimopeqs(loop *l); +STATIC famlist * flcmp(famlist *f1 , famlist *f2); +STATIC elem ** onlyref(symbol *x , loop *l , elem *incn , int *prefcount); +STATIC void countrefs(elem **pn , bool flag); +STATIC int countrefs2(elem *e); +STATIC void elimspec(loop *l); +STATIC void elimspecwalk(elem **pn); + +static bool addblk; /* if TRUE, then we added a block */ + +/* is elem loop invariant? */ +#define isLI(n) ((n)->Nflags & NFLli) + +/* make elem loop invariant */ +#define makeLI(n) ((n)->Nflags |= NFLli) + +/****************************** + * UNAMBIG being defined means that: + * Only variables that could only be unambiguously defined + * are candidates for loop invariant removal and induction + * variables. + * This means only variables that have the SFLunambig flag + * set for them. + * Doing this will still cover 90% (I hope) of the cases, and + * is a lot faster to compute. + */ + +#define UNAMBIG 1 + +/**************************** + */ + +void famlist::print() +{ +#ifdef DEBUG + dbg_printf("famlist:\n"); + dbg_printf("*FLpelem:\n"); + elem_print(*FLpelem); + dbg_printf("c1:"); + elem_print(c1); + dbg_printf("c2:"); + elem_print(c2); + dbg_printf("FLty = "); WRTYxx(FLty); + dbg_printf("\nFLivty = "); WRTYxx(FLivty); + dbg_printf("\n"); +#endif +} + + +/**************************** + */ + +void Iv::print() +{ +#ifdef DEBUG + dbg_printf("IV: '%s'\n",IVbasic->Sident); + dbg_printf("*IVincr:\n"); + elem_print(*IVincr); +#endif +} + +/*********************** + * Write loop. + */ + +void loop::print() +{ +#ifdef DEBUG + loop *l = this; + dbg_printf("loop %p, next = %p\n",l,(l) ? l->Lnext : (loop *) NULL); + if (!l) + return; + dbg_printf("\thead: B%d, tail: B%d, prehead: B%d\n",l->Lhead->Bdfoidx, + l->Ltail->Bdfoidx,(l->Lpreheader ) ? l->Lpreheader->Bdfoidx : + (unsigned)-1); + dbg_printf("\tLloop "); vec_println(l->Lloop); + dbg_printf("\tLexit "); vec_println(l->Lexit); +#endif +} + +/*************************** + * Allocate loop. + */ + +loop *loop::freelist = NULL; + +loop *loop::mycalloc() +{ loop *l; + + if (freelist) + { + l = freelist; + freelist = l->Lnext; + memset(l,0,sizeof(loop)); + } + else + l = (loop *) mem_calloc(sizeof(loop)); + return l; +} + +/************* + * Free loops. + */ + +STATIC void freeloop(loop **pl) +{ loop *ln; + loop *l; + + for (l = *pl; l; l = ln) + { ln = l->Lnext; + vec_free(l->Lloop); + vec_free(l->Lexit); + list_free(&l->Llis); + l->Lnext = loop::freelist; + loop::freelist = l; + } + *pl = NULL; +} + +/********************************** + * Initialize block information. + * Returns: + * !=0 contains BCasm block + */ + +int blockinit() +{ register unsigned i; + register block *b; + int hasasm = 0; + + assert(dfo); + for (i = 0, b = startblock; b; i++, b = b->Bnext) + { +#ifdef DEBUG /* check integrity of Bpred and Bsucc */ + register list_t blp; + + for (blp = b->Bpred; blp; blp = list_next(blp)) + { register list_t bls; + + for (bls = list_block(blp)->Bsucc; bls; bls = list_next(bls)) + if (list_block(bls) == b) + goto L1; + assert(0); + L1: ; + } +#endif + if (b->BC == BCasm) + hasasm = 1; + ; /* compute number of blocks */ + } + assert(numblks == i && maxblks); + assert(i <= maxblks); + for (i = 0; i < dfotop; i++) + { assert(dfo[i]->Bdfoidx == i); + if (!dfo[i]->Bdom) + dfo[i]->Bdom = vec_calloc(maxblks); /* alloc Bdom vectors */ + } + return hasasm; +} + +/**************************************** + * Compute dominators (Bdom) for each block. + * See Aho & Ullman Fig. 13.5. + * Note that flow graph is reducible if there is only one + * pass through the loop. + * Input: + * dfo[] + * Output: + * fills in the Bdom vector for each block + */ + +void compdom() +{ unsigned i; + unsigned cntr; + vec_t t1; + list_t bl; + bool chgs; + block *sb; + + assert(dfo); + sb = dfo[0]; // starting block + t1 = vec_calloc(vec_numbits(sb->Bdom)); // allocate a temporary + vec_clear(sb->Bdom); + vec_setbit(0,sb->Bdom); // starting block only doms itself + for (i = 1; i < dfotop; i++) // for all except startblock + vec_set(dfo[i]->Bdom); // dominate all blocks + cntr = 0; // # of times thru loop + do + { chgs = FALSE; + for (i = 1; i < dfotop; ++i) // for each block in dfo[] + { // except startblock + bl = dfo[i]->Bpred; + if (bl) // if there are predecessors + { vec_copy(t1,list_block(bl)->Bdom); + while ((bl = list_next(bl)) != NULL) + vec_andass(t1,list_block(bl)->Bdom); + } + else + vec_clear(t1); // no predecessors to dominate + vec_setbit(i,t1); // each block doms itself + if (chgs) + vec_copy(dfo[i]->Bdom,t1); + else if (!vec_equal(dfo[i]->Bdom,t1)) // if any changes + { vec_copy(dfo[i]->Bdom,t1); + chgs = TRUE; + } + } + cntr++; + assert(cntr < 50); // should have converged by now + } while (chgs); + vec_free(t1); + if (cntr <= 2) + cmes("Flow graph is reducible\n"); + else + cmes("Flow graph is not reducible\n"); +} + +/*************************** + * Return !=0 if block A dominates block B. + */ + +HINT dom(block *A,block *B) +{ + assert(A && B && dfo && dfo[A->Bdfoidx] == A); + return vec_testbit(A->Bdfoidx,B->Bdom); +} + +/********************** + * Find all the loops. + */ + +STATIC void findloops(loop **ploops) +{ unsigned i; + list_t bl; + block *b,*s; + + freeloop(ploops); + + //printf("findloops()\n"); + for (i = 0; i < dfotop; i++) + dfo[i]->Bweight = 1; /* reset Bweights */ + for (i = dfotop; i--;) /* for each block (note reverse */ + /* dfo order, so most nested */ + /* loops are found first) */ + { b = dfo[i]; + assert(b); + for (bl = b->Bsucc; bl; bl = list_next(bl)) + { s = list_block(bl); /* each successor s to b */ + assert(s); + if (dom(s,b)) /* if s dominates b */ + buildloop(ploops,s,b); // we found a loop + } + } + +#ifdef DEBUG + if (debugc) + { loop *l; + + for (l = *ploops; l; l = l->Lnext) + { + l->print(); + } + } +#endif +} + +/******************************** + */ + +STATIC void loop_weight(block *b,int factor) +{ + // Be careful not to overflow + if (b->Bweight < 0x10000) + b->Bweight *= 10 * factor; + else if (b->Bweight < 0x100000) + b->Bweight *= 2 * factor; + else + b->Bweight += factor; +} + +/***************************** + * Construct natural loop. + * Algorithm 13.1 from Aho & Ullman. + * Note that head dom tail. + */ + +STATIC void buildloop(loop **ploops,block *head,block *tail) +{ loop *l; + unsigned i; + list_t bl; + + //printf("buildloop()\n"); + /* See if this is part of an existing loop. If so, merge the two. */ + for (l = *ploops; l; l = l->Lnext) + if (l->Lhead == head) /* two loops with same header */ + { + vec_t v; + + // Calculate loop contents separately so we get the Bweights + // done accurately. + + v = vec_calloc(maxblks); + vec_setbit(head->Bdfoidx,v); + loop_weight(head,1); + insert(tail,v); + + vec_orass(l->Lloop,v); // merge into existing loop + vec_free(v); + + vec_clear(l->Lexit); // recompute exit blocks + goto L1; + } + + /* Allocate loop entry */ + l = loop::mycalloc(); + l->Lnext = *ploops; + *ploops = l; // put l at beginning of list + + l->Lloop = vec_calloc(maxblks); /* allocate loop bit vector */ + l->Lexit = vec_calloc(maxblks); /* bit vector for exit blocks */ + l->Lhead = head; + l->Ltail = tail; + + vec_setbit(head->Bdfoidx,l->Lloop); /* add head to the loop */ + loop_weight(head,2); // *20 usage for loop header + + insert(tail,l->Lloop); /* insert tail in loop */ + +L1: + /* Find all the exit blocks (those blocks with + * successors outside the loop). + */ + + foreach (i,dfotop,l->Lloop) /* for each block in this loop */ + { if (dfo[i]->BC == BCret || dfo[i]->BC == BCretexp || dfo[i]->BC == BCexit) + vec_setbit(i,l->Lexit); /* ret blocks are exit blocks */ + else + { for (bl = dfo[i]->Bsucc; bl; bl = list_next(bl)) + if (!vec_testbit(list_block(bl)->Bdfoidx,l->Lloop)) + { vec_setbit(i,l->Lexit); + break; + } + } + } + + /* Find preheader, if any, to the loop. + The preheader is a block that has only the head as a successor. + All other predecessors of head must be inside the loop. + */ + l->Lpreheader = NULL; + for (bl = head->Bpred; bl; bl = list_next(bl)) + { block *b = list_block(bl); + + if (!vec_testbit(b->Bdfoidx,l->Lloop)) /* if not in loop */ + { if (l->Lpreheader) /* if already one */ + { l->Lpreheader = NULL; /* can only be one */ + break; + } + else + { if (list_next(b->Bsucc)) // if more than 1 successor + break; // b can't be a preheader + l->Lpreheader = b; + } + } + } +} + +/******************************** + * Support routine for buildloop(). + * Add a block b and all its predecessors to loop lv. + */ + +STATIC void insert(register block *b, register vec_t lv) +{ register list_t bl; + + assert(b && lv); + if (!vec_testbit(b->Bdfoidx,lv)) /* if block is not in loop */ + { vec_setbit(b->Bdfoidx,lv); /* add block to loop */ + loop_weight(b,1); // *10 usage count + for (bl = b->Bpred; bl; bl = list_next(bl)) + insert(list_block(bl),lv); /* insert all its predecessors */ + } +} + +/************************************** + * Perform loop rotations. + * Loop starts as: + * + * prehead + * | + * v + * +->head----> + * | | + * | v + * | body + * | | + * | v + * +--tail + * + * Two types are done: + * 1) Header is moved to be past the tail. + * + * prehead + * | + * +---+ + * | + * | body<-+ + * | | | + * | v | + * | tail | + * | | | + * | v | + * +->head--+ + * | + * v + * + * 2) Header is copied past the tail (done only if MFtime is set). + * + * prehead + * | + * v + * head1-----+ + * | | + * v | + * body<--+ | + * | | | + * v | | + * tail | | + * | | | + * v | | + * head2--+ | + * | | + * +--------+ + * v + * + * Input: + * Loop information (do not depend on the preheader information) + * Output: + * Revised list of blocks, a new dfo and new loop information + * Returns: + * TRUE need to recompute loop data + */ + +STATIC int looprotate(loop *l) +{ + register block *tail = l->Ltail; + register block *head = l->Lhead; + register block *b; + + //printf("looprotate(%p)\n",l); + + // Do not rotate loop if: + if (head == tail || // loop is only one block big + !vec_testbit(head->Bdfoidx,l->Lexit)) // header is not an exit block + goto Lret; + + if (//iter != 1 && + vec_testbit(tail->Bdfoidx,l->Lexit)) // tail is an exit block + goto Lret; + + // Do not rotate if already rotated + for (b = tail->Bnext; b; b = b->Bnext) + if (b == head) // if loop already rotated + goto Lret; + +#if SCPP + if (head->BC == BCtry) + goto Lret; +#endif + if (head->BC == BC_try) + goto Lret; +#ifdef DEBUG + //if (debugc) { dbg_printf("looprotate: "); l->print(); } +#endif + + if ((mfoptim & MFtime) && head->BC != BCswitch && head->BC != BCasm) + { // Duplicate the header past the tail (but doing + // switches would be too expensive in terms of code + // generated). + register block *head2; + register list_t bl, *pbl2, *pbl, *pbln; + + head2 = block_calloc(); // create new head block + numblks++; // number of blocks in existence + head2->Btry = head->Btry; + head2->Bflags = head->Bflags; + head->Bflags = BFLnomerg; // move flags over to head2 + head2->Bflags |= BFLnomerg; + head2->BC = head->BC; + assert(head2->BC != BCswitch); + if (head->Belem) // copy expression tree + head2->Belem = el_copytree(head->Belem); + head2->Bnext = tail->Bnext; + tail->Bnext = head2; + + // pred(head1) = pred(head) outside loop + // pred(head2) = pred(head) inside loop + pbl2 = &(head2->Bpred); + for (pbl = &(head->Bpred); *pbl; pbl = pbln) + { + if (vec_testbit(list_block(*pbl)->Bdfoidx, l->Lloop)) + { // if this predecessor is inside the loop + + *pbl2 = *pbl; + *pbl = list_next(*pbl); + pbln = pbl; // don't skip this next one + list_next(*pbl2) = NULL; + bl = list_block(*pbl2)->Bsucc; + pbl2 = &(list_next(*pbl2)); + for (; bl; bl = list_next(bl)) + if (list_block(bl) == head) + { + list_ptr(bl) = (void *)head2; + goto L2; + } + assert(0); + L2: ; + } + else + pbln = &(list_next(*pbl)); // next predecessor in list + } // for each pred(head) + + // succ(head2) = succ(head) + for (bl = head->Bsucc; bl; bl = list_next(bl)) + { + list_append(&(head2->Bsucc),list_block(bl)); + list_append(&(list_block(bl)->Bpred),head2); + } + changes++; + return TRUE; + } + else if (startblock != head + /* This screws up the OPctor/OPdtor sequence for: + * struct CString + * { CString(); + * ~CString(); + * int GetLength(); + * }; + * + * void f(void) + * { for(;;) + * { CString s ; + * if(s.GetLength()!=0) + * break ; + * } + * } + */ + && !(config.flags3 & CFG3eh) + ) + { // optimize for space + // Simply position the header past the tail + for (b = startblock; b; b = b->Bnext) + if (b->Bnext == head) + goto L1; // found parent b of head + assert(0); + + L1: + b->Bnext = head->Bnext; + head->Bnext = tail->Bnext; + tail->Bnext = head; + cmes2( "Rotated loop %p\n", l); + changes++; + } +Lret: + return FALSE; +} + +static int gref; // parameter for markinvar() +static block *gblock; // parameter for markinvar() +static vec_t lv; // parameter for markinvar() +static vec_t gin; // parameter for markinvar() +static bool doflow; // TRUE if flow analysis has to be redone + +/********************************* + * Loop invariant and induction variable elimination. + * Input: + * iter which optimization iteration we are on + */ + +void loopopt() +{ + list_t bl; + loop *l; + loop *ln; + vec_t rd; + loop *startloop; + + cmes("loopopt()\n"); + startloop = NULL; +restart: + file_progress(); + if (blockinit()) // init block data + { + findloops(&startloop); // Compute Bweights + freeloop(&startloop); // free existing loops + return; // can't handle ASM blocks + } + compdom(); // compute dominators + findloops(&startloop); // find the loops + + for (l = startloop; l; l = ln) + { + ln = l->Lnext; + if (looprotate(l)) // rotate the loop + { + compdfo(); + blockinit(); + compdom(); + findloops(&startloop); // may trash l->Lnext + if (ln) + { ln = startloop; // start over + file_progress(); + } + } + } + // Make sure there is a preheader for each loop. + + addblk = FALSE; /* assume no blocks added */ + for (l = startloop; l; l = l->Lnext)/* for each loop */ + { +#ifdef DEBUG + //if (debugc) l->print(); +#endif + if (!l->Lpreheader) /* if no preheader */ + { register block *h, *p; + + cmes("Generating preheader for loop\n"); + addblk = TRUE; /* add one */ + p = block_calloc(); // the preheader + numblks++; + assert (numblks <= maxblks); + h = l->Lhead; /* loop header */ + + /* Find parent of h */ + if (h == startblock) + startblock = p; + else + { register block *ph; + + for (ph = startblock; 1; ph = ph->Bnext) + { assert(ph); /* should have found it */ + if (ph->Bnext == h) + break; + } + /* Link p into block list between ph and h */ + ph->Bnext = p; + } + p->Bnext = h; + + l->Lpreheader = p; + p->BC = BCgoto; + assert(p->Bsucc == NULL); + list_append(&(p->Bsucc),h); /* only successor is h */ + p->Btry = h->Btry; + + cmes3("Adding preheader %p to loop %p\n",p,l); + + // Move preds of h that aren't in the loop to preds of p + for (bl = h->Bpred; bl;) + { register block *b = list_block(bl); + + if (!vec_testbit (b->Bdfoidx, l->Lloop)) + { register list_t bls; + + list_append(&(p->Bpred), b); + list_subtract(&(h->Bpred), b); + bl = h->Bpred; /* dunno what subtract did */ + + /* Fix up successors of predecessors */ + for (bls = b->Bsucc; bls; bls = list_next(bls)) + if (list_block(bls) == h) + list_ptr(bls) = (void *)p; + } + else + bl = list_next(bl); + } + list_append(&(h->Bpred),p); /* p is a predecessor to h */ + } + } /* for */ + if (addblk) /* if any blocks were added */ + { + compdfo(); /* compute depth-first order */ + blockinit(); + compdom(); + findloops(&startloop); // recompute block info + addblk = FALSE; + } + + /* Do the loop optimizations. Note that accessing the loops */ + /* starting from startloop will access them in least nested */ + /* one first, thus moving LIs out as far as possible. */ + + doflow = TRUE; /* do flow analysis */ + cmes("Starting loop invariants\n"); + + for (l = startloop; l; l = l->Lnext) + { register unsigned i,j; + +#ifdef DEBUG + //if (debugc) l->print(); +#endif + file_progress(); + assert(l->Lpreheader); + if (doflow) + { + flowrd(); /* compute reaching definitions */ + flowlv(); /* compute live variables */ + flowae(); // compute available expressions + doflow = FALSE; /* no need to redo it */ + if (deftop == 0) /* if no definition elems */ + break; /* no need to optimize */ + } + lv = l->Lloop; + cmes2("...Loop %p start...\n",l); + + /* Unmark all elems in this loop */ + foreach (i,dfotop,lv) + if (dfo[i]->Belem) + unmarkall(dfo[i]->Belem); /* unmark all elems */ + + /* Find & mark all LIs */ + gin = vec_clone(l->Lpreheader->Bout); + rd = vec_calloc(deftop); /* allocate our running RD vector */ + foreach (i,dfotop,lv) /* for each block in loop */ + { block *b = dfo[i]; + + cmes2("B%d\n",i); + if (b->Belem) + { + vec_copy(rd, b->Binrd); // IN reaching defs +#if 0 + dbg_printf("i = %d\n",i); + { int j; + for (j = 0; j < deftop; j++) + elem_print(defnod[j].DNelem); + } + dbg_printf("rd : "); vec_println(rd); +#endif + gblock = b; + gref = 0; + if (b != l->Lhead) + gref = 1; + markinvar(b->Belem, rd); +#if 0 + dbg_printf("i = %d\n",i); + { int j; + for (j = 0; j < deftop; j++) + elem_print(defnod[j].DNelem); + } + dbg_printf("rd : "); vec_println(rd); + dbg_printf("Boutrd: "); vec_println(b->Boutrd); +#endif + assert(vec_equal(rd, b->Boutrd)); + } + else + assert(vec_equal(b->Binrd, b->Boutrd)); + } + vec_free(rd); + vec_free(gin); + + /* Move loop invariants */ + foreach (i,dfotop,lv) + { + int domexit; // TRUE if this block dominates all + // exit blocks of the loop + + foreach (j,dfotop,l->Lexit) /* for each exit block */ + { + if (!vec_testbit (i, dfo[j]->Bdom)) + { domexit = 0; + goto L1; // break if !(i dom j) + } + } + // if i dom (all exit blocks) + domexit = 1; + L1: ; + if (dfo[i]->Belem) + { // If there is any hope of making an improvement + if (domexit || l->Llis) + { if (dfo[i] != l->Lhead) + ; //domexit |= 2; + movelis(dfo[i]->Belem, dfo[i], l, &domexit); + } + } + } + //list_free(&l->Llis,FPNULL); + cmes2("...Loop %p done...\n",l); + + if (mfoptim & MFliv) + { loopiv(l); /* induction variables */ + if (addblk) /* if we added a block */ + { compdfo(); + goto restart; /* play it safe and start over */ + } + } + } /* for */ + freeloop(&startloop); +} + +/***************************** + * If elem is loop invariant, mark it. + * Input: + * lv = vector of all the blocks in this loop. + * rd = vector of loop invariants for this elem. This must be + * continually updated. + * Note that we do not iterate until no more LIs are found. The only + * thing this would buy us is stuff that depends on LI assignments. + */ + +STATIC void markinvar(elem *n,vec_t rd) +{ vec_t tmp; + unsigned i; + symbol *v; + elem *n1; + + assert(n && rd); + assert(vec_numbits(rd) == deftop); + switch (n->Eoper) + { + case OPaddass: case OPminass: case OPmulass: case OPandass: + case OPorass: case OPxorass: case OPdivass: case OPmodass: + case OPshlass: case OPshrass: case OPashrass: + case OPpostinc: case OPpostdec: + case OPcall: + markinvar(n->E2,rd); + case OPnegass: + n1 = n->E1; + if (n1->Eoper == OPind) + markinvar(n1->E1,rd); + else if (OTbinary(n1->Eoper)) + { markinvar(n1->E1,rd); + markinvar(n1->E2,rd); + } + L2: + if (n->Eoper == OPcall || + gblock->Btry || + !(n1->Eoper == OPvar && + symbol_isintab(n1->EV.sp.Vsym))) + { + gref = 1; + } + + updaterd(n,rd,NULL); + break; + + case OPcallns: + markinvar(n->E2,rd); + markinvar(n->E1,rd); + break; + +#if TX86 + case OPstrcpy: + case OPstrcat: + case OPmemcpy: + case OPmemset: + markinvar(n->E2,rd); + markinvar(n->E1,rd); + updaterd(n,rd,NULL); + break; + case OPbtc: + case OPbtr: + case OPbts: + markinvar(n->E1,rd); + markinvar(n->E2,rd); + updaterd(n,rd,NULL); + break; +#endif + case OPucall: + markinvar(n->E1,rd); + /* FALL-THROUGH */ + case OPasm: + gref = 1; + updaterd(n,rd,NULL); + break; + + case OPucallns: + case OPstrpar: + case OPstrctor: + case OPvector: +#if TX86 + case OPvoid: + case OPstrlen: + case OPinp: +#endif + markinvar(n->E1,rd); + break; + case OPcond: + case OPparam: +#if TX86 + case OPoutp: + case OPstrcmp: + case OPmemcmp: + case OPbt: // OPbt is like OPind, assume not LI +#endif + markinvar(n->E1,rd); + markinvar(n->E2,rd); + break; + case OPandand: + case OPoror: + markinvar(n->E1,rd); + tmp = vec_clone(rd); + markinvar(n->E2,tmp); + vec_orass(rd,tmp); /* rd |= tmp */ + vec_free(tmp); + break; + case OPcolon: + case OPcolon2: + tmp = vec_clone(rd); + markinvar(n->E1,rd); + markinvar(n->E2,tmp); + vec_orass(rd,tmp); /* rd |= tmp */ + vec_free(tmp); + break; + case OPaddr: // mark addresses of OPvars as LI + markinvar(n->E1,rd); + if (n->E1->Eoper == OPvar || isLI(n->E1)) + makeLI(n); + break; + case OPmsw: + case OPneg: case OPbool: case OPnot: case OPcom: + case OPs16_32: case OPd_s32: case OPs32_d: + case OPd_s16: case OPs16_d: case OPd_f: case OPf_d: + case OP32_16: case OPu8_16: + case OPld_d: case OPd_ld: + case OPld_u64: + case OPc_r: case OPc_i: + case OParraylength: + case OPnullcheck: + case OPu16_32: + case OPu16_d: case OPd_u16: + case OPs8_16: case OP16_8: + case OPd_u32: case OPu32_d: + +#if LONGLONG + case OPs32_64: case OPu32_64: + case OP64_32: + case OPd_s64: case OPd_u64: + case OPs64_d: + case OPu64_d: + case OP128_64: + case OPs64_128: + case OPu64_128: +#endif + case OPabs: + case OPsqrt: + case OPrndtol: + case OPsin: + case OPcos: + case OPrint: +#if TX86 + case OPsetjmp: + case OPbsf: + case OPbsr: + case OPbswap: +#endif +#if TARGET_SEGMENTED + case OPvp_fp: /* BUG for MacHandles */ + case OPnp_f16p: case OPf16p_np: case OPoffset: case OPnp_fp: + case OPcvp_fp: +#endif + markinvar(n->E1,rd); + if (isLI(n->E1)) /* if child is LI */ + makeLI(n); + break; + case OPeq: + case OPstreq: + markinvar(n->E2,rd); + n1 = n->E1; + markinvar(n1,rd); + + /* Determine if assignment is LI. Conditions are: */ + /* 1) Rvalue is LI */ + /* 2) Lvalue is a variable (simplifies things a lot) */ + /* 3) Lvalue can only be affected by unambiguous defs */ + /* 4) No rd's of lvalue that are within the loop (other */ + /* than the current def) */ + if (isLI(n->E2) && n1->Eoper == OPvar) /* 1 & 2 */ + { v = n1->EV.sp.Vsym; +#if UNAMBIG + if (v->Sflags & SFLunambig) +#endif + { + tmp = vec_calloc(deftop); + //filterrd(tmp,rd,v); + listrds(rd,n1,tmp); + foreach (i,deftop,tmp) + if (defnod[i].DNelem != n && + vec_testbit(defnod[i].DNblock->Bdfoidx,lv)) + goto L3; + makeLI(n); // then the def is LI + L3: vec_free(tmp); + } + } + goto L2; + + case OPadd: case OPmin: case OPmul: case OPand: + case OPor: case OPxor: case OPdiv: case OPmod: + case OPshl: case OPshr: case OPeqeq: case OPne: + case OPlt: case OPle: case OPgt: case OPge: + case OPashr: + case OPror: case OProl: + + case OPunord: case OPlg: case OPleg: case OPule: + case OPul: case OPuge: case OPug: case OPue: + case OPngt: case OPnge: case OPnlt: case OPnle: + case OPord: case OPnlg: case OPnleg: case OPnule: + case OPnul: case OPnuge: case OPnug: case OPnue: + + case OPinstanceof: + case OPfinalinstanceof: + case OPcheckcast: + case OPcomma: + case OPpair: + case OPrpair: + case OPscale: + case OPremquo: + case OPyl2x: + case OPyl2xp1: + markinvar(n->E1,rd); + markinvar(n->E2,rd); + if (isLI(n->E2) && isLI(n->E1)) + makeLI(n); + break; + + case OPind: /* must assume this is not LI */ + markinvar(n->E1,rd); + if (isLI(n->E1)) + { +#if 0 + // This doesn't work with C++, because exp2_ptrtocomtype() will + // transfer const to where it doesn't belong. + if (n->Ety & mTYconst) + { + makeLI(n); + } +#endif +#if 0 + // This was disabled because it was marking as LI + // the loop dimension for the [i] array if + // a[j][i] was in a loop. This meant the a[j] array bounds + // check for the a[j].length was skipped. + else if (n->Ejty) + { + tmp = vec_calloc(deftop); + filterrdind(tmp,rd,n); // only the RDs pertaining to n + + // if (no RDs within loop) + // then it's loop invariant + + foreach (i,deftop,tmp) // for each RD + if (vec_testbit(defnod[i].DNblock->Bdfoidx,lv)) + goto L10; // found a RD in the loop + + // If gref has occurred, this can still be LI + // if n is an AE that was also an AE at the + // point of gref. + // We can catch a subset of these cases by looking + // at the AEs at the start of the loop. + if (gref) + { int j; + + //printf("\tn is: "); WReqn(n); printf("\n"); + foreach (j,exptop,gin) + { elem *e = expnod[j]; + + //printf("\t\texpnod[%d] = %p\n",j,e); + //printf("\t\tAE is: "); WReqn(e); printf("\n"); + if (el_match2(n,e)) + { + makeLI(n); + //printf("Ind LI: "); WReqn(n); printf("\n"); + break; + } + } + } + else + makeLI(n); + L10: vec_free(tmp); + break; + } +#endif + } + break; + case OPvar: + v = n->EV.sp.Vsym; +#if UNAMBIG + if (v->Sflags & SFLunambig) // must be unambiguous to be LI +#endif + { + tmp = vec_calloc(deftop); + //filterrd(tmp,rd,v); // only the RDs pertaining to v + listrds(rd,n,tmp); // only the RDs pertaining to v + + // if (no RDs within loop) + // then it's loop invariant + + foreach (i,deftop,tmp) // for each RD + if (vec_testbit(defnod[i].DNblock->Bdfoidx,lv)) + goto L1; // found a RD in the loop + makeLI(n); + + L1: vec_free(tmp); + } + break; + case OPstring: + case OPrelconst: + case OPconst: /* constants are always LI */ + case OPhstring: + case OPframeptr: + makeLI(n); + break; + case OPinfo: + markinvar(n->E2,rd); + break; + + case OPstrthis: + case OPmark: + case OPctor: + case OPdtor: + case OPdctor: + case OPddtor: + case OPhalt: + case OPgot: // shouldn't OPgot be makeLI ? + break; + + default: +#ifdef DEBUG + WROP(n->Eoper); +#endif + //printf("n->Eoper = %d, OPconst = %d\n", n->Eoper, OPconst); + assert(0); + } +#ifdef DEBUG + if (debugc && isLI(n)) + { dbg_printf(" LI elem: "); + WReqn(n); + dbg_printf("\n"); + } +#endif +} + +/******************** + * Update rd vector. + * Input: + * n assignment elem or function call elem or OPasm elem + * rd reaching def vector to update + * (clear bits for defs we kill, set bit for n (which is the + * def we are genning)) + * vecdim deftop + */ + +void updaterd(elem *n,vec_t GEN,vec_t KILL) +{ unsigned op = n->Eoper; + unsigned i; + unsigned ni; + elem *t; + + assert(OTdef(op)); + assert(GEN); + elem_debug(n); + + // If unambiguous def + if (OTassign(op) && (t = n->E1)->Eoper == OPvar) + { symbol *d = t->EV.sp.Vsym; + targ_size_t toff = t->EV.sp.Voffset; + targ_size_t tsize; + targ_size_t ttop; + + tsize = (op == OPstreq) ? type_size(n->ET) : tysize(t->Ety); + ttop = toff + tsize; + + //printf("updaterd: "); WReqn(n); printf(" toff=%d, tsize=%d\n", toff, tsize); + + ni = (unsigned)-1; + + /* for all unambig defs in defnod[] */ + for (i = 0; i < deftop; i++) + { elem *tn = defnod[i].DNelem; + elem *tn1; + targ_size_t tn1size; + + if (tn == n) + ni = i; + + if (!OTassign(tn->Eoper)) + continue; + + // If def of same variable, kill that def + tn1 = tn->E1; + if (tn1->Eoper != OPvar || d != tn1->EV.sp.Vsym) + continue; + + // If t completely overlaps tn1 + tn1size = (tn->Eoper == OPstreq) + ? type_size(tn->ET) : tysize(tn1->Ety); + if (toff <= tn1->EV.sp.Voffset && + tn1->EV.sp.Voffset + tn1size <= ttop) + { + if (KILL) + vec_setbit(i,KILL); + vec_clearbit(i,GEN); + } + } + assert(ni != -1); + } +#if 0 + else if (OTassign(op) && t->Eoper != OPvar && t->Ejty) + { + ni = -1; + + // for all unambig defs in defnod[] + for (i = 0; i < deftop; i++) + { elem *tn = defnod[i].DNelem; + elem *tn1; + + if (tn == n) + ni = i; + + if (!OTassign(tn->Eoper)) + continue; + + // If def of same variable, kill that def + tn1 = tn->E1; + if (tn1->Eoper != OPind || t->Ejty != tn1->Ejty) + continue; + + if (KILL) + vec_setbit(i,KILL); + vec_clearbit(i,GEN); + } + assert(ni != -1); + } +#endif + else + { + /* Set bit in GEN for this def */ + for (i = 0; 1; i++) + { assert(i < deftop); // should find n in defnod[] + if (defnod[i].DNelem == n) + { ni = i; + break; + } + } + } + + vec_setbit(ni,GEN); // set bit in GEN for this def +} + +/*************************** + * Mark all elems as not being loop invariant. + */ + +STATIC void unmarkall(elem *e) +{ + for (; 1; e = e->E1) + { + assert(e); + e->Nflags &= ~NFLli; /* unmark this elem */ + if (OTunary(e->Eoper)) + continue; + else if (OTbinary(e->Eoper)) + { unmarkall(e->E2); + continue; + } + return; + } +} + +/******************************* + * Take a RD vector and filter out all RDs but + * ones that are defs of symbol s. + * Output: + * f + */ + +#if 0 // replaced by listrds() +void filterrd(vec_t f,vec_t rd,symbol *s) +{ + register unsigned i; + register elem *n; + + vec_copy(f,rd); +#if UNAMBIG + foreach (i,deftop,f) /* for each def in f */ + { n = defnod[i].DNelem; /* the definition elem */ + elem_debug(n); + if (n->Eoper == OPasm) // OPasm defs always reach (sigh) + continue; + /* Clear bit if it's not an unambiguous def of si */ + if (OTassign(n->Eoper)) /* if assignment elem */ + { if (!(n->E1->Eoper == OPvar && n->E1->EV.sp.Vsym == s + )) + vec_clearbit(i,f); + } + else /* else ambiguous def */ + vec_clearbit(i,f); // and couldn't def this var + } +#else + assert(0); /* not implemented */ +#endif +} +#endif + +/******************************* + * Take a RD vector and filter out all RDs but + * ones that are possible defs of OPind elem e. + * Output: + * f + */ + +#if 0 + +STATIC void filterrdind(vec_t f,vec_t rd,elem *e) +{ + unsigned i; + elem *n; + tym_t jty = e->Ejty; + + vec_copy(f,rd); +#if UNAMBIG + foreach (i,deftop,f) // for each def in f + { n = defnod[i].DNelem; // the definition elem + elem_debug(n); + if (n->Eoper == OPasm) // OPasm defs always reach (sigh) + continue; + // Clear bit if it's not an unambiguous def of si + if (OTassign(n->Eoper)) // if assignment elem + { elem *n1 = n->E1; + + if (n1->Eoper == OPind) + { + if (jty && n1->Ejty && jty != n1->Ejty) + vec_clearbit(i,f); + } + else if (n1->Eoper == OPvar) + { + if (jty || n1->EV.sp.Vsym->Sflags & SFLunambig) + vec_clearbit(i,f); + } + } + else if (OTcall(n->Eoper) && el_noreturn(n)) + vec_clearbit(i,f); + } +#else + assert(0); // not implemented +#endif +} + +#endif + +/******************************** + * Return TRUE if there are any refs of v in n before nstop is encountered. + * Input: + * refstop = -1 + */ + +static int refstop; /* flag to stop refs() */ + +STATIC bool refs(symbol *v,elem *n,elem *nstop) +{ register bool f; + register unsigned op; + + symbol_debug(v); + elem_debug(n); + assert(symbol_isintab(v)); + assert(v->Ssymnum < globsym.top); + assert(n); + + op = n->Eoper; +#if UNAMBIG + if (refstop == 0) + return FALSE; + f = FALSE; + if (OTunary(op)) + f = refs(v,n->E1,nstop); + else if (OTbinary(op)) + { if (ERTOL(n)) /* watch order of evaluation */ + { + /* Note that (OPvar = e) is not a ref of OPvar, whereas */ + /* ((OPbit OPvar) = e) is a ref of OPvar, and (OPvar op= e) is */ + /* a ref of OPvar, etc. */ + f = refs(v,n->E2,nstop); + if (!f) + { if (op == OPeq) + { if (n->E1->Eoper != OPvar) + f = refs(v,n->E1->E1,nstop); + } + else + f = refs(v,n->E1,nstop); + } + } + else + f = refs(v,n->E1,nstop) || refs(v,n->E2,nstop); + } + + if (n == nstop) + refstop = 0; + else if (n->Eoper == OPvar) /* if variable reference */ + return v == n->EV.sp.Vsym; + else if (op == OPasm) /* everything is referenced */ + return TRUE; + return f; +#else + assert(0); +#endif +} + +/************************* + * Move LIs to preheader. + * Conditions to be satisfied for code motion are: + * 1) All exit blocks are dominated (TRUE before this is called). + * -- OR -- + * 2) Variable assigned by a statement is not live on entering + * any successor outside the loop of any exit block of the + * loop. + * + * 3) Cannot move assignment to variable if there are any other + * assignments to that variable within the loop (TRUE or + * assignment would not have been marked LI). + * 4) Cannot move assignments to a variable if there is a use + * of that variable in this loop that is reached by any other + * def of it. + * 5) Cannot move expressions that have side effects. + * 6) Do not move assignments to variables that could be affected + * by ambiguous defs. + * 7) It is not worth it to move expressions of the form: + * (var == const) + * Input: + * n the elem we're considering moving + * b the block this elem is in + * l the loop we're in + * domexit flags + * bit 0: 1 this branch is always executed + * 0 this branch is only sometimes executed + * bit 1: 1 do not move LIs that could throw exceptions + * or cannot be moved past possibly thrown exceptions + * Returns: + * revised domexit + */ + +STATIC void movelis(elem *n,block *b,loop *l,int *pdomexit) +{ register unsigned i,j,op; + register vec_t tmp; + register elem *ne,*t,*n2; + register list_t nl; + symbol *v; + tym_t ty; + +Lnextlis: + //if (isLI(n)) { printf("movelis("); WReqn(n); printf(")\n"); } + assert(l && n); + elem_debug(n); + op = n->Eoper; + switch (op) + { + case OPvar: + case OPconst: + case OPrelconst: + goto Lret; + + case OPandand: + case OPoror: + case OPcond: + { int domexit; + + movelis(n->E1,b,l,pdomexit); // always executed + domexit = *pdomexit & ~1; // sometimes executed + movelis(n->E2,b,l,&domexit); + *pdomexit |= domexit & 2; + goto Lret; + } + + case OPeq: + // Do loop invariant assignments + if (isLI(n) && n->E1->Eoper == OPvar) + { v = n->E1->EV.sp.Vsym; // variable index number + + #ifdef UNAMBIG + if (!(v->Sflags & SFLunambig)) goto L3; // case 6 + #endif + + // If case 4 is not satisfied, return + + // Function parameters have an implied definition prior to the + // first block of the function. Unfortunately, the rd vector + // does not take this into account. Therefore, we assume the + // worst and reject assignments to function parameters. + if (v->Sclass == SCparameter || v->Sclass == SCregpar || v->Sclass == SCfastpar) + goto L3; + + if (el_sideeffect(n->E2)) goto L3; // case 5 + + // If case 1 or case 2 is not satisfied, return + + if (!(*pdomexit & 1)) // if not case 1 + { + foreach (i,dfotop,l->Lexit) // for each exit block + { register list_t bl; + + for (bl = dfo[i]->Bsucc; bl; bl = list_next(bl)) + { block *s; // successor to exit block + + s = list_block(bl); + if (!vec_testbit(s->Bdfoidx,l->Lloop) && + (!symbol_isintab(v) || + vec_testbit(v->Ssymnum,s->Binlv))) // if v is live on exit + goto L3; + } + } + } + + tmp = vec_calloc(deftop); + foreach (i,dfotop,l->Lloop) // for each block in loop + { + if (dfo[i] == b) // except this one + continue; + + // + // + // return; + + //filterrd(tmp,dfo[i]->Binrd,v); + listrds(dfo[i]->Binrd,n->E1,tmp); + foreach (j,deftop,tmp) // for each RD of v in Binrd + { if (defnod[j].DNelem == n) + continue; + refstop = -1; + if (dfo[i]->Belem && + refs(v,dfo[i]->Belem,(elem *)NULL)) //if refs of v + { vec_free(tmp); + goto L3; + } + break; + } + } // foreach + + // Binrd other than n> + // + // + + //filterrd(tmp,b->Binrd,v); + listrds(b->Binrd,n->E1,tmp); + foreach (j,deftop,tmp) // for each RD of v in Binrd + { if (defnod[j].DNelem == n) + continue; + refstop = -1; + if (b->Belem && refs(v,b->Belem,n)) + { vec_free(tmp); + goto L3; // can't move it + } + break; // avoid redundant looping + } + vec_free(tmp); + + // We have an LI assignment, n. + // Check to see if the rvalue is already in the preheader. + for (nl = l->Llis; nl; nl = list_next(nl)) + { + if (el_match(n->E2,list_elem(nl)->E2)) + { + el_free(n->E2); + n->E2 = el_calloc(); + el_copy(n->E2,list_elem(nl)->E1); + cmes("LI assignment rvalue was replaced\n"); + doflow = TRUE; + changes++; + break; + } + } + + // move assignment elem to preheader + cmes("Moved LI assignment "); + #ifdef DEBUG + if (debugc) + { WReqn(n); + dbg_printf(";\n"); + } + #endif + changes++; + doflow = TRUE; // redo flow analysis + ne = el_calloc(); + el_copy(ne,n); // create assignment elem + assert(l->Lpreheader); // make sure there is one + appendelem(ne,&(l->Lpreheader->Belem)); // append ne to preheader + list_prepend(&l->Llis,ne); + + el_copy(n,ne->E1); // replace n with just a reference to v + goto Lret; + } // if + break; + + case OPcall: + case OPucall: + *pdomexit |= 2; + break; + } + +L3: + // Do leaves of non-LI expressions, leaves of = elems that didn't + // meet the invariant assignment removal criteria, and don't do leaves + if (OTleaf(op)) + goto Lret; + if (!isLI(n) || op == OPeq || op == OPcomma || OTrel(op) || op == OPnot || + // These are usually addressing modes, so moving them is a net loss + (I32 && op == OPshl && n->E2->Eoper == OPconst && el_tolong(n->E2) <= 3ull) + ) + { + if (OTassign(op)) + { elem *n1 = n->E1; + elem *n11; + + if (OTbinary(op)) + movelis(n->E2,b,l,pdomexit); + + // Do lvalue only if it is an expression + if (n1->Eoper == OPvar) + goto Lret; + n11 = n1->E1; + if (OTbinary(n1->Eoper)) + { + movelis(n11,b,l,pdomexit); + n = n1->E2; + } + // If *(x + c), just make x the LI, not the (x + c). + // The +c comes free with the addressing mode. + else if (n1->Eoper == OPind && + isLI(n11) && + n11->Eoper == OPadd && + n11->E2->Eoper == OPconst + ) + { + n = n11->E1; + } + else + n = n11; + movelis(n,b,l,pdomexit); + if (b->Btry || !(n1->Eoper == OPvar && symbol_isintab(n1->EV.sp.Vsym))) + { + //printf("assign to global => domexit |= 2\n"); + *pdomexit |= 2; + } + } + else if (OTunary(op)) + { elem *e1 = n->E1; + + // If *(x + c), just make x the LI, not the (x + c). + // The +c comes free with the addressing mode. + if (op == OPind && + isLI(e1) && + e1->Eoper == OPadd && + e1->E2->Eoper == OPconst + ) + { + n = e1->E1; + } + else + n = e1; + } + else if (OTbinary(op)) + { movelis(n->E1,b,l,pdomexit); + n = n->E2; + } + goto Lnextlis; + } + + if (el_sideeffect(n)) + goto Lret; + +#if 0 +printf("*pdomexit = %d\n",*pdomexit); + if (*pdomexit & 2) + { + // If any indirections, can't LI it + + // If this operand has already been indirected, we can let + // it pass. + Symbol *s; + +printf("looking at:\n"); +elem_print(n); + s = el_basesym(n->E1); + if (s) + { + for (nl = l->Llis; nl; nl = list_next(nl)) + { elem *el; + tym_t ty2; + + el = list_elem(nl); + el = el->E2; +elem_print(el); + if (el->Eoper == OPind && el_basesym(el->E1) == s) + { +printf(" pass!\n"); + goto Lpass; + } + } + } +printf(" skip!\n"); + goto Lret; + + Lpass: + ; + } +#endif + + // Move the LI expression to the preheader + cmes("Moved LI expression "); +#ifdef DEBUG + if (debugc) + { WReqn(n); + dbg_printf(";\n"); + } +#endif + + // See if it's already been moved + ty = n->Ety; + for (nl = l->Llis; nl; nl = list_next(nl)) + { elem *el; + tym_t ty2; + + el = list_elem(nl); + //printf("existing LI: "); WReqn(el); printf("\n"); + ty2 = el->E2->Ety; + if (tysize(ty) == tysize(ty2)) + { el->E2->Ety = ty; + if (el_match(n,el->E2)) + { + el->E2->Ety = ty2; + if (!OTleaf(n->Eoper)) + { el_free(n->E1); + if (OTbinary(n->Eoper)) + el_free(n->E2); + } + el_copy(n,el->E1); // make copy of temp + n->Ety = ty; +#ifdef DEBUG + if (debugc) + { dbg_printf("Already moved: LI expression replaced with "); + WReqn(n); + dbg_printf("\nPreheader %d expression %p ", + l->Lpreheader->Bdfoidx,l->Lpreheader->Belem); + WReqn(l->Lpreheader->Belem); + dbg_printf("\n"); + } +#endif + changes++; + doflow = TRUE; // redo flow analysis + goto Lret; + } + el->E2->Ety = ty2; + } + } + + if (!(*pdomexit & 1)) // if only sometimes executed + { cmes(" doesn't dominate exit\n"); + goto Lret; // don't move LI + } + + if (tyaggregate(n->Ety)) + goto Lret; + + changes++; + doflow = TRUE; // redo flow analysis + + t = el_alloctmp(n->Ety); /* allocate temporary t */ +#if DEBUG + cmes2("movelis() introduced new variable '%s' of type ",t->EV.sp.Vsym->Sident); + if (debugc) WRTYxx(t->Ety); + cmes("\n"); +#endif + n2 = el_calloc(); + el_copy(n2,n); /* create copy n2 of n */ + ne = el_bin(OPeq,t->Ety,t,n2); /* create elem t=n2 */ + assert(l->Lpreheader); /* make sure there is one */ + appendelem(ne,&(l->Lpreheader->Belem)); /* append ne to preheader */ +#ifdef DEBUG + if (debugc) + { dbg_printf("Preheader %d expression %p\n\t", + l->Lpreheader->Bdfoidx,l->Lpreheader->Belem); + WReqn(l->Lpreheader->Belem); + dbg_printf("\nLI expression replaced with "); WReqn(t); + dbg_printf("\n"); + } +#endif + el_copy(n,t); /* replace this elem with t */ + + // Remember LI expression in elem list + list_prepend(&l->Llis,ne); + +Lret: + ; +} + +/*************************** + * Append elem to existing elem using an OPcomma elem. + * Input: + * n elem to append + * *pn elem to append to + */ + +STATIC void appendelem(register elem *n,elem **pn) +{ + assert(n && pn); + if (*pn) /* if this elem exists */ + { while ((*pn)->Eoper == OPcomma) /* while we see OPcomma elems */ + { (*pn)->Ety = n->Ety; + pn = &((*pn)->E2); /* cruise down right side */ + } + *pn = el_bin(OPcomma,n->Ety,*pn,n); + } + else + *pn = n; /* else create a elem */ +} + +/************** LOOP INDUCTION VARIABLES **********************/ + +/*************************** + * Allocate famlist. + */ + +famlist *famlist::freelist = NULL; + +famlist *famlist::mycalloc() +{ famlist *fl; + + if (freelist) + { + fl = freelist; + freelist = fl->FLnext; + memset(fl,0,sizeof(famlist)); + } + else + fl = (famlist *) mem_calloc(sizeof(famlist)); + return fl; +} + +/*************************** + * Allocate Iv. + */ + +Iv *Iv::freelist = NULL; + +Iv *Iv::mycalloc() +{ Iv *iv; + + if (freelist) + { + iv = freelist; + freelist = iv->IVnext; + memset(iv,0,sizeof(Iv)); + } + else + iv = (Iv *) mem_calloc(sizeof(Iv)); + return iv; +} + +/********************* + * Free iv list. + */ + +STATIC void freeivlist(register Iv *biv) +{ register Iv *bivnext; + + while (biv) + { register famlist *fl,*fln; + + for (fl = biv->IVfamily; fl; fl = fln) + { el_free(fl->c1); + el_free(fl->c2); + fln = fl->FLnext; + + fl->FLnext = famlist::freelist; + famlist::freelist = fl; + } + bivnext = biv->IVnext; + + biv->IVnext = Iv::freelist; + Iv::freelist = biv; + + biv = bivnext; + } +} + +/**************************** + * Create a new famlist entry. + */ + +STATIC famlist * newfamlist(tym_t ty) +{ register famlist *fl; + union eve c; + + memset(&c,0,sizeof(c)); + fl = famlist::mycalloc(); + fl->FLty = ty; + switch (tybasic(ty)) + { case TYfloat: + c.Vfloat = 1; + break; + case TYdouble: + case TYdouble_alias: + c.Vdouble = 1; + break; + case TYldouble: + c.Vldouble = 1; + break; +#if _MSDOS || __OS2__ || _WIN32 // if no byte ordering problems +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYnptr: + case TYfptr: + case TYvptr: +#endif + /* Convert pointers to integrals to avoid things like */ + /* multiplying pointers */ + ty = TYptrdiff; + /* FALL-THROUGH */ + default: + c.Vlong = 1; + break; +#if TARGET_SEGMENTED + case TYhptr: + ty = TYlong; + c.Vlong = 1; + break; +#endif +#else + case TYbool: + case TYchar: + case TYschar: + case TYuchar: + c.Vchar = 1; + break; + case TYshort: + case TYushort: + case TYchar16: + case TYwchar_t: // BUG: what about 4 byte wchar_t's? + c.Vshort = 1; + break; +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYfptr: + case TYvptr: +#endif + case TYnptr: + case TYnullptr: + ty = TYint; + if (I64) + ty = TYllong; + /* FALL-THROUGH */ + case TYint: + case TYuint: + c.Vint = 1; + break; +#if TARGET_SEGMENTED + case TYhptr: + ty = TYlong; +#endif + case TYlong: + case TYulong: + case TYdchar: + default: + c.Vlong = 1; + break; +#if 0 + default: + printf("ty = x%x\n", tybasic(ty)); + assert(0); +#endif +#endif + } + fl->c1 = el_const(ty,&c); /* c1 = 1 */ + c.Vldouble = 0; + if (typtr(ty)) + { + ty = TYint; +#if TARGET_SEGMENTED + if (tybasic(ty) == TYhptr) + ty = TYlong; +#endif + if (I64) + ty = TYllong; + } + fl->c2 = el_const(ty,&c); /* c2 = 0 */ + return fl; +} + +/*************************** + * Remove induction variables from loop l. + * Loop invariant removal should have been done just previously. + */ + +STATIC void loopiv(register loop *l) +{ + cmes2("loopiv(%p)\n",l); + assert(l->Livlist == NULL && l->Lopeqlist == NULL); + elimspec(l); + if (doflow) + { flowrd(); /* compute reaching defs */ + flowlv(); /* compute live variables */ + flowae(); // compute available expressions + doflow = FALSE; + } + findbasivs(l); /* find basic induction variables */ + findopeqs(l); // find op= variables + findivfams(l); /* find IV families */ + elimfrivivs(l); /* eliminate less useful family IVs */ + intronvars(l); /* introduce new variables */ + elimbasivs(l); /* eliminate basic IVs */ + if (!addblk) // adding a block changes the Binlv + elimopeqs(l); // eliminate op= variables + + freeivlist(l->Livlist); // free up IV list + l->Livlist = NULL; + freeivlist(l->Lopeqlist); // free up list + l->Lopeqlist = NULL; + + /* Do copy propagation and dead assignment elimination */ + /* upon return to optfunc() */ +} + +/************************************* + * Find basic IVs of loop l. + * A basic IV x of loop l is a variable x which has + * exactly one assignment within l of the form: + * x += c or x -= c, where c is either a constant + * or a LI. + * Input: + * defnod[] loaded with all the definition elems of the loop + */ + +STATIC void findbasivs(loop *l) +{ vec_t poss,notposs; + elem *n; + unsigned i,j; + bool ambdone; + + assert(l); + ambdone = FALSE; + poss = vec_calloc(globsym.top); + notposs = vec_calloc(globsym.top); /* vector of all variables */ + /* (initially all unmarked) */ + + /* for each def in defnod[] that is within loop l */ + + for (i = 0; i < deftop; i++) + { if (!vec_testbit(defnod[i].DNblock->Bdfoidx,l->Lloop)) + continue; /* def is not in the loop */ + + n = defnod[i].DNelem; + elem_debug(n); + if (OTassign(n->Eoper) && n->E1->Eoper == OPvar) + { symbol *s; /* if unambiguous def */ + + s = n->E1->EV.sp.Vsym; + if (symbol_isintab(s)) + { + SYMIDX v; + + v = n->E1->EV.sp.Vsym->Ssymnum; + if ((n->Eoper == OPaddass || n->Eoper == OPminass || + n->Eoper == OPpostinc || n->Eoper == OPpostdec) && + (cnst(n->E2) || /* if x += c or x -= c */ + n->E2->Eoper == OPvar && isLI(n->E2))) + { if (vec_testbit(v,poss)) + /* We've already seen this def elem, */ + /* therefore there is more than one */ + /* def of v within the loop, therefore */ + /* v is not a basic IV. */ + vec_setbit(v,notposs); + else + vec_setbit(v,poss); + } + else /* else mark as not possible */ + vec_setbit(v,notposs); + } + } + else /* else ambiguous def */ + { /* mark any vars that could be affected by */ + /* this def as not possible */ + + if (!ambdone) /* avoid redundant loops */ + { for (j = 0; j < globsym.top; j++) + { if (!(globsym.tab[j]->Sflags & SFLunambig)) + vec_setbit(j,notposs); + } + ambdone = TRUE; + } + } + } +#if 0 + dbg_printf("poss "); vec_println(poss); + dbg_printf("notposs "); vec_println(notposs); +#endif + vec_subass(poss,notposs); /* poss = poss - notposs */ + + /* create list of IVs */ + foreach (i,globsym.top,poss) /* for each basic IV */ + { register Iv *biv; + symbol *s; + + /* Skip if we don't want it to be a basic IV (see funcprev()) */ + s = globsym.tab[i]; + assert(symbol_isintab(s)); + if (s->Sflags & SFLnotbasiciv) + continue; + + // Do not use aggregates as basic IVs. This is because the other loop + // code doesn't check offsets into symbols, (assuming everything + // is at offset 0). We could perhaps amend this by allowing basic IVs + // if the struct consists of only one data member. + if (tyaggregate(s->ty())) + continue; + + biv = Iv::mycalloc(); + biv->IVnext = l->Livlist; + l->Livlist = biv; // link into list of IVs + + biv->IVbasic = s; // symbol of basic IV + + cmes3("Symbol '%s' (%d) is a basic IV, ",s->Sident + ? (char *)s->Sident : "",i); + + /* We have the sym idx of the basic IV. We need to find */ + /* the parent of the increment elem for it. */ + + /* First find the defnod[] */ + for (j = 0; j < deftop; j++) + { /* If defnod is a def of i and it is in the loop */ + if (defnod[j].DNelem->E1 && /* OPasm are def nodes */ + defnod[j].DNelem->E1->EV.sp.Vsym == s && + vec_testbit(defnod[j].DNblock->Bdfoidx,l->Lloop)) + goto L1; + } + assert(0); /* should have found it */ + /* NOTREACHED */ + + L1: biv->IVincr = el_parent(defnod[j].DNelem,&(defnod[j].DNblock->Belem)); + assert(s == (*biv->IVincr)->E1->EV.sp.Vsym); +#ifdef DEBUG + if (debugc) + { dbg_printf("Increment elem is: "); WReqn(*biv->IVincr); dbg_printf("\n"); } +#endif + } + + vec_free(poss); + vec_free(notposs); +} + +/************************************* + * Find op= elems of loop l. + * Analogous to findbasivs(). + * Used to eliminate useless loop code normally found in benchmark programs. + * Input: + * defnod[] loaded with all the definition elems of the loop + */ + +STATIC void findopeqs(loop *l) +{ vec_t poss,notposs; + elem *n; + unsigned i,j; + bool ambdone; + + assert(l); + ambdone = FALSE; + poss = vec_calloc(globsym.top); + notposs = vec_calloc(globsym.top); // vector of all variables + // (initially all unmarked) + + // for each def in defnod[] that is within loop l + + for (i = 0; i < deftop; i++) + { if (!vec_testbit(defnod[i].DNblock->Bdfoidx,l->Lloop)) + continue; // def is not in the loop + + n = defnod[i].DNelem; + elem_debug(n); + if (OTopeq(n->Eoper) && n->E1->Eoper == OPvar) + { symbol *s; // if unambiguous def + + s = n->E1->EV.sp.Vsym; + if (symbol_isintab(s)) + { + SYMIDX v; + + v = n->E1->EV.sp.Vsym->Ssymnum; + { if (vec_testbit(v,poss)) + // We've already seen this def elem, + // therefore there is more than one + // def of v within the loop, therefore + // v is not a basic IV. + vec_setbit(v,notposs); + else + vec_setbit(v,poss); + } + } + } + else // else ambiguous def + { // mark any vars that could be affected by + // this def as not possible + + if (!ambdone) // avoid redundant loops + { for (j = 0; j < globsym.top; j++) + { if (!(globsym.tab[j]->Sflags & SFLunambig)) + vec_setbit(j,notposs); + } + ambdone = TRUE; + } + } + } + + // Don't use symbols already in Livlist + for (Iv *iv = l->Livlist; iv; iv = iv->IVnext) + { symbol *s; + + s = iv->IVbasic; + vec_setbit(s->Ssymnum,notposs); + } + + +#if 0 + dbg_printf("poss "); vec_println(poss); + dbg_printf("notposs "); vec_println(notposs); +#endif + vec_subass(poss,notposs); // poss = poss - notposs + + // create list of IVs + foreach (i,globsym.top,poss) // for each opeq IV + { register Iv *biv; + symbol *s; + + s = globsym.tab[i]; + assert(symbol_isintab(s)); + + // Do not use aggregates as basic IVs. This is because the other loop + // code doesn't check offsets into symbols, (assuming everything + // is at offset 0). We could perhaps amend this by allowing basic IVs + // if the struct consists of only one data member. + if (tyaggregate(s->ty())) + continue; + + biv = Iv::mycalloc(); + biv->IVnext = l->Lopeqlist; + l->Lopeqlist = biv; // link into list of IVs + + biv->IVbasic = s; // symbol of basic IV + + cmes3("Symbol '%s' (%d) is an opeq IV, ",s->Sident + ? (char *)s->Sident : "",i); + + // We have the sym idx of the basic IV. We need to find + // the parent of the increment elem for it. + + // First find the defnod[] + for (j = 0; j < deftop; j++) + { // If defnod is a def of i and it is in the loop + if (defnod[j].DNelem->E1 && // OPasm are def nodes + defnod[j].DNelem->E1->EV.sp.Vsym == s && + vec_testbit(defnod[j].DNblock->Bdfoidx,l->Lloop)) + goto L1; + } + assert(0); // should have found it + // NOTREACHED + + L1: biv->IVincr = el_parent(defnod[j].DNelem,&(defnod[j].DNblock->Belem)); + assert(s == (*biv->IVincr)->E1->EV.sp.Vsym); +#ifdef DEBUG + if (debugc) + { dbg_printf("Opeq elem is: "); WReqn(*biv->IVincr); dbg_printf("\n"); } +#endif + Lcont: + ; + } + + vec_free(poss); + vec_free(notposs); +} + +/***************************** + * Find families for each basic IV. + * An IV family is a list of elems of the form + * c1*X+c2, where X is a basic induction variable. + * Note that we do not do divides, because of roundoff error problems. + */ + +STATIC void findivfams(register loop *l) +{ register Iv *biv; + register unsigned i; + register famlist *fl; + + cmes2("findivfams(%p)\n",l); + for (biv = l->Livlist; biv; biv = biv->IVnext) + { foreach (i,dfotop,l->Lloop) /* for each block in loop */ + if (dfo[i]->Belem) + ivfamelems(biv,&(dfo[i]->Belem)); + /* Fold all the constant expressions in c1 and c2. */ + for (fl = biv->IVfamily; fl; fl = fl->FLnext) + { fl->c1 = doptelem(fl->c1,GOALvalue | GOALagain); + fl->c2 = doptelem(fl->c2,GOALvalue | GOALagain); + } + } +} + +/************************* + * Tree walking support routine for findivfams(). + * biv = basic induction variable pointer + * pn pointer to elem + */ + +STATIC void ivfamelems(register Iv *biv,register elem **pn) +{ register unsigned op; + register tym_t ty,c2ty; + register famlist *f; + register elem *n,*n1,*n2; + + assert(pn); + n = *pn; + assert(biv && n); + op = n->Eoper; + if (OTunary(op)) + { ivfamelems(biv,&n->E1); + n1 = n->E1; + n2 = NULL; + } + else if (OTbinary(op)) + { ivfamelems(biv,&n->E1); + ivfamelems(biv,&n->E2); /* LTOR or RTOL order is unimportant */ + n1 = n->E1; + n2 = n->E2; + } + else /* else leaf elem */ + return; /* which can't be in the family */ + + if (op == OPmul || op == OPadd || op == OPmin || + op == OPneg || op == OPshl) + { /* Note that we are wimping out and not considering */ + /* LI variables as part of c1 and c2, but only constants. */ + + ty = n->Ety; + + /* Since trees are canonicalized, basic induction variables */ + /* will only appear on the left. */ + + /* Improvement: */ + /* We wish to pick up the cases (biv + li), (biv - li) and */ + /* (li + biv). OPmul and LS with bivs are out, since if we */ + /* try to eliminate the biv, and the loop test is a >, >=, */ + /* <, <=, we have a problem since we don't know if the li */ + /* is negative. (Would have to call swaprel() on it.) */ + + /* If we have (li + var), swap the leaves. */ + if (op == OPadd && isLI(n1) && n1->Eoper == OPvar && n2->Eoper == OPvar) + { n->E1 = n2; + n2 = n->E2 = n1; + n1 = n->E1; + } + +#if TARGET_SEGMENTED + // Get rid of case where we painted a far pointer to a long + if (op == OPadd || op == OPmin) + { int sz; + + sz = tysize(ty); + if (sz == tysize[TYfptr] && !tyfv(ty) && + (sz != tysize(n1->Ety) || sz != tysize(n2->Ety))) + return; + } +#endif + + /* Look for function of basic IV (-biv or biv op const) */ + if (n1->Eoper == OPvar && n1->EV.sp.Vsym == biv->IVbasic) + { if (op == OPneg) + { register famlist *fl; + + cmes2("found (-biv), elem %p\n",n); + fl = newfamlist(ty); + fl->FLivty = n1->Ety; + fl->FLpelem = pn; + fl->FLnext = biv->IVfamily; + biv->IVfamily = fl; + fl->c1 = el_una(op,ty,fl->c1); /* c1 = -1 */ + } + else if (n2->Eoper == OPconst || + isLI(n2) && (op == OPadd || op == OPmin)) + { register famlist *fl; + +#ifdef DEBUG + if (debugc) + { dbg_printf("found (biv op const), elem ("); + WReqn(n); + dbg_printf(");\n"); + dbg_printf("Types: n1="); WRTYxx(n1->Ety); + dbg_printf(" ty="); WRTYxx(ty); + dbg_printf(" n2="); WRTYxx(n2->Ety); + dbg_printf("\n"); + } +#endif + fl = newfamlist(ty); + fl->FLivty = n1->Ety; + fl->FLpelem = pn; + fl->FLnext = biv->IVfamily; + biv->IVfamily = fl; + switch (op) + { case OPadd: /* c2 = right */ + c2ty = n2->Ety; + if (typtr(fl->c2->Ety)) + c2ty = fl->c2->Ety; + goto L1; + case OPmin: /* c2 = -right */ + c2ty = fl->c2->Ety; + /* Check for subtracting two pointers */ + if (typtr(c2ty) && typtr(n2->Ety)) + { +#if TARGET_SEGMENTED + if (tybasic(c2ty) == TYhptr) + c2ty = TYlong; + else +#endif + c2ty = I64 ? TYllong : TYint; + } + L1: + fl->c2 = el_bin(op,c2ty,fl->c2,el_copytree(n2)); + break; + case OPmul: /* c1 = right */ + case OPshl: /* c1 = 1 << right */ + fl->c1 = el_bin(op,ty,fl->c1,el_copytree(n2)); + break; + default: + assert(0); + } + } + } + + /* Look for function of existing IV */ + + for (f = biv->IVfamily; f; f = f->FLnext) + { if (*f->FLpelem != n1) /* not it */ + continue; + + /* Look for (f op constant) */ + if (op == OPneg) + { + cmes2("found (-f), elem %p\n",n); + /* c1 = -c1; c2 = -c2; */ + f->c1 = el_una(OPneg,ty,f->c1); + f->c2 = el_una(OPneg,ty,f->c2); + f->FLty = ty; + f->FLpelem = pn; /* replace with new IV */ + + } + else if (n2->Eoper == OPconst || + isLI(n2) && (op == OPadd || op == OPmin)) + { +#ifdef DEBUG + if (debugc) + { dbg_printf("found (f op const), elem ("); + WReqn(n); + assert(*pn == n); + dbg_printf(");\n"); + elem_print(n); + } +#endif + switch (op) + { case OPmul: + case OPshl: + f->c1 = el_bin(op,ty,f->c1,el_copytree(n2)); + break; + case OPadd: + case OPmin: + break; + default: + assert(0); + } + f->c2 = el_bin(op,ty,f->c2,el_copytree(n2)); + f->FLty = ty; + f->FLpelem = pn; /* replace with new IV */ + } /* else if */ + } /* for */ + } /* if */ +} + +/********************************* + * Eliminate frivolous family ivs, that is, + * if we can't eliminate the BIV, then eliminate family ivs that + * differ from it only by a constant. + */ + +STATIC void elimfrivivs(loop *l) +{ Iv *biv; + + for (biv = l->Livlist; biv; biv = biv->IVnext) + { int nfams; + famlist *fl; + int nrefs; + +cmes("elimfrivivs()\n"); + /* Compute number of family ivs for biv */ + nfams = 0; + for (fl = biv->IVfamily; fl; fl = fl->FLnext) + nfams++; +cmes2("nfams = %d\n",nfams); + + /* Compute number of references to biv */ + if (onlyref(biv->IVbasic,l,*biv->IVincr,&nrefs)) + nrefs--; +cmes2("nrefs = %d\n",nrefs); + assert(nrefs + 1 >= nfams); + if (nrefs > nfams || // if we won't eliminate the biv + (!I16 && nrefs == nfams)) + { /* Eliminate any family ivs that only differ by a constant */ + /* from biv */ + for (fl = biv->IVfamily; fl; fl = fl->FLnext) + { elem *ec1 = fl->c1; + targ_llong c; + + if (elemisone(ec1) || + // Eliminate fl's that can be represented by + // an addressing mode + (!I16 && ec1->Eoper == OPconst && tyintegral(ec1->Ety) && + ((c = el_tolong(ec1)) == 2 || c == 4 || c == 8) + ) + ) + { fl->FLtemp = FLELIM; +#ifdef DEBUG + if (debugc) + { dbg_printf("Eliminating frivolous IV "); + WReqn(*fl->FLpelem); + dbg_printf("\n"); + } +#endif + } + } + } + } +} + + +/****************************** + * Introduce new variables. + */ + +STATIC void intronvars(loop *l) +{ + famlist *fl; + Iv *biv; + elem *T, *ne, *t2, *C2, *cmul; + tym_t ty,tyr; + + cmes2("intronvars(%p)\n",l); + for (biv = l->Livlist; biv; biv = biv->IVnext) // for each basic IV + { register elem *bivinc = *biv->IVincr; /* ptr to increment elem */ + + for (fl = biv->IVfamily; fl; fl = fl->FLnext) + { /* for each IV in family of biv */ + if (fl->FLtemp == FLELIM) /* if already eliminated */ + continue; + + /* If induction variable can be written as a simple function */ + /* of a previous induction variable, skip it. */ + if (funcprev(biv,fl)) + continue; + + ty = fl->FLty; + T = el_alloctmp(ty); /* allocate temporary T */ + fl->FLtemp = T->EV.sp.Vsym; +#if DEBUG + cmes2("intronvars() introduced new variable '%s' of type ",T->EV.sp.Vsym->Sident); + if (debugc) WRTYxx(ty); + cmes("\n"); +#endif + + /* append elem T=biv*C1+C2 to preheader */ + /* ne = biv*C1 */ + tyr = fl->FLivty; /* type of biv */ + ne = el_var(biv->IVbasic); + ne->Ety = tyr; + if (!elemisone(fl->c1)) /* don't multiply ptrs by 1 */ + ne = el_bin(OPmul,tyr,ne,el_copytree(fl->c1)); + if (tyfv(tyr) && tysize(ty) == SHORTSIZE) + ne = el_una(OP32_16,ty,ne); + C2 = el_copytree(fl->c2); + t2 = el_bin(OPadd,ty,ne,C2); /* t2 = ne + C2 */ + ne = el_bin(OPeq,ty,el_copytree(T),t2); + appendelem(ne, &(l->Lpreheader->Belem)); + + /* prefix T+=C1*C to elem biv+=C */ + /* Must prefix in case the value of the expression (biv+=C) */ + /* is used by somebody up the tree. */ + cmul = el_bin(OPmul,fl->c1->Ety,el_copytree(fl->c1), + el_copytree(bivinc->E2)); + t2 = el_bin(bivinc->Eoper,ty,el_copytree(T),cmul); + t2 = doptelem(t2,GOALvalue | GOALagain); + *biv->IVincr = el_bin(OPcomma,bivinc->Ety,t2,bivinc); + biv->IVincr = &((*biv->IVincr)->E2); +#ifdef DEBUG + if (debugc) + { dbg_printf("Replacing elem ("); + WReqn(*fl->FLpelem); + dbg_printf(") with '%s'\n",T->EV.sp.Vsym->Sident); + dbg_printf("The init elem is ("); + WReqn(ne); + dbg_printf(");\nThe increment elem is ("); + WReqn(t2); + dbg_printf(")\n"); + } +#endif + el_free(*fl->FLpelem); + *fl->FLpelem = T; /* replace elem n with ref to T */ + doflow = TRUE; /* redo flow analysis */ + changes++; + } /* for */ + } /* for */ +} + +/******************************* + * Determine if induction variable can be rewritten as a simple + * function of a previously generated temporary. + * This can frequently + * generate less code than that of an all-new temporary (especially + * if it is the same as a previous temporary!). + * Input: + * biv Basic induction variable + * fl Item in biv's family list we are looking at + * Returns: + * FALSE Caller should create a new induction variable. + * TRUE *FLpelem is replaced with function of a previous + * induction variable. FLtemp is set to FLELIM to + * indicate this. + */ + +STATIC bool funcprev(Iv *biv,famlist *fl) +{ tym_t tymin; + int sz; + famlist *fls; + elem *e1,*e2,*flse1; + +#ifdef DEBUG + if (debugc) + dbg_printf("funcprev\n"); +#endif + for (fls = biv->IVfamily; fls != fl; fls = fls->FLnext) + { assert(fls); /* fl must be in list */ + if (fls->FLtemp == FLELIM) /* no iv we can use here */ + continue; + + /* The multipliers must match */ + if (!el_match(fls->c1,fl->c1)) + continue; + + /* If the c2's match also, we got it easy */ + if (el_match(fls->c2,fl->c2)) + { + if (tysize(fl->FLty) > tysize(fls->FLtemp->ty())) + continue; /* can't increase size of var */ + flse1 = el_var(fls->FLtemp); + flse1->Ety = fl->FLty; + goto L2; + } + + /* The difference is only in the addition. Therefore, replace + *fl->FLpelem with: + case 1: (fl->c2 + (fls->FLtemp - fls->c2)) + case 2: (fls->FLtemp + (fl->c2 - fls->c2)) + */ + e1 = fl->c2; + /* Subtracting relocatables usually generates slow code for */ + /* linkers that can't handle arithmetic on relocatables. */ + if (typtr(fls->c2->Ety)) + { if (fls->c2->Eoper == OPrelconst && + !(fl->c2->Eoper == OPrelconst && + fl->c2->EV.sp.Vsym == fls->c2->EV.sp.Vsym) + ) + continue; + } + flse1 = el_var(fls->FLtemp); + e2 = flse1; /* assume case 1 */ + tymin = e2->Ety; + if (typtr(fls->c2->Ety)) + { if (!typtr(tymin)) + { if (typtr(e1->Ety)) + { e1 = e2; + e2 = fl->c2; /* case 2 */ + } + else /* can't subtract fptr */ + goto L1; + } +#if TARGET_SEGMENTED + if (tybasic(fls->c2->Ety) == TYhptr) + tymin = TYlong; + else +#endif + tymin = I64 ? TYllong : TYint; /* type of (ptr - ptr) */ + } + +#if TARGET_SEGMENTED + /* If e1 and fls->c2 are fptrs, and are not from the same */ + /* segment, we cannot subtract them. */ + if (tyfv(e1->Ety) && tyfv(fls->c2->Ety)) + { if (e1->Eoper != OPrelconst || fls->c2->Eoper != OPrelconst) + goto L1; /* assume expressions have diff segs */ + if (e1->EV.sp.Vsym->Sclass != fls->c2->EV.sp.Vsym->Sclass) + { L1: + el_free(flse1); + continue; + } + } +#else +L1: + el_free(flse1); + continue; + +#endif + /* Some more type checking... */ + sz = tysize(fl->FLty); + if (sz != tysize(e1->Ety) && + sz != tysize(tymin)) + goto L1; + + /* Do some type checking (can't add pointers and get a pointer!) */ + //if (typtr(fl->FLty) && typtr(e1->Ety) && typtr(tymin)) + //goto L1; + /* Construct (e1 + (e2 - fls->c2)) */ + flse1 = el_bin(OPadd,fl->FLty, + e1, + el_bin(OPmin,tymin, + e2, + el_copytree(fls->c2))); + if (sz < tysize(tymin) && sz == tysize(e1->Ety)) +#if TARGET_SEGMENTED + flse1->E2 = el_una(OPoffset,fl->FLty,flse1->E2); +#else + assert(0); +#endif + + flse1 = doptelem(flse1,GOALvalue | GOALagain); + fl->c2 = NULL; + L2: +#ifdef DEBUG + if (debugc) + { dbg_printf("Replacing "); + WReqn(*fl->FLpelem); + dbg_printf(" with "); + WReqn(flse1); + dbg_printf("\n"); + } +#endif + el_free(*fl->FLpelem); + *fl->FLpelem = flse1; + + /* Fix the iv so when we do loops again, we won't create */ + /* yet another iv, which is just what funcprev() is supposed */ + /* to prevent. */ + fls->FLtemp->Sflags |= SFLnotbasiciv; + + fl->FLtemp = FLELIM; /* mark iv as being gone */ + changes++; + doflow = TRUE; + return TRUE; /* it was replaced */ + } + return FALSE; /* need to create a new variable */ +} + +/*********************** + * Eliminate basic IVs. + */ + +STATIC void elimbasivs(register loop *l) +{ famlist *fl; + register Iv *biv; + register unsigned i; + register tym_t ty; + register elem **pref,*fofe,*C2; + symbol *X; + int refcount; + + cmes2("elimbasivs(%p)\n",l); + for (biv = l->Livlist; biv; biv = biv->IVnext) // for each basic IV + { + + /* Can't eliminate this basic IV if we have a goal for the */ + /* increment elem. */ + // Be careful about Nflags being in a union... + if (!((*biv->IVincr)->Nflags & NFLnogoal)) + continue; + + X = biv->IVbasic; + assert(symbol_isintab(X)); + ty = X->ty(); + pref = onlyref(X,l,*biv->IVincr,&refcount); + + /* if only ref of X is of the form (X) or (X relop e) or (e relop X) */ + if (pref != NULL && refcount <= 1) + { elem *ref; + tym_t flty; + + fl = biv->IVfamily; + if (!fl) // if no elems in family of biv + continue; + + ref = *pref; + + /* Replace (X) with (X != 0) */ + if (ref->Eoper == OPvar) + ref = *pref = el_bin(OPne,TYint,ref,el_long(ref->Ety,0L)); + + fl = simfl(fl,ty); /* find simplest elem in family */ + if (!fl) + continue; + + // Don't do the replacement if we would replace a + // signed comparison with an unsigned one + flty = fl->FLty; + if (tyuns(ref->E1->Ety) | tyuns(ref->E2->Ety)) + flty = touns(flty); + + if (ref->Eoper >= OPle && ref->Eoper <= OPge && +#if 1 + !(tyuns(ref->E1->Ety) | tyuns(ref->E2->Ety)) && + tyuns(flty)) +#else + (tyuns(ref->E1->Ety) | tyuns(ref->E2->Ety)) != + tyuns(flty)) +#endif + continue; + + /* if we have (e relop X), replace it with (X relop e) */ + if (ref->E2->Eoper == OPvar && ref->E2->EV.sp.Vsym == X) + { register elem *tmp; + + tmp = ref->E2; + ref->E2 = ref->E1; + ref->E1 = tmp; + ref->Eoper = swaprel(ref->Eoper); + } + + // If e*c1+c2 would result in a sign change or an overflow + // then we can't do it + if (fl->c1->Eoper == OPconst) + { +#if LONGLONG + targ_llong c1; +#else + targ_long c1; +#endif + int sz; + + c1 = el_tolong(fl->c1); + sz = tysize(ty); + if (sz == SHORTSIZE && + ((ref->E2->Eoper == OPconst && + c1 * el_tolong(ref->E2) & ~0x7FFFL) || + c1 & ~0x7FFFL) + ) + continue; + + if (sz == LONGSIZE && + ((ref->E2->Eoper == OPconst && + c1 * el_tolong(ref->E2) & ~0x7FFFFFFFL) || + c1 & ~0x7FFFFFFFL) + ) + continue; +#if LONGLONG && __INTSIZE >= 4 + if (sz == LLONGSIZE && + ((ref->E2->Eoper == OPconst && + c1 * el_tolong(ref->E2) & ~0x7FFFFFFFFFFFFFFFLL) || + c1 & ~0x7FFFFFFFFFFFFFFFLL) + ) + continue; +#endif + } + + /* If loop started out with a signed conditional that was + * replaced with an unsigned one, don't do it if c2 + * is less than 0. + */ + if (ref->Nflags & NFLtouns && fl->c2->Eoper == OPconst) + { + targ_llong c2 = el_tolong(fl->c2); + if (c2 < 0) + continue; + } + + elem *refE2 = el_copytree(ref->E2); + int refEoper = ref->Eoper; + + /* if c1 < 0 and relop is < <= > >= + then adjust relop as if both sides were multiplied + by -1 + */ + if (!tyuns(ty) && + (tyintegral(ty) && el_tolong(fl->c1) < 0 || + tyfloating(ty) && el_toldouble(fl->c1) < 0.0)) + refEoper = swaprel(refEoper); + + /* Replace (X relop e) with (X relop (short)e) + if T is 1 word but e is 2 + */ + if (tysize(flty) == SHORTSIZE && + tysize(refE2->Ety) == LONGSIZE) + refE2 = el_una(OP32_16,flty,refE2); + + /* replace e with e*c1 + c2 */ + C2 = el_copytree(fl->c2); + fofe = el_bin(OPadd,flty, + el_bin(OPmul,refE2->Ety, + refE2, + el_copytree(fl->c1)), + C2); + fofe = doptelem(fofe,GOALvalue | GOALagain); // fold any constants + + if (tyuns(flty) && refEoper == OPge && + fofe->Eoper == OPconst && el_allbits(fofe, 0) && + fl->c2->Eoper == OPconst && !el_allbits(fl->c2, 0)) + { + /* Don't do it if replacement will result in + * an unsigned T>=0 which will be an infinite loop. + */ + el_free(fofe); + continue; + } + + cmes2("Eliminating basic IV '%s'\n",X->Sident); + +#ifdef DEBUG + if (debugc) + { dbg_printf("Comparison replaced: "); + WReqn(ref); + dbg_printf(" with "); + } +#endif + + el_free(ref->E2); + ref->E2 = refE2; + ref->Eoper = refEoper; + + elimass(*biv->IVincr); // dump the increment elem + + // replace X with T + assert(ref->E1->EV.sp.Voffset == 0); + ref->E1->EV.sp.Vsym = fl->FLtemp; + ref->E1->Ety = flty; + ref->E2 = fofe; + + /* If sizes of expression worked out wrong... + Which can happen if we have (int)ptr==e + */ + if (EBIN(fofe)) /* if didn't optimize it away */ + { int sz; + tym_t ty,ty1,ty2; + + ty = fofe->Ety; + sz = tysize(ty); + ty1 = fofe->E1->Ety; + ty2 = fofe->E2->Ety; + /* Sizes of + expression must all be the same */ + if (sz != tysize(ty1) && + sz != tysize(ty2) + ) + { + if (tyuns(ty)) /* if unsigned comparison */ + ty1 = touns(ty1); /* to unsigned type */ + fofe->Ety = ty1; + ref->E1->Ety = ty1; + } + } + +#if TARGET_SEGMENTED + /* Fix if leaves of compare are TYfptrs and the compare */ + /* operator is < <= > >=. */ + if (ref->Eoper >= OPle && ref->Eoper <= OPge && tyfv(ref->E1->Ety)) + { assert(tyfv(ref->E2->Ety)); + ref->E1 = el_una(OPoffset,TYuint,ref->E1); + ref->E2 = el_una(OPoffset,TYuint,fofe); + } +#endif +#ifdef DEBUG + if (debugc) + { WReqn(ref); + dbg_printf("\n"); + } +#endif + + changes++; + doflow = TRUE; /* redo flow analysis */ + + /* if X is live on entry to any successor S outside loop */ + /* prepend elem X=(T-c2)/c1 to S.Belem */ + + foreach (i,dfotop,l->Lexit) /* for each exit block */ + { register elem *ne; + register block *b; + register list_t bl; + + for (bl = dfo[i]->Bsucc; bl; bl = list_next(bl)) + { /* for each successor */ + b = list_block(bl); + if (vec_testbit(b->Bdfoidx,l->Lloop)) + continue; /* inside loop */ + if (!vec_testbit(X->Ssymnum,b->Binlv)) + continue; /* not live */ + + C2 = el_copytree(fl->c2); + ne = el_bin(OPmin,ty, + el_var(fl->FLtemp), + C2); +#if TARGET_SEGMENTED + if (tybasic(ne->E1->Ety) == TYfptr && + tybasic(ne->E2->Ety) == TYfptr) + { ne->Ety = I64 ? TYllong : TYint; + if (tylong(ty) && intsize == 2) + ne = el_una(OPs16_32,ty,ne); + } +#endif + + ne = el_bin(OPeq,X->ty(), + el_var(X), + el_bin(OPdiv,ne->Ety, + ne, + el_copytree(fl->c1))); +#ifdef DEBUG + if (debugc) + { dbg_printf("Adding ("); + WReqn(ne); + dbg_printf(") to exit block B%d\n",b->Bdfoidx); + //elem_print(ne); + } +#endif + /* We have to add a new block if there is */ + /* more than one predecessor to b. */ + if (list_next(b->Bpred)) + { block *bn; + register list_t bl2; + + bn = block_calloc(); + bn->Btry = b->Btry; + numblks++; + assert(numblks <= maxblks); + bn->BC = BCgoto; + bn->Bnext = dfo[i]->Bnext; + dfo[i]->Bnext = bn; + list_append(&(bn->Bsucc),b); + list_append(&(bn->Bpred),dfo[i]); + list_ptr(bl) = (void *)bn; + for (bl2 = b->Bpred; bl2; + bl2 = list_next(bl2)) + if (list_block(bl2) == dfo[i]) + { list_ptr(bl2) = (void *)bn; + goto L2; + } + assert(0); + L2: + b = bn; + addblk = TRUE; + } + + if (b->Belem) + b->Belem = + el_bin(OPcomma,b->Belem->Ety, + ne,b->Belem); + else + b->Belem = ne; + changes++; + doflow = TRUE; /* redo flow analysis */ + } /* for each successor */ + } /* foreach exit block */ + if (addblk) + return; + } + else if (refcount == 0) /* if no uses of IV in loop */ + { /* Eliminate the basic IV if it is not live on any successor */ + foreach (i,dfotop,l->Lexit) /* for each exit block */ + { register block *b; + register list_t bl; + + for (bl = dfo[i]->Bsucc; bl; bl = list_next(bl)) + { /* for each successor */ + b = list_block(bl); + if (vec_testbit(b->Bdfoidx,l->Lloop)) + continue; /* inside loop */ + if (vec_testbit(X->Ssymnum,b->Binlv)) + goto L1; /* live */ + } + } + + cmes3("No uses, eliminating basic IV '%s' (%p)\n",(X->Sident) + ? (char *)X->Sident : "",X); + + /* Dump the increment elem */ + /* (Replace it with an OPconst that only serves as a */ + /* placeholder in the tree) */ + *(biv->IVincr) = el_selecte2(*(biv->IVincr)); + + changes++; + doflow = TRUE; /* redo flow analysis */ + L1: ; + } + } /* for */ +} + + +/*********************** + * Eliminate opeq IVs that are not used outside the loop. + */ + +STATIC void elimopeqs(register loop *l) +{ + Iv *biv; + unsigned i; + elem **pref; + symbol *X; + int refcount; + + cmes2("elimopeqs(%p)\n",l); + for (biv = l->Lopeqlist; biv; biv = biv->IVnext) // for each opeq IV + { + + // Can't eliminate this basic IV if we have a goal for the + // increment elem. + // Be careful about Nflags being in a union... + if (!((*biv->IVincr)->Nflags & NFLnogoal)) + continue; + + X = biv->IVbasic; + assert(symbol_isintab(X)); + pref = onlyref(X,l,*biv->IVincr,&refcount); + + // if only ref of X is of the form (X) or (X relop e) or (e relop X) + if (pref != NULL && refcount <= 1) + ; + else if (refcount == 0) // if no uses of IV in loop + { // Eliminate the basic IV if it is not live on any successor + foreach (i,dfotop,l->Lexit) // for each exit block + { block *b; + list_t bl; + + for (bl = dfo[i]->Bsucc; bl; bl = list_next(bl)) + { // for each successor + b = list_block(bl); + if (vec_testbit(b->Bdfoidx,l->Lloop)) + continue; // inside loop + if (vec_testbit(X->Ssymnum,b->Binlv)) + goto L1; // live + } + } + + cmes3("No uses, eliminating opeq IV '%s' (%p)\n",(X->Sident) + ? (char *)X->Sident : "",X); + + // Dump the increment elem + // (Replace it with an OPconst that only serves as a + // placeholder in the tree) + *(biv->IVincr) = el_selecte2(*(biv->IVincr)); + + changes++; + doflow = TRUE; // redo flow analysis + L1: ; + } + } +} + +/************************** + * Find simplest elem in family. + * Input: + * tym type of basic IV + * Return NULL if none found. + */ + +STATIC famlist * simfl(famlist *fl,tym_t tym) +{ famlist *sofar; + + assert(fl); + sofar = NULL; + for (; fl; fl = fl->FLnext) + { + if (fl->FLtemp == FLELIM) /* no variable, so skip it */ + continue; + /* If size of replacement is less than size of biv, we could */ + /* be in trouble due to loss of precision. */ + if (size(fl->FLtemp->ty()) < size(tym)) + continue; + sofar = flcmp(sofar,fl); /* pick simplest */ + } + return sofar; +} + +/************************** + * Return simpler of two family elems. + * There is room for improvement, namely if + * f1.c1 = 2, f2.c1 = 27 + * then pick f1 because it is a shift. + */ + +STATIC famlist * flcmp(famlist *f1,famlist *f2) +{ tym_t ty; + union eve *t1,*t2; + + assert(f2); + if (!f1) + goto Lf2; + t1 = &(f1->c1->EV); + t2 = &(f2->c1->EV); + ty = (*f1->FLpelem)->Ety; /* type of elem */ +#if 0 + printf("f1: c1 = %d, c2 = %d\n",t1->Vshort,f1->c2->EV.Vshort); + printf("f2: c1 = %d, c2 = %d\n",t2->Vshort,f2->c2->EV.Vshort); + WRTYxx((*f1->FLpelem)->Ety); + WRTYxx((*f2->FLpelem)->Ety); +#endif + /* Wimp out and just pick f1 if the types don't match */ + if (tysize(ty) == tysize((*f2->FLpelem)->Ety)) + { + switch (tybasic(ty)) + { case TYbool: + case TYchar: + case TYschar: + case TYuchar: + if (t2->Vuchar == 1 || + t1->Vuchar != 1 && f2->c2->EV.Vuchar == 0) + goto Lf2; + break; + case TYshort: + case TYushort: + case TYchar16: + case TYwchar_t: // BUG: what about 4 byte wchar_t's? + case_short: + if (t2->Vshort == 1 || + t1->Vshort != 1 && f2->c2->EV.Vshort == 0) + goto Lf2; + break; + +#if JHANDLE + case TYjhandle: +#endif +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: +#endif + case TYnptr: // BUG: 64 bit pointers? + case TYnullptr: + case TYint: + case TYuint: + if (intsize == SHORTSIZE) + goto case_short; + else + goto case_long; + case TYlong: + case TYulong: + case TYdchar: +#if TARGET_SEGMENTED + case TYfptr: + case TYvptr: + case TYhptr: +#endif + case_long: + if (t2->Vlong == 1 || + t1->Vlong != 1 && f2->c2->EV.Vlong == 0) + goto Lf2; + break; + case TYfloat: + if (t2->Vfloat == 1 || + t1->Vfloat != 1 && f2->c2->EV.Vfloat == 0) + goto Lf2; + break; + case TYdouble: + case TYdouble_alias: + if (t2->Vdouble == 1.0 || + t1->Vdouble != 1.0 && f2->c2->EV.Vdouble == 0) + goto Lf2; + break; + case TYldouble: + if (t2->Vldouble == 1.0 || + t1->Vldouble != 1.0 && f2->c2->EV.Vldouble == 0) + goto Lf2; + break; + case TYllong: + case TYullong: + if (t2->Vllong == 1 || + t1->Vllong != 1 && f2->c2->EV.Vllong == 0) + goto Lf2; + break; + default: + assert(0); + } + } + //printf("picking f1\n"); + return f1; + +Lf2: + //printf("picking f2\n"); + return f2; +} + +/************************************ + * Input: + * x basic IV symbol + * incn increment elem for basic IV X. + * Output: + * *prefcount # of references to X other than the increment elem + * Returns: + * If ref of X in loop l is of the form (X relop e) or (e relop X) + * Return the relop elem + * Else + * Return NULL + */ + +static int count; +static elem **nd,*sincn; +static symbol *X; + +STATIC elem ** onlyref(symbol *x,loop *l,elem *incn,int *prefcount) +{ register unsigned i; + + //printf("onlyref('%s')\n", x->Sident); + X = x; /* save some parameter passing */ + assert(symbol_isintab(x)); + sincn = incn; +#ifdef DEBUG + if (!(X->Ssymnum < globsym.top && l && incn)) + dbg_printf("X = %d, globsym.top = %d, l = %p, incn = %p\n",X->Ssymnum,globsym.top,l,incn); +#endif + assert(X->Ssymnum < globsym.top && l && incn); + count = 0; + nd = NULL; + foreach (i,dfotop,l->Lloop) /* for each block in loop */ + { block *b; + + b = dfo[i]; + if (b->Belem) + { + countrefs(&b->Belem,b->BC == BCiftrue); + } + } +#if 0 + dbg_printf("count = %d, nd = ("); + if (nd) WReqn(*nd); + dbg_printf(")\n"); +#endif + *prefcount = count; + return nd; +} + +/****************************** + * Count elems of the form (X relop e) or (e relop X). + * Do not count the node if it is the increment node (sincn). + * Input: + * flag: TRUE if block wants to test the elem + */ + +STATIC void countrefs(register elem **pn,bool flag) +{ elem *n = *pn; + + assert(n); + if (n == sincn) /* if it is the increment elem */ + { + if (OTbinary(n->Eoper)) + countrefs(&n->E2, FALSE); + return; // don't count lvalue + } + if (OTunary(n->Eoper)) + countrefs(&n->E1,FALSE); + else if (OTbinary(n->Eoper)) + { + if (OTrel(n->Eoper)) + { elem *e1 = n->E1; + + assert(e1->Eoper != OPcomma); + if (e1 == sincn && + (e1->Eoper == OPeq || OTopeq(e1->Eoper))) + goto L1; + + /* Check both subtrees to see if n is the comparison node, + * that is, if X is a leaf of the comparison. + */ + if (e1->Eoper == OPvar && e1->EV.sp.Vsym == X && !countrefs2(n->E2) || + n->E2->Eoper == OPvar && n->E2->EV.sp.Vsym == X && !countrefs2(e1)) + nd = pn; /* found the relop node */ + } + L1: + countrefs(&n->E1,FALSE); + countrefs(&n->E2,(flag && n->Eoper == OPcomma)); + } + else if ((n->Eoper == OPvar || n->Eoper == OPrelconst) && n->EV.sp.Vsym == X) + { if (flag) + nd = pn; /* comparing it with 0 */ + count++; /* found another reference */ + } +} + +/******************************* + * Count number of times symbol X appears in elem tree e. + */ + +STATIC int countrefs2(elem *e) +{ + elem_debug(e); + while (OTunary(e->Eoper)) + e = e->E1; + if (OTbinary(e->Eoper)) + return countrefs2(e->E1) + countrefs2(e->E2); + return ((e->Eoper == OPvar || e->Eoper == OPrelconst) && + e->EV.sp.Vsym == X); +} + +/**************************** + * Eliminate some special cases. + */ + +STATIC void elimspec(loop *l) +{ register unsigned i; + + foreach (i,dfotop,l->Lloop) /* for each block in loop */ + { block *b; + + b = dfo[i]; + if (b->Belem) + elimspecwalk(&b->Belem); + } +} + +/****************************** + */ + +STATIC void elimspecwalk(elem **pn) +{ elem *n; + + n = *pn; + assert(n); + if (OTunary(n->Eoper)) + elimspecwalk(&n->E1); + else if (OTbinary(n->Eoper)) + { + elimspecwalk(&n->E1); + elimspecwalk(&n->E2); + if (OTrel(n->Eoper)) + { elem *e1 = n->E1; + + /* Replace ((e1,e2) rel e3) with (e1,(e2 rel e3). + * This will reduce the number of cases for elimbasivs(). + * Don't do equivalent with (e1 rel (e2,e3)) because + * of potential side effects in e1. + */ + if (e1->Eoper == OPcomma) + { elem *e; + +#ifdef DEBUG + if (debugc) + { dbg_printf("3rewriting ("); WReqn(n); dbg_printf(")\n"); } +#endif + e = n->E2; + n->E2 = e1; + n->E1 = n->E2->E1; + n->E2->E1 = n->E2->E2; + n->E2->E2 = e; + n->E2->Eoper = n->Eoper; + n->E2->Ety = n->Ety; + n->Eoper = OPcomma; + + changes++; + doflow = TRUE; + + elimspecwalk(&n->E1); + elimspecwalk(&n->E2); + } + + /* Rewrite ((X op= e2) rel e3) into ((X op= e2),(X rel e3)) + * Rewrite ((X ++ e2) rel e3) into ((X += e2),(X-e2 rel e3)) + * so that the op= will not have a goal, so elimbasivs() + * will work on it. + */ + if ((OTopeq(e1->Eoper) + || OTpost(e1->Eoper) + ) && + !el_sideeffect(e1->E1)) + { elem *e; + int op; +#ifdef DEBUG + if (debugc) + { dbg_printf("4rewriting ("); WReqn(n); dbg_printf(")\n"); } +#endif + e = el_calloc(); + el_copy(e,n); + e->E1 = el_copytree(e1->E1); + e->E1->Ety = n->E1->Ety; + n->E2 = e; + switch (e1->Eoper) + { case OPpostinc: + e1->Eoper = OPaddass; + op = OPmin; + goto L3; + case OPpostdec: + e1->Eoper = OPminass; + op = OPadd; + L3: e->E1 = el_bin(op,e->E1->Ety,e->E1,el_copytree(e1->E2)); + break; + + } + /* increment node is now guaranteed to have no goal */ + e1->Nflags |= NFLnogoal; + n->Eoper = OPcomma; + //changes++; + doflow = TRUE; + + elimspecwalk(&n->E1); + elimspecwalk(&n->E2); + } + } + } +} + +#endif diff --git a/backend/go.c b/backend/go.c new file mode 100644 index 00000000..74100f70 --- /dev/null +++ b/backend/go.c @@ -0,0 +1,368 @@ +// Copyright (C) 1986-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "el.h" +#include "go.h" +#include "type.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/**************************** + * Terminate use of globals. + */ + +void go_term() +{ + vec_free(defkill); + vec_free(starkill); + vec_free(vptrkill); + util_free(expnod); + util_free(expblk); + util_free(defnod); +} + +#if DEBUG + // to print progress message and current trees set to + // DEBUG_TREES to 1 and uncomment next 2 lines +#define DEBUG_TREES 0 +#if DEBUG_TREES +void dbg_optprint(char *); +#else + // to print progress message, undo comment +#define dbg_optprint(c) // dbg_printf(c) +#endif +#else +#define dbg_optprint(c) +#endif + +/************************************** + * Parse optimizer command line flag. + * Input: + * cp flag string + * Returns: + * 0 not recognized + * !=0 recognized + */ + +int go_flag(char *cp) +{ unsigned i; + unsigned flag; + + enum GL // indices of various flags in flagtab[] + { + GLO,GLall,GLcnp,GLcp,GLcse,GLda,GLdc,GLdv,GLli,GLliv,GLlocal,GLloop, + GLnone,GLo,GLreg,GLspace,GLspeed,GLtime,GLtree,GLvbe,GLMAX + }; + static const char *flagtab[] = + { "O","all","cnp","cp","cse","da","dc","dv","li","liv","local","loop", + "none","o","reg","space","speed","time","tree","vbe" + }; + static mftype flagmftab[] = + { 0,MFall,MFcnp,MFcp,MFcse,MFda,MFdc,MFdv,MFli,MFliv,MFlocal,MFloop, + 0,0,MFreg,0,MFtime,MFtime,MFtree,MFvbe + }; + + i = GLMAX; + assert(i == arraysize(flagtab)); + assert(i == arraysize(flagmftab)); + + //printf("go_flag('%s')\n", cp); + flag = binary(cp + 1,flagtab,GLMAX); + if (mfoptim == 0 && flag != -1) + mfoptim = MFall & ~MFvbe; + + if (*cp == '-') /* a regular -whatever flag */ + { /* cp -> flag string */ + switch (flag) + { + case GLall: + case GLcnp: + case GLcp: + case GLdc: + case GLda: + case GLdv: + case GLcse: + case GLli: + case GLliv: + case GLlocal: + case GLloop: + case GLreg: + case GLspeed: + case GLtime: + case GLtree: + case GLvbe: + mfoptim &= ~flagmftab[flag]; /* clear bits */ + break; + case GLo: + case GLO: + case GLnone: + mfoptim |= MFall & ~MFvbe; // inverse of -all + break; + case GLspace: + mfoptim |= MFtime; /* inverse of -time */ + break; + case -1: /* not in flagtab[] */ + goto badflag; + default: + assert(0); + } + } + else if (*cp == '+') /* a regular +whatever flag */ + { /* cp -> flag string */ + switch (flag) + { + case GLall: + case GLcnp: + case GLcp: + case GLdc: + case GLda: + case GLdv: + case GLcse: + case GLli: + case GLliv: + case GLlocal: + case GLloop: + case GLreg: + case GLspeed: + case GLtime: + case GLtree: + case GLvbe: + mfoptim |= flagmftab[flag]; /* set bits */ + break; + case GLnone: + mfoptim &= ~MFall; /* inverse of +all */ + break; + case GLspace: + mfoptim &= ~MFtime; /* inverse of +time */ + break; + case -1: /* not in flagtab[] */ + goto badflag; + default: + assert(0); + } + } + if (mfoptim) + { + mfoptim |= MFtree | MFdc; // always do at least this much + config.flags4 |= (mfoptim & MFtime) ? CFG4speed : CFG4space; + } + else + { + config.flags4 &= ~CFG4optimized; + } + return 1; // recognized + +badflag: + return 0; +} + +#if DEBUG_TREES +void dbg_optprint(char *title) +{ + block *b; + for (b = startblock; b; b = b->Bnext) + if (b->Belem) + { + dbg_printf("%s\n",title); + elem_print(b->Belem); + } +} +#endif + +/**************************** + * Optimize function. + */ + +void optfunc() +{ +#if !HTOD + block *b; + int iter; // iteration count + clock_t starttime; + + cmes ("optfunc()\n"); + dbg_optprint("optfunc\n"); +#ifdef DEBUG + if (debugb) + { + dbg_printf("................Before optimization.........\n"); + WRfunc(); + } +#endif + iter = 0; + + if (localgot) + { // Initialize with: + // localgot = OPgot; + elem *e = el_long(TYnptr, 0); + e->Eoper = OPgot; + e = el_bin(OPeq, TYnptr, el_var(localgot), e); + startblock->Belem = el_combine(e, startblock->Belem); + } + + // Each pass through the loop can reduce only one level of comma expression. + // The infinite loop check needs to take this into account. + int iterationLimit = 0; + for (b = startblock; b; b = b->Bnext) + { + if (!b->Belem) + continue; + int d = el_countCommas(b->Belem); + if (d > iterationLimit) + iterationLimit = d; + } + + // Some functions can take enormous amounts of time to optimize. + // We try to put a lid on it. + starttime = clock(); + do + { + //printf("iter = %d\n", iter); + if (++iter > 200) + { assert(iter < iterationLimit); // infinite loop check + break; + } +#if MARS + util_progress(); +#else + file_progress(); +#endif + + //printf("optelem\n"); + /* canonicalize the trees */ + for (b = startblock; b; b = b->Bnext) + if (b->Belem) + { +#if DEBUG + if(debuge) + { + dbg_printf("before\n"); + elem_print(b->Belem); + //el_check(b->Belem); + } +#endif + b->Belem = doptelem(b->Belem,bc_goal[b->BC] | GOALagain); +#if DEBUG + if(0 && debugf) + { + dbg_printf("after\n"); + elem_print(b->Belem); + } +#endif + } + //printf("blockopt\n"); + if (mfoptim & MFdc) + blockopt(0); // do block optimization + out_regcand(&globsym); // recompute register candidates + changes = 0; /* no changes yet */ + if (mfoptim & MFcnp) + constprop(); /* make relationals unsigned */ + if (mfoptim & (MFli | MFliv)) + loopopt(); /* remove loop invariants and */ + /* induction vars */ + /* do loop rotation */ + else + for (b = startblock; b; b = b->Bnext) + b->Bweight = 1; + dbg_optprint("boolopt\n"); + + if (mfoptim & MFcnp) + boolopt(); // optimize boolean values + if (changes && mfoptim & MFloop && (clock() - starttime) < 30 * CLOCKS_PER_SEC) + continue; + + if (mfoptim & MFcnp) + constprop(); /* constant propagation */ + if (mfoptim & MFcp) + copyprop(); /* do copy propagation */ + + /* Floating point constants and string literals need to be + * replaced with loads from variables in read-only data. + * This can result in localgot getting needed. + */ + symbol *localgotsave = localgot; + for (b = startblock; b; b = b->Bnext) + { + if (b->Belem) + { + b->Belem = doptelem(b->Belem,bc_goal[b->BC] | GOALstruct); + if (b->Belem) + b->Belem = el_convert(b->Belem); + } + } + if (localgot != localgotsave) + { /* Looks like we did need localgot, initialize with: + * localgot = OPgot; + */ + elem *e = el_long(TYnptr, 0); + e->Eoper = OPgot; + e = el_bin(OPeq, TYnptr, el_var(localgot), e); + startblock->Belem = el_combine(e, startblock->Belem); + } + + /* localize() is after localgot, otherwise we wind up with + * more than one OPgot in a function, which mucks up OSX + * code generation which assumes at most one (localgotoffset). + */ + if (mfoptim & MFlocal) + localize(); // improve expression locality + if (mfoptim & MFda) + rmdeadass(); /* remove dead assignments */ + + cmes2 ("changes = %d\n", changes); + if (!(changes && mfoptim & MFloop && (clock() - starttime) < 30 * CLOCKS_PER_SEC)) + break; + } while (1); + cmes2("%d iterations\n",iter); + if (mfoptim & MFdc) + blockopt(1); // do block optimization + + for (b = startblock; b; b = b->Bnext) + { + if (b->Belem) + postoptelem(b->Belem); + } + if (mfoptim & MFvbe) + verybusyexp(); /* very busy expressions */ + if (mfoptim & MFcse) + builddags(); /* common subexpressions */ + if (mfoptim & MFdv) + deadvar(); /* eliminate dead variables */ + +#ifdef DEBUG + if (debugb) + { + dbg_printf(".............After optimization...........\n"); + WRfunc(); + } +#endif + + // Prepare for code generator + for (b = startblock; b; b = b->Bnext) + { + block_optimizer_free(b); + } +#endif +} + +#endif // !SPP diff --git a/backend/go.h b/backend/go.h new file mode 100644 index 00000000..e483b3b0 --- /dev/null +++ b/backend/go.h @@ -0,0 +1,98 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if __SC__ +#pragma once +#endif + +#ifndef GO_H +#define GO_H 1 + +/*************************************** + * Bit masks for various optimizations. + */ + +typedef unsigned mftype; /* a type big enough for all the flags */ + +#define MFdc 1 // dead code +#define MFda 2 // dead assignments +#define MFdv 4 // dead variables +#define MFreg 8 // register variables +#define MFcse 0x10 // global common subexpressions +#define MFvbe 0x20 // very busy expressions +#define MFtime 0x40 // favor time (speed) over space +#define MFli 0x80 // loop invariants +#define MFliv 0x100 // loop induction variables +#define MFcp 0x200 // copy propagation +#define MFcnp 0x400 // constant propagation +#define MFloop 0x800 // loop till no more changes +#define MFtree 0x1000 // optelem (tree optimization) +#define MFlocal 0x2000 // localize expressions +#define MFall (~0) // do everything + +/********************************** + * Definition elem vector, used for reaching definitions. + */ + +typedef struct DN + { + elem *DNelem; // pointer to definition elem + block *DNblock; // pointer to block that the elem is in + } dn; + +/* Global Variables */ +extern unsigned optab[]; +extern mftype mfoptim; +extern unsigned changes; /* # of optimizations performed */ +extern struct DN *defnod; /* array of definition elems */ +extern unsigned deftop; /* # of entries in defnod[] */ +extern elem **expnod; /* array of expression elems */ +extern unsigned exptop; /* top of expnod[] */ +extern block **expblk; /* parallel array of block pointers */ +extern vec_t defkill; /* vector of AEs killed by an ambiguous */ + /* definition */ +extern vec_t starkill; /* vector of AEs killed by a definition */ + /* of something that somebody could be */ + /* pointing to */ +extern vec_t vptrkill; /* vector of AEs killed by an access */ + +/* gdag.c */ +void builddags(void); +void boolopt(void); +void opt_arraybounds(); + +/* gflow.c */ +void flowrd(),flowlv(),flowae(),flowvbe(), + flowcp(),flowae(),genkillae(),flowarraybounds(); +int ae_field_affect(elem *lvalue,elem *e); + +/* glocal.c */ +void localize(void); + +/* gloop.c */ +int blockinit(void); +void compdom(void); +void loopopt(void); +void updaterd(elem *n,vec_t GEN,vec_t KILL); + +/* gother.c */ +void rd_arraybounds(void); +void rd_free(); +void constprop(void); +void copyprop(void); +void rmdeadass(void); +void elimass(elem *); +void deadvar(void); +void verybusyexp(void); +list_t listrds(vec_t, elem *, vec_t); + +#endif /* GO_H */ diff --git a/backend/gother.c b/backend/gother.c new file mode 100644 index 00000000..b0f36925 --- /dev/null +++ b/backend/gother.c @@ -0,0 +1,1781 @@ +// Copyright (C) 1986-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if (SCPP || MARS) && !HTOD + +#include +#include + +#include "cc.h" +#include "global.h" +#include "el.h" +#include "go.h" +#include "oper.h" +#include "list.h" +#include "type.h" + +#if SCPP +#include "parser.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +extern void error(const char *filename, unsigned linnum, const char *format, ...); + +STATIC void rd_free_elem(elem *e); +STATIC void rd_compute(); +STATIC void conpropwalk(elem *n , vec_t IN); +STATIC void chkrd(elem *n , list_t rdlist); +STATIC elem * chkprop(elem *n , list_t rdlist); +STATIC void arrayboundsrds(void); +STATIC void eqeqranges(void); +STATIC void intranges(void); +STATIC int loopcheck(block *start , block *inc , block *rel); +STATIC void cpwalk(elem *n , vec_t IN); +STATIC unsigned numasg(elem *e); +STATIC void accumda(elem *n , vec_t DEAD , vec_t POSS); +STATIC void dvwalk(elem *n , unsigned i); +STATIC int killed(unsigned j , block *bp , block *b); +STATIC int ispath(unsigned j , block *bp , block *b); + +/**********************************************************************/ + +// Lists to help identify ranges of variables +struct Elemdata +{ Elemdata *next; // linked list + elem *pelem; // the elem in question + block *pblock; // which block it's in + list_t rdlist; // list of definition elems for *pelem + + static Elemdata *ctor(elem *e,block *b,list_t rd); +}; + +Elemdata *Elemdata::ctor(elem *e,block *b,list_t rd) +{ Elemdata *ed; + + ed = (Elemdata *) MEM_BEF_CALLOC(sizeof(Elemdata)); + ed->pelem = e; + ed->pblock = b; + ed->rdlist = rd; + return ed; +} + + +/***************** + * Free list of Elemdata's. + */ + +STATIC void elemdatafree(Elemdata **plist) +{ Elemdata *el; + Elemdata *eln; + + for (el = *plist; el; el = eln) + { eln = el->next; + list_free(&el->rdlist); + MEM_BEF_FREE(el); + } + *plist = NULL; +} + +static Elemdata *arraylist = NULL; // list of Elemdata's of OParray elems +static Elemdata *eqeqlist = NULL; // list of Elemdata's of OPeqeq & OPne elems +static Elemdata *rellist = NULL; // list of Elemdata's of relop elems +static Elemdata *inclist = NULL; // list of Elemdata's of increment elems + +enum Rdtype { RDarraybounds, RDconstprop }; +static Rdtype rdtype; + +/*************************** Constant Propagation ***************************/ + + +/************************** + * Constant propagation. + * Also detects use of variable before any possible def. + */ + +void constprop() +{ + rdtype = RDconstprop; + rd_compute(); + intranges(); // compute integer ranges +#if 0 + eqeqranges(); // see if we can eliminate some relationals +#endif + elemdatafree(&eqeqlist); + elemdatafree(&rellist); + elemdatafree(&inclist); +} + +/************************************ + * Compute reaching definitions. + * Note: RD vectors are destroyed by this. + */ + +static block *thisblock; + +STATIC void rd_compute() +{ register unsigned i; + + cmes("constprop()\n"); + assert(dfo); + flowrd(); /* compute reaching definitions (rd) */ + if (deftop == 0) /* if no reaching defs */ + return; + assert(rellist == NULL && inclist == NULL && eqeqlist == NULL && arraylist == NULL); + block_clearvisit(); + for (i = 0; i < dfotop; i++) /* for each block */ + { block *b = dfo[i]; + + switch (b->BC) + { +#if MARS + case BCjcatch: +#endif + case BC_finally: + case BCasm: + case BCcatch: + block_visit(b); + break; + } + } + + for (i = 0; i < dfotop; i++) /* for each block */ + { register block *b; + + b = dfo[i]; + thisblock = b; +#if 0 + dbg_printf("block %d Bin ",i); vec_println(b->Binrd); + dbg_printf(" Bout "); vec_println(b->Boutrd); +#endif + if (b->Bflags & BFLvisited) + continue; // not reliable for this block + if (b->Belem) + { + conpropwalk(b->Belem,b->Binrd); +#ifdef DEBUG + if (!(vec_equal(b->Binrd,b->Boutrd))) + { int j; + + dbg_printf("block %d Binrd ",i); vec_println(b->Binrd); + dbg_printf(" Boutrd "); vec_println(b->Boutrd); + WReqn(b->Belem); + dbg_printf("\n"); + vec_xorass(b->Binrd,b->Boutrd); + j = vec_index(0,b->Binrd); + WReqn(defnod[j].DNelem); + dbg_printf("\n"); + } +#endif + assert(vec_equal(b->Binrd,b->Boutrd)); + } + } +} + +/*************************** + * Support routine for constprop(). + * Visit each elem in order + * If elem is a reference to a variable, and + * all the reaching defs of that variable are + * defining it to be a specific constant, + * Replace reference with that constant. + * Generate warning if no reaching defs for a + * variable, and the variable is on the stack + * or in a register. + * If elem is an assignment or function call or OPasm + * Modify vector of reaching defs. + */ + +STATIC void conpropwalk(elem *n,vec_t IN) +{ register unsigned op; + Elemdata *pdata; + vec_t L,R; + elem *t; + + assert(n && IN); + /*chkvecdim(deftop,0);*/ + //printf("conpropwalk()\n"),elem_print(n); + op = n->Eoper; + if (op == OPcolon || op == OPcolon2) + { L = vec_clone(IN); + conpropwalk(n->E1,L); + conpropwalk(n->E2,IN); + vec_orass(IN,L); /* IN = L | R */ + vec_free(L); + } + else if (op == OPandand || op == OPoror) + { conpropwalk(n->E1,IN); + R = vec_clone(IN); + conpropwalk(n->E2,R); + vec_orass(IN,R); /* IN |= R */ + vec_free(R); + } + else if (OTunary(op)) + goto L3; + else if (ERTOL(n)) + { conpropwalk(n->E2,IN); + L3: + t = n->E1; + if (OTassign(op)) + { + if (t->Eoper == OPvar) + { + // Note that the following ignores OPnegass + if (rdtype == RDconstprop && + OTopeq(op) && sytab[t->EV.sp.Vsym->Sclass] & SCRD) + { elem *e; + list_t rdl; + + rdl = listrds(IN,t,NULL); + if (!(config.flags & CFGnowarning)) // if warnings are enabled + chkrd(t,rdl); + e = chkprop(t,rdl); + if (e) + { // Replace (t op= exp) with (t = e op exp) + + e = el_copytree(e); + e->Ety = t->Ety; + n->E2 = el_bin(opeqtoop(op),n->Ety,e,n->E2); + n->Eoper = OPeq; + } + list_free(&rdl); + } + } + else + conpropwalk(t,IN); + } + else + conpropwalk(t,IN); + } + else if (OTbinary(op)) + { + if (OTassign(op)) + { t = Elvalue(n); + if (t->Eoper != OPvar) + conpropwalk(t,IN); + } + else + conpropwalk(n->E1,IN); + conpropwalk(n->E2,IN); + } + + // Collect data for subsequent optimizations + if (OTbinary(op) && n->E1->Eoper == OPvar && n->E2->Eoper == OPconst) + { + switch (op) + { + case OPlt: + case OPgt: + case OPle: + case OPge: + // Collect compare elems and their rd's in the rellist list + if (rdtype == RDconstprop && + tyintegral(n->E1->Ety) && + tyintegral(n->E2->Ety) + ) + { + //dbg_printf("appending to rellist\n"); elem_print(n); + pdata = Elemdata::ctor(n,thisblock,listrds(IN,n->E1,NULL)); + pdata->next = rellist; + rellist = pdata; + } + break; + + case OPaddass: + case OPminass: + case OPpostinc: + case OPpostdec: + // Collect increment elems and their rd's in the inclist list + if (rdtype == RDconstprop && + tyintegral(n->E1->Ety)) + { + //dbg_printf("appending to inclist\n"); elem_print(n); + pdata = Elemdata::ctor(n,thisblock,listrds(IN,n->E1,NULL)); + pdata->next = inclist; + inclist = pdata; + } + break; + + case OPne: + case OPeqeq: + // Collect compare elems and their rd's in the rellist list + if (rdtype == RDconstprop && + tyintegral(n->E1->Ety)) + { //dbg_printf("appending to eqeqlist\n"); elem_print(n); + pdata = Elemdata::ctor(n,thisblock,listrds(IN,n->E1,NULL)); + pdata->next = eqeqlist; + eqeqlist = pdata; + } + break; + } + } + + + if (OTdef(op)) /* if definition elem */ + updaterd(n,IN,NULL); /* then update IN vector */ + + /* now we get to the part that checks to see if we can */ + /* propagate a constant. */ + if (op == OPvar && sytab[n->EV.sp.Vsym->Sclass] & SCRD) + { list_t rdl; + + //printf("const prop: %s\n", n->EV.sp.Vsym->Sident); + rdl = listrds(IN,n,NULL); + if (rdtype == RDconstprop) + { elem *e; + + if (!(config.flags & CFGnowarning)) // if warnings are enabled + chkrd(n,rdl); + e = chkprop(n,rdl); + if (e) + { tym_t nty; + + nty = n->Ety; + el_copy(n,e); + n->Ety = nty; // retain original type + } + list_free(&rdl); + } + } +} + +/****************************** + * Give error if there are no reaching defs for variable v. + */ + +STATIC void chkrd(elem *n,list_t rdlist) +{ unsigned i; + symbol *sv; + int unambig; + + sv = n->EV.sp.Vsym; + assert(sytab[sv->Sclass] & SCRD); + if (sv->Sflags & SFLnord) // if already printed a warning + return; + if (sv->ty() & mTYvolatile) + return; + unambig = sv->Sflags & SFLunambig; + for (list_t l = rdlist; l; l = list_next(l)) + { elem *d = (elem *) list_ptr(l); + + elem_debug(d); + if (d->Eoper == OPasm) /* OPasm elems ruin everything */ + return; + if (OTassign(d->Eoper)) + { + if (d->E1->Eoper == OPvar) + { if (d->E1->EV.sp.Vsym == sv) + return; + } + else if (!unambig) + return; + } + else + { if (!unambig) + return; + } + } + + // If there are any asm blocks, don't print the message + for (i = 0; i < dfotop; i++) + if (dfo[i]->BC == BCasm) + return; + + // If variable contains bit fields, don't print message (because if + // bit field is the first set, then we get a spurious warning). + // STL uses 0 sized structs to transmit type information, so + // don't complain about them being used before set. + if (type_struct(sv->Stype)) + { + if (sv->Stype->Ttag->Sstruct->Sflags & (STRbitfields | STR0size)) + return; + } +#if SCPP + { Outbuffer buf; + char *p2; + + type_tostring(&buf, sv->Stype); + buf.writeByte(' '); + buf.write(sv->Sident); + p2 = buf.toString(); + warerr(WM_used_b4_set, p2); // variable used before set + } +#endif +#if 1 && MARS + /* Watch out for: + void test() + { + void[0] x; + auto y = x; + } + */ + error(n->Esrcpos.Sfilename, n->Esrcpos.Slinnum, "variable %s used before set", sv->Sident); +#endif + + sv->Sflags |= SFLnord; // no redundant messages +#ifdef DEBUG + //elem_print(n); +#endif +} + +/********************************** + * Look through the vector of reaching defs (IN) to see + * if all defs of n are of the same constant. If so, replace + * n with that constant. + * Bit fields are gross, so don't propagate anything with assignments + * to a bit field. + * Note the flaw in the reaching def vector. There is currently no way + * to detect RDs from when the function is invoked, i.e. RDs for parameters, + * statics and globals. This could be fixed by adding dummy defs for + * them before startblock, but we just kludge it and don't propagate + * stuff for them. + * Returns: + * NULL do not propagate constant + * e constant elem that we should replace n with + */ + +STATIC elem * chkprop(elem *n,list_t rdlist) +{ + elem *foundelem = NULL; + int unambig; + symbol *sv; + tym_t nty; + unsigned nsize; + targ_size_t noff; + list_t l; + + //printf("checkprop: "); WReqn(n); printf("\n"); + assert(n && n->Eoper == OPvar); + elem_debug(n); + sv = n->EV.sp.Vsym; + assert(sytab[sv->Sclass] & SCRD); + nty = n->Ety; + if (!tyscalar(nty)) + goto noprop; + nsize = size(nty); + noff = n->EV.sp.Voffset; + unambig = sv->Sflags & SFLunambig; + for (l = rdlist; l; l = list_next(l)) + { elem *d = (elem *) list_ptr(l); + + elem_debug(d); + + //printf("\trd: "); WReqn(d); printf("\n"); + if (d->Eoper == OPasm) /* OPasm elems ruin everything */ + goto noprop; +#if 0 + // Runs afoul of Buzilla 4506 + if (OTassign(d->Eoper) && EBIN(d)) // if assignment elem +#else + if (OTassign(d->Eoper)) // if assignment elem +#endif + { elem *t = Elvalue(d); + + if (t->Eoper == OPvar) + { assert(t->EV.sp.Vsym == sv); + + if (d->Eoper == OPstreq || + !tyscalar(t->Ety)) + goto noprop; // not worth bothering with these cases + + if (d->Eoper == OPnegass) + goto noprop; // don't bother with this case, either + + /* Everything must match or we must skip this variable */ + /* (in case of assigning to overlapping unions, etc.) */ + if (t->EV.sp.Voffset != noff || + /* If sizes match, we are ok */ + size(t->Ety) != nsize && + !(d->E2->Eoper == OPconst && size(t->Ety) > nsize && !tyfloating(d->E2->Ety))) + goto noprop; + } + else + { if (unambig) /* unambiguous assignments only */ + continue; + goto noprop; + } + if (d->Eoper != OPeq) + goto noprop; + } + else /* must be a call elem */ + { + if (unambig) + continue; + else + goto noprop; /* could be affected */ + } + + if (d->E2->Eoper == OPconst || d->E2->Eoper == OPrelconst) + { + if (foundelem) /* already found one */ + { /* then they must be the same */ + if (!el_match(foundelem,d->E2)) + goto noprop; + } + else /* else this is it */ + foundelem = d->E2; + } + else + goto noprop; + } + + if (foundelem) /* if we got one */ + { /* replace n with foundelem */ +#ifdef DEBUG + if (debugc) + { dbg_printf("const prop ("); + WReqn(n); + dbg_printf(" replaced by "); + WReqn(foundelem); + dbg_printf("), %p to %p\n",foundelem,n); + } +#endif + changes++; + return foundelem; + } +noprop: + return NULL; +} + +/*********************************** + * Find all the reaching defs of OPvar e. + * Put into a linked list, or just set the RD bits in a vector. + * + */ + +list_t listrds(vec_t IN,elem *e,vec_t f) +{ list_t rdlist; + unsigned i; + unsigned unambig; + Symbol *s; + unsigned nsize; + targ_size_t noff; + tym_t ty; + + //printf("listrds: "); WReqn(e); printf("\n"); + assert(IN); + rdlist = NULL; + assert(e->Eoper == OPvar); + s = e->EV.sp.Vsym; + ty = e->Ety; + if (tyscalar(ty)) + nsize = size(ty); + noff = e->EV.sp.Voffset; + unambig = s->Sflags & SFLunambig; + if (f) + vec_clear(f); + foreach (i, deftop, IN) + { elem *d; + unsigned op; + + d = defnod[i].DNelem; + //dbg_printf("\tlooking at "); WReqn(d); dbg_printf("\n"); + op = d->Eoper; + if (op == OPasm) // assume ASM elems define everything + goto listit; + if (OTassign(op)) + { elem *t = Elvalue(d); + + if (t->Eoper == OPvar && t->EV.sp.Vsym == s) + { if (op == OPstreq) + goto listit; + if (!tyscalar(ty) || !tyscalar(t->Ety)) + goto listit; + // If t does not overlap e, then it doesn't affect things + if (noff + nsize > t->EV.sp.Voffset && + t->EV.sp.Voffset + size(t->Ety) > noff) + goto listit; // it's an assignment to s + } + else if (t->Eoper != OPvar && !unambig) + goto listit; /* assignment through pointer */ + } + else if (!unambig) + goto listit; /* probably a function call */ + continue; + + listit: + //dbg_printf("\tlisting "); WReqn(d); dbg_printf("\n"); + if (f) + vec_setbit(i,f); + else + list_append(&rdlist,d); // add the definition node + } + return rdlist; +} + +/******************************************** + * Look at reaching defs for expressions of the form (v == c) and (v != c). + * If all definitions of v are c or are not c, then we can replace the + * expression with 1 or 0. + */ + +STATIC void eqeqranges() +{ Elemdata *rel; + list_t rdl; + Symbol *v; + int sz; + elem *e; + targ_llong c; + int result; + + for (rel = eqeqlist; rel; rel = rel->next) + { + e = rel->pelem; + v = e->E1->EV.sp.Vsym; + if (!(sytab[v->Sclass] & SCRD)) + continue; + sz = tysize(e->E1->Ety); + c = el_tolong(e->E2); + + result = -1; // result not known yet + for (rdl = rel->rdlist; rdl; rdl = list_next(rdl)) + { elem *erd = (elem *) list_ptr(rdl); + elem *erd1; + int szrd; + int tmp; + + elem_debug(erd); + if (erd->Eoper != OPeq || + (erd1 = erd->E1)->Eoper != OPvar || + erd->E2->Eoper != OPconst + ) + goto L1; + szrd = tysize(erd1->Ety); + if (erd1->EV.sp.Voffset + szrd <= e->E1->EV.sp.Voffset || + e->E1->EV.sp.Voffset + sz <= erd1->EV.sp.Voffset) + continue; // doesn't affect us, skip it + if (szrd != sz || e->E1->EV.sp.Voffset != erd1->EV.sp.Voffset) + goto L1; // overlapping - forget it + + tmp = (c == el_tolong(erd->E2)); + if (result == -1) + result = tmp; + else if (result != tmp) + goto L1; + } + if (result >= 0) + { + //printf("replacing with %d\n",result); + el_free(e->E1); + el_free(e->E2); + e->EV.Vint = (e->Eoper == OPeqeq) ? result : result ^ 1; + e->Eoper = OPconst; + } + L1: ; + } +} + +/****************************** + * Examine rellist and inclist to determine if any of the signed compare + * elems in rellist can be replace by unsigned compares. + * rellist is list of relationals in function. + * inclist is list of increment elems in function. + */ + +STATIC void intranges() +{ Elemdata *rel,*iel; + block *rb,*ib; + symbol *v; + elem *rdeq,*rdinc; + unsigned incop,relatop; + targ_int initial,increment,final; + + cmes("intranges()\n"); + for (rel = rellist; rel; rel = rel->next) + { + rb = rel->pblock; + //dbg_printf("rel->pelem: "); WReqn(rel->pelem); dbg_printf("\n"); + assert(rel->pelem->E1->Eoper == OPvar); + v = rel->pelem->E1->EV.sp.Vsym; + + // RD info is only reliable for registers and autos + if (!(sytab[v->Sclass] & SCRD)) + continue; + + /* Look for two rd's: an = and an increment */ + if (list_nitems(rel->rdlist) != 2) + continue; + rdeq = list_elem(list_next(rel->rdlist)); + if (rdeq->Eoper != OPeq) + { rdinc = rdeq; + rdeq = list_elem(rel->rdlist); + if (rdeq->Eoper != OPeq) + continue; + } + else + rdinc = list_elem(rel->rdlist); +#if 0 + printf("\neq: "); WReqn(rdeq); printf("\n"); + printf("rel: "); WReqn(rel->pelem); printf("\n"); + printf("inc: "); WReqn(rdinc); printf("\n"); +#endif + incop = rdinc->Eoper; + if (!OTpost(incop) && incop != OPaddass && incop != OPminass) + continue; + + /* lvalues should be unambiguous defs */ + if (rdeq->E1->Eoper != OPvar || rdinc->E1->Eoper != OPvar) + continue; + /* rvalues should be constants */ + if (rdeq->E2->Eoper != OPconst || rdinc->E2->Eoper != OPconst) + continue; + + /* Ensure that the only defs reaching the increment elem (rdinc) */ + /* are rdeq and rdinc. */ + for (iel = inclist; TRUE; iel = iel->next) + { elem *rd1,*rd2; + + if (!iel) + goto nextrel; + ib = iel->pblock; + if (iel->pelem != rdinc) + continue; /* not our increment elem */ + if (list_nitems(iel->rdlist) != 2) + { //printf("!= 2\n"); + goto nextrel; + } + rd1 = list_elem(iel->rdlist); + rd2 = list_elem(list_next(iel->rdlist)); + /* The rd's for the relational elem (rdeq,rdinc) must be */ + /* the same as the rd's for tne increment elem (rd1,rd2). */ + if (rd1 == rdeq && rd2 == rdinc || rd1 == rdinc && rd2 == rdeq) + break; + } + + // Check that all paths from rdinc to rdinc must pass through rdrel + { int i; + + // ib: block of increment + // rb: block of relational + i = loopcheck(ib,ib,rb); + block_clearvisit(); + if (i) + continue; + } + + /* Gather initial, increment, and final values for loop */ + initial = el_tolong(rdeq->E2); + increment = el_tolong(rdinc->E2); + if (incop == OPpostdec || incop == OPminass) + increment = -increment; + relatop = rel->pelem->Eoper; + final = el_tolong(rel->pelem->E2); +// dbg_printf("initial = %d, increment = %d, final = %d\n", +// initial,increment,final); + + /* Determine if we can make the relational an unsigned */ + if (initial >= 0) + { if (final >= initial) + { if (increment > 0 && ((final - initial) % increment) == 0) + goto makeuns; + } + else if (final >= 0) + { /* 0 <= final < initial */ + if (increment < 0 && ((final - initial) % increment) == 0 && + !(final + increment < 0 && + (relatop == OPge || relatop == OPlt) + ) + ) + { + makeuns: + if (!tyuns(rel->pelem->E2->Ety)) + { + rel->pelem->E2->Ety = touns(rel->pelem->E2->Ety); + rel->pelem->Nflags |= NFLtouns; +#ifdef DEBUG + if (debugc) + { WReqn(rel->pelem); + dbg_printf(" made unsigned, initial = %ld, increment = %ld,\ + final = %ld\n",(long int)initial,(long int)increment,(long int)final); + } +#endif + changes++; + } +#if 0 + // Eliminate loop if it is empty + if (relatop == OPlt && + rb->BC == BCiftrue && + list_block(rb->Bsucc) == rb && + rb->Belem->Eoper == OPcomma && + rb->Belem->E1 == rdinc && + rb->Belem->E2 == rel->pelem + ) + { + rel->pelem->Eoper = OPeq; + rel->pelem->Ety = rel->pelem->E1->Ety; + rb->BC = BCgoto; + list_subtract(&rb->Bsucc,rb); + list_subtract(&rb->Bpred,rb); +#ifdef DEBUG + if (debugc) + { WReqn(rel->pelem); + dbg_printf(" eliminated loop\n"); + } +#endif + changes++; + } +#endif + } + } + } + + nextrel: + ; + } +} + +/*********************** + * Return TRUE if there is a path from start to inc without + * passing through rel. + */ + +STATIC int loopcheck(block *start,block *inc,block *rel) +{ list_t list; + block *b; + +#if __ZTC__ + _chkstack(); /* always check stack on recursive routines */ +#endif + if (!(start->Bflags & BFLvisited)) + { start->Bflags |= BFLvisited; /* guarantee eventual termination */ + for (list = start->Bsucc; list; list = list_next(list)) + { b = (block *) list_ptr(list); + if (b != rel && (b == inc || loopcheck(b,inc,rel))) + return TRUE; + } + } + return FALSE; +} + +/**************************** + * Do copy propagation. + * Copy propagation elems are of the form OPvar=OPvar, and they are + * in expnod[]. + */ + +static int recalc; + +void copyprop() +{ register unsigned i; + + out_regcand(&globsym); + cmes("copyprop()\n"); + assert(dfo); +Lagain: + flowcp(); /* compute available copy statements */ + if (exptop <= 1) + return; /* none available */ +#if 0 + for (i = 1; i < exptop; i++) + { dbg_printf("expnod[%d] = (",i); + WReqn(expnod[i]); + dbg_printf(");\n"); + } +#endif + recalc = 0; + for (i = 0; i < dfotop; i++) /* for each block */ + { register block *b; + + b = dfo[i]; + if (b->Belem) + { +#if 0 + dbg_printf("B%d, elem (",i); + WReqn(b->Belem); dbg_printf(")\nBin "); + vec_println(b->Bin); + cpwalk(b->Belem,b->Bin); + dbg_printf("Bino "); + vec_println(b->Bin); + dbg_printf("Bout "); + vec_println(b->Bout); +#else + cpwalk(b->Belem,b->Bin); +#endif + /*assert(vec_equal(b->Bin,b->Bout)); */ + /* The previous assert() is correct except */ + /* for the following case: */ + /* a=b; d=a; a=b; */ + /* The vectors don't match because the */ + /* equations changed to: */ + /* a=b; d=b; a=b; */ + /* and the d=b copy elem now reaches the end */ + /* of the block (the d=a elem didn't). */ + } + if (recalc) + goto Lagain; + } +} + +/***************************** + * Walk tree n, doing copy propagation as we go. + * Keep IN up to date. + */ + +STATIC void cpwalk(register elem *n,vec_t IN) +{ register unsigned op,i; + register elem *t; + vec_t L; + + static int nocp; + + assert(n && IN); + /*chkvecdim(exptop,0);*/ + if (recalc) + return; + op = n->Eoper; + if (op == OPcolon || op == OPcolon2) + { + L = vec_clone(IN); + cpwalk(n->E1,L); + cpwalk(n->E2,IN); + vec_andass(IN,L); // IN = L & R + vec_free(L); + } + else if (op == OPandand || op == OPoror) + { cpwalk(n->E1,IN); + L = vec_clone(IN); + cpwalk(n->E2,L); + vec_andass(IN,L); // IN = L & R + vec_free(L); + } + else if (OTunary(op)) + { + t = n->E1; + if (OTassign(op)) + { if (t->Eoper == OPind) + cpwalk(t->E1,IN); + } + else if (op == OPctor || op == OPdtor) + { + /* This kludge is necessary because in except_pop() + * an el_match is done on the lvalue. If copy propagation + * changes the OPctor but not the corresponding OPdtor, + * then the match won't happen and except_pop() + * will fail. + */ + nocp++; + cpwalk(t,IN); + nocp--; + } + else + cpwalk(t,IN); + } + else if (OTassign(op)) + { cpwalk(n->E2,IN); + t = Elvalue(n); + if (t->Eoper == OPind) + cpwalk(t,IN); + else + { +#ifdef DEBUG + if (t->Eoper != OPvar) elem_print(n); +#endif + assert(t->Eoper == OPvar); + } + } + else if (ERTOL(n)) + { cpwalk(n->E2,IN); + cpwalk(n->E1,IN); + } + else if (OTbinary(op)) + { + cpwalk(n->E1,IN); + cpwalk(n->E2,IN); + } + + if (OTdef(op)) // if definition elem + { int ambig; /* TRUE if ambiguous def */ + + ambig = !OTassign(op) || t->Eoper == OPind; + foreach (i,exptop,IN) /* for each active copy elem */ + { symbol *v; + + if (op == OPasm) + goto clr; + + /* If this elem could kill the lvalue or the rvalue, */ + /* Clear bit in IN. */ + v = expnod[i]->E1->EV.sp.Vsym; + if (ambig) + { if (!(v->Sflags & SFLunambig)) + goto clr; + } + else + { if (v == t->EV.sp.Vsym) + goto clr; + } + v = expnod[i]->E2->EV.sp.Vsym; + if (ambig) + { if (!(v->Sflags & SFLunambig)) + goto clr; + } + else + { if (v == t->EV.sp.Vsym) + goto clr; + } + continue; + + clr: /* this copy elem is not available */ + vec_clearbit(i,IN); /* so remove it from the vector */ + } /* foreach */ + + /* If this is a copy elem in expnod[] */ + /* Set bit in IN. */ + if (op == OPeq && n->E1->Eoper == OPvar && + n->E2->Eoper == OPvar && n->Eexp) + vec_setbit(n->Eexp,IN); + } + else if (op == OPvar && !nocp) // if reference to variable v + { symbol *v = n->EV.sp.Vsym; + symbol *f; + elem *foundelem = NULL; + unsigned sz; + tym_t ty; + + //dbg_printf("Checking copyprop for '%s', ty=x%x\n",v->Sident,n->Ety); + symbol_debug(v); + ty = n->Ety; + sz = tysize(n->Ety); + foreach(i,exptop,IN) /* for all active copy elems */ + { elem *c; + + c = expnod[i]; + assert(c); + + //dbg_printf("looking at: ("); WReqn(c); dbg_printf("), ty=x%x\n",c->E1->Ety); + /* Not only must symbol numbers match, but */ + /* offsets too (in case of arrays) and sizes */ + /* (in case of unions). */ + if (v == c->E1->EV.sp.Vsym && + n->EV.sp.Voffset == c->E1->EV.sp.Voffset && + sz <= tysize(c->E1->Ety)) + { if (foundelem) + { if (c->E2->EV.sp.Vsym != f) + goto noprop; + } + else + { foundelem = c; + f = foundelem->E2->EV.sp.Vsym; + } + } + } + if (foundelem) /* if we can do the copy prop */ + { + cmes3("Copyprop, from '%s' to '%s'\n", + (v->Sident) ? (char *)v->Sident : "temp", + (f->Sident) ? (char *)f->Sident : "temp"); + el_copy(n,foundelem->E2); + n->Ety = ty; // retain original type + changes++; + + // Mark ones we can no longer use + foreach(i,exptop,IN) + { + if (f == expnod[i]->E2->EV.sp.Vsym) + { recalc++; + break; + } + } + } + //else dbg_printf("not found\n"); + noprop: + ; + } +} + +/******************************** + * Remove dead assignments. Those are assignments to a variable v + * for which there are no subsequent uses of v. + */ + +static unsigned asstop, /* # of assignment elems in assnod[] */ + assmax = 0, /* size of assnod[] */ + assnum; /* current position in assnod[] */ +static elem **assnod = NULL; /* array of pointers to asg elems */ +static vec_t ambigref; /* vector of assignment elems that */ + /* are referenced when an ambiguous */ + /* reference is done (as in *p or call) */ + +void rmdeadass() +{ register unsigned i,j; + vec_t DEAD,POSS; + + cmes("rmdeadass()\n"); + flowlv(); /* compute live variables */ + for (i = 0; i < dfotop; i++) /* for each block b */ + { register block *b = dfo[i]; + + if (!b->Belem) /* if no elems at all */ + continue; + if (b->Btry) // if in try-block guarded body + continue; + asstop = numasg(b->Belem); /* # of assignment elems */ + if (asstop == 0) /* if no assignment elems */ + continue; + if (asstop > assmax) /* if we need to reallocate */ + { assnod = (elem **) + util_realloc(assnod,sizeof(elem *),asstop); + assmax = asstop; + } + /*setvecdim(asstop);*/ + DEAD = vec_calloc(asstop); + POSS = vec_calloc(asstop); + ambigref = vec_calloc(asstop); + assnum = 0; + accumda(b->Belem,DEAD,POSS); /* compute DEAD and POSS */ + assert(assnum == asstop); + vec_free(ambigref); + vec_orass(POSS,DEAD); /* POSS |= DEAD */ + foreach (j,asstop,POSS) /* for each possible dead asg. */ + { symbol *v; /* v = target of assignment */ + register elem *n,*nv; + + n = assnod[j]; + nv = Elvalue(n); + v = nv->EV.sp.Vsym; + if (!symbol_isintab(v)) // not considered + continue; +//printf("assnod[%d]: ",j); WReqn(n); printf("\n"); +//printf("\tPOSS\n"); + /* If not positively dead but v is live on a */ + /* successor to b, then v is live. */ +//printf("\tDEAD=%d, live=%d\n",vec_testbit(j,DEAD),vec_testbit(v->Ssymnum,b->Boutlv)); + if (!vec_testbit(j,DEAD) && vec_testbit(v->Ssymnum,b->Boutlv)) + continue; + /* volatile variables are not dead */ + if ((v->ty() | nv->Ety) & mTYvolatile) + continue; +#ifdef DEBUG + if (debugc) + { dbg_printf("dead assignment ("); + WReqn(n); + if (vec_testbit(j,DEAD)) + dbg_printf(") DEAD\n"); + else + dbg_printf(") Boutlv\n"); + } +#endif + elimass(n); + changes++; + } /* foreach */ + vec_free(DEAD); + vec_free(POSS); + } /* for */ + util_free(assnod); + assnod = NULL; + assmax = 0; +} + +/*************************** + * Remove side effect of assignment elem. + */ + +void elimass(elem *n) +{ elem *e1; + + switch (n->Eoper) + { case OPeq: + case OPstreq: + /* (V=e) => (random constant,e) */ + /* Watch out for (a=b=c) stuff! */ + /* Don't screw up assnod[]. */ + n->Eoper = OPcomma; + n->Ety |= n->E2->Ety & (mTYconst | mTYvolatile | mTYimmutable | mTYshared +#if TARGET_SEGMENTED + | mTYfar +#endif + ); + n->E1->Eoper = OPconst; + break; + /* Convert (V op= e) to (V op e) */ + case OPaddass: + case OPminass: + case OPmulass: + case OPdivass: + case OPorass: + case OPandass: + case OPxorass: + case OPmodass: + case OPshlass: + case OPshrass: + case OPashrass: + n->Eoper = opeqtoop(n->Eoper); + break; + case OPpostinc: /* (V i++ c) => V */ + case OPpostdec: /* (V i-- c) => V */ + e1 = n->E1; + el_free(n->E2); + el_copy(n,e1); + el_free(e1); + break; + case OPnegass: + n->Eoper = OPneg; + break; + case OPbtc: + case OPbtr: + case OPbts: + n->Eoper = OPbt; + break; + default: + assert(0); + } +} + +/************************ + * Compute number of =,op=,i++,i--,--i,++i elems. + * (Unambiguous assignments only. Ambiguous ones would always be live.) + * Some compilers generate better code for ?: than if-then-else. + */ + +STATIC unsigned numasg(elem *e) +{ + assert(e); + if (OTassign(e->Eoper) && e->E1->Eoper == OPvar) + { e->Nflags |= NFLassign; + return 1 + numasg(e->E1) + (OTbinary(e->Eoper) ? numasg(e->E2) : 0); + } + e->Nflags &= ~NFLassign; + return OTunary(e->Eoper) ? numasg(e->E1) : + OTbinary(e->Eoper) ? numasg(e->E1) + numasg(e->E2) : 0; +} + +/****************************** + * Tree walk routine for rmdeadass(). + * DEAD = assignments which are dead + * POSS = assignments which are possibly dead + * The algorithm is basically: + * if we have an assignment to v, + * for all defs of v in POSS + * set corresponding bits in DEAD + * set bit for this def in POSS + * if we have a reference to v, + * clear all bits in POSS that are refs of v + */ + +STATIC void accumda(elem *n,vec_t DEAD, vec_t POSS) +{ vec_t Pl,Pr,Dl,Dr; + register unsigned i,op,vecdim; + + /*chkvecdim(asstop,0);*/ + assert(n && DEAD && POSS); + op = n->Eoper; + switch (op) + { case OPcolon: + case OPcolon2: + Pl = vec_clone(POSS); + Pr = vec_clone(POSS); + Dl = vec_calloc(asstop); + Dr = vec_calloc(asstop); + accumda(n->E1,Dl,Pl); + accumda(n->E2,Dr,Pr); + + /* D |= P & (Dl & Dr) | ~P & (Dl | Dr) */ + /* P = P & (Pl & Pr) | ~P & (Pl | Pr) */ + /* = Pl & Pr | ~P & (Pl | Pr) */ + vecdim = vec_dim(DEAD); + for (i = 0; i < vecdim; i++) +#if MPW + { + unsigned tmp1,tmp2; + tmp1 = POSS[i] & Dl[i] & Dr[i] ; + tmp2 = ~POSS[i] & (Dl[i] | Dr[i]); + DEAD[i] |= tmp1 | tmp2; + tmp1 = Pl[i] & Pr[i]; + tmp2 = ~POSS[i] & (Pl[i] | Pr[i]); + POSS[i] = tmp1 | tmp2; + } +#else + { DEAD[i] |= POSS[i] & Dl[i] & Dr[i] | + ~POSS[i] & (Dl[i] | Dr[i]); + POSS[i] = Pl[i] & Pr[i] | ~POSS[i] & (Pl[i] | Pr[i]); + } +#endif + vec_free(Pl); vec_free(Pr); vec_free(Dl); vec_free(Dr); + break; + + case OPandand: + case OPoror: + accumda(n->E1,DEAD,POSS); + // Substituting into the above equations Pl=P and Dl=0: + // D |= Dr - P + // P = Pr + Pr = vec_clone(POSS); + Dr = vec_calloc(asstop); + accumda(n->E2,Dr,Pr); + vec_subass(Dr,POSS); + vec_orass(DEAD,Dr); + vec_copy(POSS,Pr); + vec_free(Pr); vec_free(Dr); + break; + + case OPvar: + { symbol *v = n->EV.sp.Vsym; + targ_size_t voff = n->EV.sp.Voffset; + unsigned vsize = tysize(n->Ety); + + // We have a reference. Clear all bits in POSS that + // could be referenced. + + for (i = 0; i < assnum; i++) + { register elem *ti; + + ti = Elvalue(assnod[i]); + if (v == ti->EV.sp.Vsym && + // If symbol references overlap + voff + vsize > ti->EV.sp.Voffset && + ti->EV.sp.Voffset + tysize(ti->Ety) > voff + ) + vec_clearbit(i,POSS); + } + break; + } + + case OPasm: // reference everything + for (i = 0; i < assnum; i++) + vec_clearbit(i,POSS); + break; + + case OPind: + case OPucall: + case OPucallns: +#if !TX86 + case OPvp_fp: +#endif + accumda(n->E1,DEAD,POSS); + vec_subass(POSS,ambigref); // remove possibly refed + // assignments from list + // of possibly dead ones + break; + + case OPconst: + break; + + case OPcall: + case OPcallns: + case OPmemcpy: + case OPstrcpy: + case OPmemset: + accumda(n->E2,DEAD,POSS); + case OPstrlen: + accumda(n->E1,DEAD,POSS); + vec_subass(POSS,ambigref); // remove possibly refed + // assignments from list + // of possibly dead ones + break; + + case OPnewarray: + case OPmultinewarray: + case OParray: + case OPfield: + case OPstrcat: + case OPstrcmp: + case OPmemcmp: + accumda(n->E1,DEAD,POSS); + accumda(n->E2,DEAD,POSS); + vec_subass(POSS,ambigref); // remove possibly refed + // assignments from list + // of possibly dead ones + break; + + default: + if (OTassign(op)) + { elem *t; + + if (ERTOL(n)) + accumda(n->E2,DEAD,POSS); + t = Elvalue(n); + // if not (v = expression) then gen refs of left tree + if (op != OPeq) + accumda(n->E1,DEAD,POSS); + else if (OTunary(t->Eoper)) // if (*e = expression) + accumda(t->E1,DEAD,POSS); + else if (OTbinary(t->Eoper)) + { accumda(t->E1,DEAD,POSS); + accumda(t->E2,DEAD,POSS); + } + if (!ERTOL(n) && op != OPnegass) + accumda(n->E2,DEAD,POSS); + + // if unambiguous assignment, post all possibilities + // to DEAD + if (op == OPeq && t->Eoper == OPvar) + { + for (i = 0; i < assnum; i++) + { register elem *ti; + + ti = Elvalue(assnod[i]); + // There may be some problem with this next + // statement with unions. + if (ti->EV.sp.Vsym == t->EV.sp.Vsym && + ti->EV.sp.Voffset == t->EV.sp.Voffset && + tysize(ti->Ety) == tysize(t->Ety) && + !(t->Ety & mTYvolatile) && + //t->EV.sp.Vsym->Sflags & SFLunambig && + vec_testbit(i,POSS)) + vec_setbit(i,DEAD); + } + } + + // if assignment operator, post this def to POSS + if (n->Nflags & NFLassign) + { assnod[assnum] = n; + vec_setbit(assnum,POSS); + + // if variable could be referenced by a pointer + // or a function call, mark the assignment in + // ambigref + if (!(t->EV.sp.Vsym->Sflags & SFLunambig)) + { vec_setbit(assnum,ambigref); +#if DEBUG + if (debugc) + { dbg_printf("ambiguous lvalue: "); + WReqn(n); + dbg_printf("\n"); + } +#endif + } + + assnum++; + } + } + else if (OTrtol(op)) + { accumda(n->E2,DEAD,POSS); + accumda(n->E1,DEAD,POSS); + } + else if (OTbinary(op)) + { accumda(n->E1,DEAD,POSS); + accumda(n->E2,DEAD,POSS); + } + else if (OTunary(op)) + accumda(n->E1,DEAD,POSS); + break; + } +} + +/*************************** + * Mark all dead variables. Only worry about register candidates. + * Compute live ranges for register candidates. + * Be careful not to compute live ranges for members of structures (CLMOS). + */ + +void deadvar() +{ SYMIDX i; + + assert(dfo); + + /* First, mark each candidate as dead. */ + /* Initialize vectors for live ranges. */ + /*setvecdim(dfotop);*/ + for (i = 0; i < globsym.top; i++) + { symbol *s = globsym.tab[i]; + + if (s->Sflags & SFLunambig) + { + s->Sflags |= SFLdead; + if (s->Sflags & GTregcand) + { if (s->Srange) + vec_clear(s->Srange); + else + s->Srange = vec_calloc(maxblks); + } + } + } + + /* Go through trees and "liven" each one we see. */ + for (i = 0; i < dfotop; i++) + if (dfo[i]->Belem) + dvwalk(dfo[i]->Belem,i); + + /* Compute live variables. Set bit for block in live range */ + /* if variable is in the IN set for that block. */ + flowlv(); /* compute live variables */ + for (i = 0; i < globsym.top; i++) + { register unsigned j; + + if (globsym.tab[i]->Srange /*&& globsym.tab[i]->Sclass != CLMOS*/) + for (j = 0; j < dfotop; j++) + if (vec_testbit(i,dfo[j]->Binlv)) + vec_setbit(j,globsym.tab[i]->Srange); + } + + /* Print results */ + for (i = 0; i < globsym.top; i++) + { register char *p; + symbol *s = globsym.tab[i]; + + if (s->Sflags & SFLdead && s->Sclass != SCparameter && s->Sclass != SCregpar) + s->Sflags &= ~GTregcand; // do not put dead variables in registers +#ifdef DEBUG + p = (char *) s->Sident ; + if (s->Sflags & SFLdead) + cmes3("Symbol %d '%s' is dead\n",i,p); + if (debugc && s->Srange /*&& s->Sclass != CLMOS*/) + { dbg_printf("Live range for %d '%s': ",i,p); + vec_println(s->Srange); + } +#endif + } +} + +/***************************** + * Tree walk support routine for deadvar(). + * Input: + * n = elem to look at + * i = block index + */ + +STATIC void dvwalk(register elem *n,register unsigned i) +{ + for (; TRUE; n = n->E1) + { assert(n); + if (n->Eoper == OPvar || n->Eoper == OPrelconst) + { register symbol *s = n->EV.sp.Vsym; + + s->Sflags &= ~SFLdead; + if (s->Srange) + vec_setbit(i,s->Srange); + } + else if (!OTleaf(n->Eoper)) + { if (OTbinary(n->Eoper)) + dvwalk(n->E2,i); + continue; + } + break; + } +} + +/********************************* + * Optimize very busy expressions (VBEs). + */ + +static vec_t blockseen; /* which blocks we have visited */ + +void verybusyexp() +{ elem **pn; + register int i; + register unsigned j,k,l; + + cmes("verybusyexp()\n"); + flowvbe(); /* compute VBEs */ + if (exptop <= 1) return; /* if no VBEs */ + assert(expblk); + if (blockinit()) + return; // can't handle ASM blocks + compdom(); /* compute dominators */ + /*setvecdim(exptop);*/ + genkillae(); /* compute Bgen and Bkill for */ + /* AEs */ + /*chkvecdim(exptop,0);*/ + blockseen = vec_calloc(dfotop); + + /* Go backwards through dfo so that VBEs are evaluated as */ + /* close as possible to where they are used. */ + for (i = dfotop; --i >= 0;) /* for each block */ + { register block *b = dfo[i]; + register int done; + + /* Do not hoist things to blocks that do not */ + /* divide the flow of control. */ + + switch (b->BC) + { case BCiftrue: + case BCswitch: + break; + default: + continue; + } + + /* Find pointer to last statement in current elem */ + pn = &(b->Belem); + if (*pn) + { while ((*pn)->Eoper == OPcomma) + pn = &((*pn)->E2); + /* If last statement has side effects, */ + /* don't do these VBEs. Potentially we */ + /* could by assigning the result to */ + /* a temporary, and rewriting the tree */ + /* from (n) to (T=n,T) and installing */ + /* the VBE as (T=n,VBE,T). This */ + /* may not buy us very much, so we will */ + /* just skip it for now. */ + /*if (sideeffect(*pn))*/ + if (!(*pn)->Eexp) + continue; + } + + /* Eliminate all elems that have already been */ + /* hoisted (indicated by expnod[] == 0). */ + /* Constants are not useful as VBEs. */ + /* Eliminate all elems from Bout that are not in blocks */ + /* that are dominated by b. */ +#if 0 + dbg_printf("block %d Bout = ",i); + vec_println(b->Bout); +#endif + done = TRUE; + foreach (j,exptop,b->Bout) + { if (expnod[j] == 0 || + !!OTleaf(expnod[j]->Eoper) || + !dom(b,expblk[j])) + vec_clearbit(j,b->Bout); + else + done = FALSE; + } + if (done) continue; + + /* Eliminate from Bout all elems that are killed by */ + /* a block between b and that elem. */ +#if 0 + dbg_printf("block %d Bout = ",i); + vec_println(b->Bout); +#endif + + foreach (j,exptop,b->Bout) + { register list_t bl; + + vec_clear(blockseen); + for (bl = expblk[j]->Bpred; bl; bl = list_next(bl)) + { if (killed(j,list_block(bl),b)) + { vec_clearbit(j,b->Bout); + break; + } + } + } + + /* For each elem still left, make sure that there */ + /* exists a path from b to j along which there is */ + /* no other use of j (else it would be a CSE, and */ + /* it would be a waste of time to hoist it). */ +#if 0 + dbg_printf("block %d Bout = ",i); + vec_println(b->Bout); +#endif + + foreach (j,exptop,b->Bout) + { register list_t bl; + + vec_clear(blockseen); + for (bl = expblk[j]->Bpred; bl; bl = list_next(bl)) + { if (ispath(j,list_block(bl),b)) + goto L2; + } + vec_clearbit(j,b->Bout); /* thar ain't no path */ + L2: ; + } + + + /* For each elem that appears more than once in Bout */ + /* We have a VBE. */ +#if 0 + dbg_printf("block %d Bout = ",i); + vec_println(b->Bout); +#endif + + foreach (j,exptop,b->Bout) + { + for (k = j + 1; k < exptop; k++) + { if (vec_testbit(k,b->Bout) && + el_match(expnod[j],expnod[k])) + goto foundvbe; + } + continue; /* no VBE here */ + + foundvbe: /* we got one */ +#ifdef DEBUG + if (debugc) + { dbg_printf("VBE %d,%d, block %d (",j,k,i); + WReqn(expnod[j]); + dbg_printf(");\n"); + } +#endif + *pn = el_bin(OPcomma,(*pn)->Ety, + el_copytree(expnod[j]),*pn); + + /* Mark all the vbe elems found but one (the */ + /* expnod[j] one) so that the expression will */ + /* only be hoisted again if other occurrances */ + /* of the expression are found later. This */ + /* will substitute for the fact that the */ + /* el_copytree() expression does not appear in expnod[]. */ + l = k; + do + { if ( k == l || (vec_testbit(k,b->Bout) && + el_match(expnod[j],expnod[k]))) + { + /* Fix so nobody else will */ + /* vbe this elem */ + expnod[k] = NULL; + vec_clearbit(k,b->Bout); + } + } while (++k < exptop); + changes++; + } /* foreach */ + } /* for */ + vec_free(blockseen); +} + +/**************************** + * Return TRUE if elem j is killed somewhere + * between b and bp. + */ + +STATIC int killed(register unsigned j,register block *bp,block *b) +{ register list_t bl; + + if (bp == b || vec_testbit(bp->Bdfoidx,blockseen)) + return FALSE; + if (vec_testbit(j,bp->Bkill)) + return TRUE; + vec_setbit(bp->Bdfoidx,blockseen); /* mark as visited */ + for (bl = bp->Bpred; bl; bl = list_next(bl)) + if (killed(j,list_block(bl),b)) + return TRUE; + return FALSE; +} + +/*************************** + * Return TRUE if there is a path from b to bp along which + * elem j is not used. + * Input: + * b -> block where we want to put the VBE + * bp -> block somewhere between b and block containing j + * j = VBE expression elem candidate (index into expnod[]) + */ + +STATIC int ispath(register unsigned j,register block *bp,block *b) +{ register list_t bl; + register unsigned i; + + /*chkvecdim(exptop,0);*/ + if (bp == b) return TRUE; /* the trivial case */ + if (vec_testbit(bp->Bdfoidx,blockseen)) + return FALSE; /* already seen this block */ + vec_setbit(bp->Bdfoidx,blockseen); /* we've visited this block */ + + /* FALSE if elem j is used in block bp (and reaches the end */ + /* of bp, indicated by it being an AE in Bgen) */ + foreach (i,exptop,bp->Bgen) /* look thru used expressions */ + { if (i != j && expnod[i] && el_match(expnod[i],expnod[j])) + return FALSE; + } + + /* Not used in bp, see if there is a path through a predecessor */ + /* of bp */ + for (bl = bp->Bpred; bl; bl = list_next(bl)) + if (ispath(j,list_block(bl),b)) + return TRUE; + + return FALSE; /* j is used along all paths */ +} + +#endif diff --git a/backend/html.c b/backend/html.c new file mode 100644 index 00000000..4e26303f --- /dev/null +++ b/backend/html.c @@ -0,0 +1,771 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +/* HTML parser + */ + +#include +#include +#include +#include +#include +#include + +#include "html.h" + +#if MARS +#include +#include "root.h" +//#include "../mars/mars.h" +#else +#include "outbuf.h" +#include "msgs2.h" + +extern void html_err(const char *, unsigned, unsigned, ...); + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" +#endif + +#if __GNUC__ +int memicmp(const char *s1, const char *s2, int n); +#if 0 +{ + int result = 0; + + for (int i = 0; i < n; i++) + { char c1 = s1[i]; + char c2 = s2[i]; + + result = c1 - c2; + if (result) + { + if ('A' <= c1 && c1 <= 'Z') + c1 += 'a' - 'A'; + if ('A' <= c2 && c2 <= 'Z') + c2 += 'a' - 'A'; + result = c1 - c2; + if (result) + break; + } + } + return result; +} +#endif +#endif + +extern int HtmlNamedEntity(unsigned char *p, int length); + +static int isLineSeparator(const unsigned char* p); + +/********************************** + * Determine if beginning of tag identifier + * or a continuation of a tag identifier. + */ + +inline int istagstart(int c) +{ + return (isalpha(c) || c == '_'); +} + +inline int istag(int c) +{ + return (isalnum(c) || c == '_'); +} + +/********************************************** + */ + +Html::Html(const char *sourcename, unsigned char *base, unsigned length) +{ + //printf("Html::Html()\n"); + this->sourcename = sourcename; + this->base = base; + p = base; + end = base + length; + linnum = 1; + dbuf = NULL; + inCode = 0; +} + +/********************************************** + * Print error & quit. + */ + +void Html::error(const char *format, ...) +{ + printf("%s(%d) : HTML Error: ", sourcename, linnum); + + va_list ap; + va_start(ap, format); + vprintf(format, ap); + va_end(ap); + + printf("\n"); + fflush(stdout); + +//#if MARS +// global.errors++; +//#else + exit(EXIT_FAILURE); +//#endif +} + +/********************************************** + * Extract all the code from an HTML file, + * concatenate it all together, and store in buf. + */ + +#if MARS +void Html::extractCode(OutBuffer *buf) +#else +void Html::extractCode(Outbuffer *buf) +#endif +{ + //printf("Html::extractCode()\n"); + dbuf = buf; // save for other routines + buf->reserve(end - p); + inCode = 0; + while (1) + { + //printf("p = %p, *p = x%x\n", p, *p); + switch (*p) + { +#if 0 // strings are not recognized outside of tags + case '"': + case '\'': + skipString(); + continue; +#endif + case '<': + if (p[1] == '!' && isCommentStart()) + { // Comments start with + * Netscape: comments nest + * w3c: whitespace can appear between -- and > of comment close + */ + +void Html::scanComment() +{ + // Most of the complexity is dealing with the case that + // an arbitrary amount of whitespace can appear between + // the -- and the > of a comment close. + int scangt = 0; + + //printf("scanComment()\n"); + if (*p == '\n') + { linnum++; + // Always extract new lines, so that D lexer counts the + // lines right. + dbuf->writeByte(*p); + } + while (1) + { + //scangt = 1; // IE 5.0 compatibility + p++; + switch (*p) + { + case '-': + if (p[1] == '-') + { + if (p[2] == '>') // optimize for most common case + { + p += 3; + break; + } + p++; + scangt = 1; + } + else + scangt = 0; + continue; + + case '>': + if (scangt) + { // found --> + p++; + break; + } + continue; + + case ' ': + case '\t': + case '\f': + case '\v': + // skip white space + continue; + + case '\r': + if (p[1] == '\n') + goto Ldefault; + case '\n': + linnum++; // remember to count lines + // Always extract new lines, so that D lexer counts the + // lines right. + dbuf->writeByte(*p); + continue; + + case 0: + case 0x1a: + error("end of file before closing --> of comment"); + break; + + default: + Ldefault: + scangt = 0; // it's not --> + continue; + } + break; + } + //printf("*p = '%c'\n", *p); +} + +/******************************************** + * Determine if we are at the start of a comment. + * Input: + * p is on the opening '<' + * Returns: + * 0 if not start of a comment + * 1 if start of a comment, p is adjusted to point past -- + */ + +int Html::isCommentStart() +#ifdef __DMC__ + __out(result) + { + if (result == 0) + ; + else if (result == 1) + { + assert(p[-2] == '-' && p[-1] == '-'); + } + else + assert(0); + } + __body +#endif /* __DMC__ */ + { unsigned char *s; + + if (p[0] == '<' && p[1] == '!') + { + for (s = p + 2; 1; s++) + { + switch (*s) + { + case ' ': + case '\t': + case '\r': + case '\f': + case '\v': + // skip white space, even though spec says no + // white space is allowed + continue; + + case '-': + if (s[1] == '-') + { + p = s + 2; + return 1; + } + goto No; + + default: + goto No; + } + } + } + No: + return 0; + } + +int Html::isCDATAStart() +{ + const char * CDATA_START_MARKER = "0) + { + /* Always extract new lines, so that D lexer counts the lines + * right. + */ + linnum++; + dbuf->writeByte('\n'); + p += lineSepLength; + continue; + } + else if (p[0] == ']' && p[1] == ']' && p[2] == '>') + { + /* end of CDATA section */ + p += 3; + return; + } + else if (inCode) + { + /* this CDATA section contains D code */ + dbuf->writeByte(*p); + } + + p++; + } +} + + +/******************************************** + * Convert an HTML character entity into a character. + * Forms are: + * &name; named entity + * &#ddd; decimal + * &#xhhhh; hex + * Input: + * p is on the & + */ + +int Html::charEntity() +{ int c = 0; + int v; + int hex; + unsigned char *pstart = p; + + //printf("Html::charEntity('%c')\n", *p); + if (p[1] == '#') + { + p++; + if (p[1] == 'x' || p[1] == 'X') + { p++; + hex = 1; + } + else + hex = 0; + if (p[1] == ';') + goto Linvalid; + while (1) + { + p++; + switch (*p) + { + case 0: + case 0x1a: + error("end of file before end of character entity"); + goto Lignore; + + case '\n': + case '\r': + case '<': // tag start + // Termination is assumed + break; + + case ';': + // Termination is explicit + p++; + break; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + v = *p - '0'; + goto Lvalue; + + case 'a': case 'b': case 'c': + case 'd': case 'e': case 'f': + if (!hex) + goto Linvalid; + v = (*p - 'a') + 10; + goto Lvalue; + + case 'A': case 'B': case 'C': + case 'D': case 'E': case 'F': + if (!hex) + goto Linvalid; + v = (*p - 'A') + 10; + goto Lvalue; + + Lvalue: + if (hex) + c = (c << 4) + v; + else + c = (c * 10) + v; + if (c > 0x10FFFF) + { + error("character entity out of range"); + goto Lignore; + } + continue; + + default: + Linvalid: + error("invalid numeric character reference"); + goto Lignore; + } + break; + } + } + else + { + // It's a named entity; gather all characters until ; + unsigned char *idstart = p + 1; + + while (1) + { + p++; + switch (*p) + { + case 0: + case 0x1a: + error("end of file before end of character entity"); + break; + + case '\n': + case '\r': + case '<': // tag start + // Termination is assumed + c = HtmlNamedEntity(idstart, p - idstart); + if (c == -1) + goto Lignore; + break; + + case ';': + // Termination is explicit + c = HtmlNamedEntity(idstart, p - idstart); + if (c == -1) + goto Lignore; + p++; + break; + + default: + continue; + } + break; + } + } + + // Kludge to convert non-breaking space to ascii space + if (c == 160) + c = ' '; + + return c; + +Lignore: + //printf("Lignore\n"); + p = pstart + 1; + return '&'; +} + +/** + * identify DOS, Linux, Mac, Next and Unicode line endings + * 0 if this is no line separator + * >0 the length of the separator + * Note: input has to be UTF-8 + */ +static int isLineSeparator(const unsigned char* p) +{ + // Linux + if( p[0]=='\n') + return 1; + + // Mac & Dos + if( p[0]=='\r') + return (p[1]=='\n') ? 2 : 1; + + // Unicode (line || paragraph sep.) + if( p[0]==0xE2 && p[1]==0x80 && (p[2]==0xA8 || p[2]==0xA9)) + return 3; + + // Next + if( p[0]==0xC2 && p[1]==0x85) + return 2; + + return 0; +} + + diff --git a/backend/html.h b/backend/html.h new file mode 100644 index 00000000..9b5a548f --- /dev/null +++ b/backend/html.h @@ -0,0 +1,50 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#if MARS +struct OutBuffer; +#else +struct Outbuffer; +#endif + +struct Html +{ + const char *sourcename; + + unsigned char *base; // pointer to start of buffer + unsigned char *end; // past end of buffer + unsigned char *p; // current character + unsigned linnum; // current line number +#if MARS + OutBuffer *dbuf; // code source buffer +#else + Outbuffer *dbuf; // code source buffer +#endif + int inCode; // !=0 if in code + + + Html(const char *sourcename, unsigned char *base, unsigned length); + + void error(const char *format, ...); +#if MARS + void extractCode(OutBuffer *buf); +#else + void extractCode(Outbuffer *buf); +#endif + void skipTag(); + void skipString(); + unsigned char *skipWhite(unsigned char *q); + void scanComment(); + int isCommentStart(); + void scanCDATA(); + int isCDATAStart(); + int charEntity(); + static int namedEntity(unsigned char *p, int length); +}; diff --git a/backend/iasm.h b/backend/iasm.h new file mode 100644 index 00000000..07268223 --- /dev/null +++ b/backend/iasm.h @@ -0,0 +1,430 @@ + +/* + * Copyright (c) 1992-1999 by Symantec + * Copyright (c) 1999-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * Written by Mike Cote, John Micco and Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include + +///////////////////////////////////////////////// +// Instruction flags (usFlags) +// +// + +// This is for when the reg field of modregrm specifies which instruction it is +#define NUM_MASK 0x7 +#define NUM_MASKR 0x8 // for REX extended registers +#define _0 (0x0 | _modrm) // insure that some _modrm bit is set +#define _1 0x1 // with _0 +#define _2 0x2 +#define _3 0x3 +#define _4 0x4 +#define _5 0x5 +#define _6 0x6 +#define _7 0x7 + +#define _modrm 0x10 + +#define _r _modrm +#define _cb _modrm +#define _cw _modrm +#define _cd _modrm +#define _cq _modrm +#define _cp _modrm +#define _ib 0 +#define _iw 0 +#define _id 0 +#define _rb 0 +#define _rw 0 +#define _rd 0 +#define _16_bit 0x20 +#define _32_bit 0x40 +#define _64_bit 0x10000 +#define _i64_bit 0x20000 // opcode is invalid in 64bit mode +#define _I386 0x80 // opcode is only for 386 and later +#define _16_bit_addr 0x100 +#define _32_bit_addr 0x200 +#define _fwait 0x400 // Add an FWAIT prior to the instruction opcode +#define _nfwait 0x800 // Do not add an FWAIT prior to the instruction + +#define MOD_MASK 0xF000 // Mod mask +#define _modsi 0x1000 // Instruction modifies SI +#define _moddx 0x2000 // Instruction modifies DX +#define _mod2 0x3000 // Instruction modifies second operand +#define _modax 0x4000 // Instruction modifies AX +#define _modnot1 0x5000 // Instruction does not modify first operand +#define _modaxdx 0x6000 // instruction modifies AX and DX +#define _moddi 0x7000 // Instruction modifies DI +#define _modsidi 0x8000 // Instruction modifies SI and DI +#define _modcx 0x9000 // Instruction modifies CX +#define _modes 0xa000 // Instruction modifies ES +#define _modall 0xb000 // Instruction modifies all register values +#define _modsiax 0xc000 // Instruction modifies AX and SI +#define _modsinot1 0xd000 // Instruction modifies SI and not first param +#define _modcxr11 0xe000 // Instruction modifies CX and R11 +#define _modxmm0 0xf000 // Instruction modifies XMM0 + +// translates opcode into equivalent vex encoding +#define VEX_128_W0(op) (_VEX(op)|_VEX_NOO) +#define VEX_128_W1(op) (_VEX(op)|_VEX_NOO|_VEX_W) +#define VEX_128_WIG(op) VEX_128_W0(op) +#define VEX_256_W0(op) (_VEX(op)|_VEX_NOO|_VEX_L) +#define VEX_256_W1(op) (_VEX(op)|_VEX_NOO|_VEX_W|_VEX_L) +#define VEX_256_WIG(op) VEX_256_W0(op) +#define VEX_NDS_128_W0(op) (_VEX(op)|_VEX_NDS) +#define VEX_NDS_128_W1(op) (_VEX(op)|_VEX_NDS|_VEX_W) +#define VEX_NDS_128_WIG(op) VEX_NDS_128_W0(op) +#define VEX_NDS_256_W0(op) (_VEX(op)|_VEX_NDS|_VEX_L) +#define VEX_NDS_256_W1(op) (_VEX(op)|_VEX_NDS|_VEX_W|_VEX_L) +#define VEX_NDS_256_WIG(op) VEX_NDS_256_W0(op) +#define VEX_NDD_128_W0(op) (_VEX(op)|_VEX_NDD) +#define VEX_NDD_128_W1(op) (_VEX(op)|_VEX_NDD|_VEX_W) +#define VEX_NDD_128_WIG(op) VEX_NDD_128_W0(op) +#define VEX_NDD_256_W0(op) (_VEX(op)|_VEX_NDD|_VEX_L) +#define VEX_NDD_256_W1(op) (_VEX(op)|_VEX_NDD|_VEX_W|_VEX_L) +#define VEX_NDD_256_WIG(op) VEX_NDD_256_W0(op) +#define VEX_DDS_128_W0(op) (_VEX(op)|_VEX_DDS) +#define VEX_DDS_128_W1(op) (_VEX(op)|_VEX_DDS|_VEX_W) +#define VEX_DDS_128_WIG(op) VEX_DDS_128_W0(op) +#define VEX_DDS_256_W0(op) (_VEX(op)|_VEX_DDS|_VEX_L) +#define VEX_DDS_256_W1(op) (_VEX(op)|_VEX_DDS|_VEX_W|_VEX_L) +#define VEX_DDS_256_WIG(op) VEX_DDS_256_W0(op) + +#define _VEX_W 0x8000 +/* Don't encode LIG/LZ use 128 for these. + */ +#define _VEX_L 0x0400 +/* Encode nds, ndd, dds in the vvvv field, it gets + * overwritten with the actual register later. + */ +#define VEX_NOO 0 // neither of nds, ndd, dds +#define VEX_NDS 1 +#define VEX_NDD 2 +#define VEX_DDS 3 +#define _VEX_NOO ( VEX_NOO << 11) +#define _VEX_NDS ( VEX_NDS << 11) +#define _VEX_NDD ( VEX_NDD << 11) +#define _VEX_DDS ( VEX_DDS << 11) + +#define _VEX(op) (0xC4 << 24 | _VEX_MM(op >> 8) | (op & 0xFF)) + +#define _VEX_MM(op) \ + ( \ + ((op) & 0x00FF) == 0x000F ? (0x1 << 16 | _VEX_PP((op) >> 8)) : \ + ((op) & 0xFFFF) == 0x0F38 ? (0x2 << 16 | _VEX_PP((op) >> 16)) : \ + ((op) & 0xFFFF) == 0x0F3A ? (0x3 << 16 | _VEX_PP((op) >> 16)) : \ + _VEX_ASSERT0 \ + ) + +#define _VEX_PP(op) \ + ( \ + (op) == 0x00 ? 0x00 << 8 : \ + (op) == 0x66 ? 0x01 << 8 : \ + (op) == 0xF3 ? 0x02 << 8 : \ + (op) == 0xF2 ? 0x03 << 8 : \ + _VEX_ASSERT0 \ + ) + +// avoid dynamic initialization of the asm tables +#if DEBUG + #define _VEX_ASSERT0 (assert(0)) +#else + #define _VEX_ASSERT0 (0) +#endif + + +///////////////////////////////////////////////// +// Operand flags - usOp1, usOp2, usOp3 +// + +typedef unsigned opflag_t; + +// Operand flags for normal opcodes + +#define _r8 CONSTRUCT_FLAGS( _8, _reg, _normal, 0 ) +#define _r16 CONSTRUCT_FLAGS(_16, _reg, _normal, 0 ) +#define _r32 CONSTRUCT_FLAGS(_32, _reg, _normal, 0 ) +#define _r64 CONSTRUCT_FLAGS(_64, _reg, _normal, 0 ) +#define _m8 CONSTRUCT_FLAGS(_8, _m, _normal, 0 ) +#define _m16 CONSTRUCT_FLAGS(_16, _m, _normal, 0 ) +#define _m32 CONSTRUCT_FLAGS(_32, _m, _normal, 0 ) +#define _m48 CONSTRUCT_FLAGS( _48, _m, _normal, 0 ) +#define _m64 CONSTRUCT_FLAGS( _64, _m, _normal, 0 ) +#define _m128 CONSTRUCT_FLAGS( _anysize, _m, _normal, 0 ) +#define _m256 CONSTRUCT_FLAGS( _anysize, _m, _normal, 0 ) +#define _rm8 CONSTRUCT_FLAGS(_8, _rm, _normal, 0 ) +#define _rm16 CONSTRUCT_FLAGS(_16, _rm, _normal, 0 ) +#define _rm32 CONSTRUCT_FLAGS(_32, _rm, _normal, 0) +#define _rm64 CONSTRUCT_FLAGS(_64, _rm, _normal, 0) +#define _r32m8 CONSTRUCT_FLAGS(_32|_8, _rm, _normal, 0) +#define _r32m16 CONSTRUCT_FLAGS(_32|_16, _rm, _normal, 0) +#define _regm8 CONSTRUCT_FLAGS(_64|_32|_8, _rm, _normal, 0) +#define _imm8 CONSTRUCT_FLAGS(_8, _imm, _normal, 0 ) +#define _imm16 CONSTRUCT_FLAGS(_16, _imm, _normal, 0) +#define _imm32 CONSTRUCT_FLAGS(_32, _imm, _normal, 0) +#define _imm64 CONSTRUCT_FLAGS(_64, _imm, _normal, 0) +#define _rel8 CONSTRUCT_FLAGS(_8, _rel, _normal, 0) +#define _rel16 CONSTRUCT_FLAGS(_16, _rel, _normal, 0) +#define _rel32 CONSTRUCT_FLAGS(_32, _rel, _normal, 0) +#define _p1616 CONSTRUCT_FLAGS(_32, _p, _normal, 0) +#define _m1616 CONSTRUCT_FLAGS(_32, _mnoi, _normal, 0) +#define _p1632 CONSTRUCT_FLAGS(_48, _p, _normal, 0 ) +#define _m1632 CONSTRUCT_FLAGS(_48, _mnoi, _normal, 0) +#define _special CONSTRUCT_FLAGS( 0, 0, _rspecial, 0 ) +#define _seg CONSTRUCT_FLAGS( 0, 0, _rseg, 0 ) +#define _a16 CONSTRUCT_FLAGS( 0, 0, _addr16, 0 ) +#define _a32 CONSTRUCT_FLAGS( 0, 0, _addr32, 0 ) +#define _f16 CONSTRUCT_FLAGS( 0, 0, _fn16, 0) + // Near function pointer +#define _f32 CONSTRUCT_FLAGS( 0, 0, _fn32, 0) + // Far function pointer +#define _lbl CONSTRUCT_FLAGS( 0, 0, _flbl, 0 ) + // Label (in current function) + +#define _mmm32 CONSTRUCT_FLAGS( 0, _m, 0, _32) +#define _mmm64 CONSTRUCT_FLAGS( _64, _m, 0, _f64) +#define _mmm128 CONSTRUCT_FLAGS( 0, _m, 0, _f128) + +#define _xmm_m16 CONSTRUCT_FLAGS( _16, _m, _rspecial, ASM_GET_uRegmask(_xmm)) +#define _xmm_m32 CONSTRUCT_FLAGS( _32, _m, _rspecial, ASM_GET_uRegmask(_xmm)) +#define _xmm_m64 CONSTRUCT_FLAGS( _anysize, _m, _rspecial, ASM_GET_uRegmask(_xmm)) +#define _xmm_m128 CONSTRUCT_FLAGS( _anysize, _m, _rspecial, ASM_GET_uRegmask(_xmm)) +#define _ymm_m256 CONSTRUCT_FLAGS( _anysize, _m, _rspecial, ASM_GET_uRegmask(_ymm)) + +#define _moffs8 (_rel8) +#define _moffs16 (_rel16 ) +#define _moffs32 (_rel32 ) + + +//////////////////////////////////////////////////////////////////// +// Operand flags for floating point opcodes are all just aliases for +// normal opcode variants and only asm_determine_operator_flags should +// need to care. +// +#define _fm80 CONSTRUCT_FLAGS( 0, _m, 0, _f80 ) +#define _fm64 CONSTRUCT_FLAGS( 0, _m, 0, _f64 ) +#define _fm128 CONSTRUCT_FLAGS( 0, _m, 0, _f128 ) +#define _fanysize (_f64 | _f80 | _f112 ) + +#define _float_m CONSTRUCT_FLAGS( _anysize, _float, 0, _fanysize) + +#define _st CONSTRUCT_FLAGS( 0, _float, 0, _rst ) // stack register 0 +#define _m112 CONSTRUCT_FLAGS( 0, _m, 0, _f112 ) +#define _m224 _m112 +#define _m512 _m224 +#define _sti CONSTRUCT_FLAGS( 0, _float, 0, _rsti ) + +////////////////// FLAGS ///////////////////////////////////// + +#if 1 +// bit size 5 3 3 7 +#define CONSTRUCT_FLAGS( uSizemask, aopty, amod, uRegmask ) \ + ( (uSizemask) | (aopty) << 5 | (amod) << 8 | (uRegmask) << 11) + +#define ASM_GET_uSizemask(us) ((us) & 0x1F) +#define ASM_GET_aopty(us) ((ASM_OPERAND_TYPE)(((us) >> 5) & 7)) +#define ASM_GET_amod(us) ((ASM_MODIFIERS)(((us) >> 8) & 7)) +#define ASM_GET_uRegmask(us) (((us) >> 11) & 0x7F) +#else +#define CONSTRUCT_FLAGS( uSizemask, aopty, amod, uRegmask ) \ + ( (uSizemask) | (aopty) << 4 | (amod) << 7 | (uRegmask) << 10) + +#define ASM_GET_uSizemask(us) ((us) & 0x0F) +#define ASM_GET_aopty(us) ((ASM_OPERAND_TYPE)(((us) & 0x70) >> 4)) +#define ASM_GET_amod(us) ((ASM_MODIFIERS)(((us) & 0x380) >> 7)) +#define ASM_GET_uRegmask(us) (((us) & 0xFC00) >> 10) +#endif + +// For uSizemask (5 bits) +#define _8 0x1 +#define _16 0x2 +#define _32 0x4 +#define _48 0x8 +#define _64 0x10 +#define _anysize (_8 | _16 | _32 | _48 | _64 ) + +// For aopty (3 bits) +enum ASM_OPERAND_TYPE { + _reg, // _r8, _r16, _r32 + _m, // _m8, _m16, _m32, _m48 + _imm, // _imm8, _imm16, _imm32, _imm64 + _rel, // _rel8, _rel16, _rel32 + _mnoi, // _m1616, _m1632 + _p, // _p1616, _p1632 + _rm, // _rm8, _rm16, _rm32 + _float // Floating point operand, look at cRegmask for the + // actual size +}; + +// For amod (3 bits) +enum ASM_MODIFIERS { + _normal, // Normal register value + _rseg, // Segment registers + _rspecial, // Special registers + _addr16, // 16 bit address + _addr32, // 32 bit address + _fn16, // 16 bit function call + _fn32, // 32 bit function call + _flbl // Label +}; + +// For uRegmask (7 bits) + +// uRegmask flags when aopty == _float +#define _rst 0x1 +#define _rsti 0x2 +#define _f64 0x4 +#define _f80 0x8 +#define _f112 0x10 +#define _f128 0x20 + +// _seg register values (amod == _rseg) +// +#define _ds CONSTRUCT_FLAGS( 0, 0, _rseg, 0x01 ) +#define _es CONSTRUCT_FLAGS( 0, 0, _rseg, 0x02 ) +#define _ss CONSTRUCT_FLAGS( 0, 0, _rseg, 0x04 ) +#define _fs CONSTRUCT_FLAGS( 0, 0, _rseg, 0x08 ) +#define _gs CONSTRUCT_FLAGS( 0, 0, _rseg, 0x10 ) +#define _cs CONSTRUCT_FLAGS( 0, 0, _rseg, 0x20 ) + +// +// _special register values +// +#define _crn CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x01 ) // CRn register (0,2,3) +#define _drn CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x02 ) // DRn register (0-3,6-7) +#define _trn CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x04 ) // TRn register (3-7) +#define _mm CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x08 ) // MMn register (0-7) +#define _xmm CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x10 ) // XMMn register (0-7) +#define _xmm0 CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x20 ) // XMM0 register +#define _ymm CONSTRUCT_FLAGS( 0, 0, _rspecial, 0x40 ) // YMMn register (0-15) + +// +// Default register values +// + +#define _al CONSTRUCT_FLAGS( 0, 0, _normal, 0x01 ) // AL register +#define _ax CONSTRUCT_FLAGS( 0, 0, _normal, 0x02 ) // AX register +#define _eax CONSTRUCT_FLAGS( 0, 0, _normal, 0x04 ) // EAX register +#define _dx CONSTRUCT_FLAGS( 0, 0, _normal, 0x08 ) // DX register +#define _cl CONSTRUCT_FLAGS( 0, 0, _normal, 0x10 ) // CL register +#define _rax CONSTRUCT_FLAGS( 0, 0, _normal, 0x40 ) // RAX register + + +#define _rplus_r 0x20 +#define _plus_r CONSTRUCT_FLAGS( 0, 0, 0, _rplus_r ) + // Add the register to the opcode (no mod r/m) + + + +////////////////////////////////////////////////////////////////// + +#define ITprefix 0x10 // special prefix +#define ITjump 0x20 // jump instructions CALL, Jxx and LOOPxx +#define ITimmed 0x30 // value of an immediate operand controls + // code generation +#define ITopt 0x40 // not all operands are required +#define ITshift 0x50 // rotate and shift instructions +#define ITfloat 0x60 // floating point coprocessor instructions +#define ITdata 0x70 // DB, DW, DD, DQ, DT pseudo-ops +#define ITaddr 0x80 // DA (define addresss) pseudo-op +#define ITMASK 0xF0 +#define ITSIZE 0x0F // mask for size + +enum OP_DB +{ +#if SCPP + // These are the number of bytes + OPdb = 1, + OPdw = 2, + OPdd = 4, + OPdq = 8, + OPdt = 10, + OPdf = 4, + OPde = 10, + OPds = 2, + OPdi = 4, + OPdl = 8, +#endif +#if MARS + // Integral types + OPdb, + OPds, + OPdi, + OPdl, + + // Float types + OPdf, + OPdd, + OPde, + + // Deprecated + OPdw = OPds, + OPdq = OPdl, + OPdt = OPde, +#endif +}; + + +/* from iasm.c */ +int asm_state(int iFlags); + +void asm_process_fixup( block **ppblockLabels ); + +typedef struct _PTRNTAB4 { + unsigned usOpcode; + unsigned usFlags; + opflag_t usOp1; + opflag_t usOp2; + opflag_t usOp3; + opflag_t usOp4; +} PTRNTAB4, * PPTRNTAB4, ** PPPTRNTAB4; + +typedef struct _PTRNTAB3 { + unsigned usOpcode; + unsigned usFlags; + opflag_t usOp1; + opflag_t usOp2; + opflag_t usOp3; +} PTRNTAB3, * PPTRNTAB3, ** PPPTRNTAB3; + +typedef struct _PTRNTAB2 { + unsigned usOpcode; + unsigned usFlags; + opflag_t usOp1; + opflag_t usOp2; +} PTRNTAB2, * PPTRNTAB2, ** PPPTRNTAB2; + +typedef struct _PTRNTAB1 { + unsigned usOpcode; + unsigned usFlags; + opflag_t usOp1; +} PTRNTAB1, * PPTRNTAB1, ** PPPTRNTAB1; + +typedef struct _PTRNTAB0 { + unsigned usOpcode; + #define ASM_END 0xffff // special opcode meaning end of table + unsigned usFlags; +} PTRNTAB0, * PPTRNTAB0, ** PPPTRNTAB0; + +typedef union _PTRNTAB { + PTRNTAB0 *pptb0; + PTRNTAB1 *pptb1; + PTRNTAB2 *pptb2; + PTRNTAB3 *pptb3; + PTRNTAB4 *pptb4; +} PTRNTAB, * PPTRNTAB, ** PPPTRNTAB; + +typedef struct +{ + unsigned char usNumops; + PTRNTAB ptb; +} OP; + diff --git a/backend/mach.h b/backend/mach.h new file mode 100644 index 00000000..f0e82cc3 --- /dev/null +++ b/backend/mach.h @@ -0,0 +1,323 @@ + +/* Mach-O object file format */ + +#if __APPLE__ + +#include +#include +#include +#include +//#include + +#ifndef S_DTRACE_DOF + #define S_DTRACE_DOF 15 +#endif + +#else + +#include + +typedef int cpu_type_t; +typedef int cpu_subtype_t; +typedef int vm_prot_t; + +struct mach_header +{ + uint32_t magic; + #define MH_MAGIC 0xfeedface + #define MH_CIGAM 0xcefaedfe + cpu_type_t cputype; + #define CPU_TYPE_I386 ((cpu_type_t)7) + #define CPU_TYPE_X86_64 ((cpu_type_t)7 | 0x1000000) + #define CPU_TYPE_POWERPC ((cpu_type_t)18) + #define CPU_TYPE_POWERPC64 (CPU_TYPE_POWERPC | 0x1000000) + cpu_subtype_t cpusubtype; + #define CPU_SUBTYPE_POWERPC_ALL ((cpu_subtype_t)0) + #define CPU_SUBTYPE_I386_ALL ((cpu_subtype_t)3) + uint32_t filetype; + #define MH_OBJECT 1 + #define MH_EXECUTE 2 + #define MH_BUNDLE 8 + #define MH_DYLIB 6 + #define MH_PRELOAD 5 + #define MH_CORE 4 + #define MH_DYLINKER 7 + #define MH_DSYM 10 + uint32_t ncmds; + uint32_t sizeofcmds; + uint32_t flags; + #define MH_NOUNDEFS 1 + #define MH_INCRLINK 2 + #define MH_DYLDLINK 4 + #define MH_TWOLEVEL 0x80 + #define MH_BINDATLOAD 8 + #define MH_PREBOUND 0x10 + #define MH_PREBINDABLE 0x800 + #define MH_NOFIXPREBINDING 0x400 + #define MH_ALLMODSBOUND 0x1000 + #define MH_CANONICAL 0x4000 + #define MH_SPLIT_SEGS 0x20 + #define MH_FORCE_FLAT 0x100 + #define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000 + #define MH_NOMULTIDEFS 0x200 +}; + +struct mach_header_64 +{ + uint32_t magic; + #define MH_MAGIC_64 0xfeedfacf + #define MH_CIGAM_64 0xcffaedfe + cpu_type_t cputype; + cpu_subtype_t cpusubtype; + uint32_t filetype; + uint32_t ncmds; + uint32_t sizeofcmds; + uint32_t flags; + uint32_t reserved; +}; + +struct load_command +{ + uint32_t cmd; + #define LC_SEGMENT 1 + #define LC_SYMTAB 2 + #define LC_DYSYMTAB 11 + #define LC_SEGMENT_64 0x19 + uint32_t cmdsize; +}; + +struct uuid_command +{ + uint32_t cmd; + uint32_t cmdsize; + uint8_t uuid[16]; +}; + +struct segment_command +{ + uint32_t cmd; + uint32_t cmdsize; + char segname[16]; + uint32_t vmaddr; + uint32_t vmsize; + uint32_t fileoff; + uint32_t filesize; + vm_prot_t maxprot; + vm_prot_t initprot; + uint32_t nsects; + uint32_t flags; + #define SG_HIGHVM 1 + #define SG_FVMLIB 2 + #define SG_NORELOC 4 + #define SG_PROTECTED_VERSION_1 8 +}; + +struct segment_command_64 +{ + uint32_t cmd; + uint32_t cmdsize; + char segname[16]; + uint64_t vmaddr; + uint64_t vmsize; + uint64_t fileoff; + uint64_t filesize; + vm_prot_t maxprot; + vm_prot_t initprot; + uint32_t nsects; + uint32_t flags; +}; + +struct section +{ + char sectname[16]; + char segname[16]; + uint32_t addr; + uint32_t size; + uint32_t offset; + uint32_t align; + uint32_t reloff; + uint32_t nreloc; + uint32_t flags; + #define SECTION_TYPE 0xFF + #define SECTION_ATTRIBUTES 0xFFFFFF00 + + #define S_REGULAR 0 + #define S_ZEROFILL 1 + #define S_CSTRING_LITERALS 2 + #define S_4BYTE_LITERALS 3 + #define S_8BYTE_LITERALS 4 + #define S_LITERAL_POINTERS 5 + + #define S_NON_LAZY_SYMBOL_POINTERS 6 + #define S_LAZY_SYMBOL_POINTERS 7 + #define S_SYMBOL_STUBS 8 + #define S_MOD_INIT_FUNC_POINTERS 9 + #define S_MOD_TERM_FUNC_POINTERS 10 + #define S_COALESCED 11 + #define S_GB_ZEROFILL 12 + #define S_INTERPOSING 13 + #define S_16BYTE_LITERALS 14 + #define S_DTRACE_DOF 15 + + #define SECTION_ATTRIBUTES_USR 0xFF000000 + #define S_ATTR_PURE_INSTRUCTIONS 0x80000000 + #define S_ATTR_NO_TOC 0x40000000 + #define S_ATTR_STRIP_STATIC_SYMS 0x20000000 + #define S_ATTR_NO_DEAD_STRIP 0x10000000 + #define S_ATTR_LIVE_SUPPORT 0x8000000 + #define S_ATTR_SELF_MODIFYING_CODE 0x4000000 + #define S_ATTR_DEBUG 0x2000000 + + #define SECTION_ATTRIBUTES_SYS 0xFFFF00 + #define S_ATTR_SOME_INSTRUCTIONS 0x000400 + #define S_ATTR_EXT_RELOC 0x000200 + #define S_ATTR_LOC_RELOC 0x000100 + + uint32_t reserved1; + uint32_t reserved2; +}; + +struct section_64 +{ + char sectname[16]; + char segname[16]; + uint64_t addr; + uint64_t size; + uint32_t offset; + uint32_t align; + uint32_t reloff; + uint32_t nreloc; + uint32_t flags; + uint32_t reserved1; + uint32_t reserved2; + uint32_t reserved3; +}; + +struct twolevel_hints_command +{ + uint32_t cmd; + uint32_t cmdsize; + uint32_t offset; + uint32_t nhints; +}; + +struct twolevel_hint +{ + uint32_t isub_image:8, itoc:24; +}; + +struct symtab_command +{ + uint32_t cmd; + uint32_t cmdsize; + uint32_t symoff; + uint32_t nsyms; + uint32_t stroff; + uint32_t strsize; +}; + +struct nlist +{ + union + { + int32_t n_strx; + } n_un; + uint8_t n_type; + #define N_EXT 1 + #define N_STAB 0xE0 + #define N_PEXT 0x10 + #define N_TYPE 0x0E + #define N_UNDF 0 + #define N_ABS 2 + #define N_INDR 10 + #define N_PBUD 12 + #define N_SECT 14 + uint8_t n_sect; + int16_t n_desc; + uint32_t n_value; +}; + +struct nlist_64 +{ + union + { + uint32_t n_strx; + } n_un; + uint8_t n_type; + uint8_t n_sect; + uint16_t n_desc; + uint64_t n_value; +}; + +struct dysymtab_command +{ + uint32_t cmd; + uint32_t cmdsize; + uint32_t ilocalsym; + uint32_t nlocalsym; + uint32_t iextdefsym; + uint32_t nextdefsym; + uint32_t iundefsym; + uint32_t nundefsym; + uint32_t tocoff; + uint32_t ntoc; + uint32_t modtaboff; + uint32_t nmodtab; + uint32_t extrefsymoff; + uint32_t nextrefsyms; + uint32_t indirectsymoff; + uint32_t nindirectsyms; + uint32_t extreloff; + uint32_t nextrel; + uint32_t locreloff; + uint32_t nlocrel; +}; + +struct relocation_info +{ + int32_t r_address; + #define R_SCATTERED 0x80000000 + uint32_t r_symbolnum:24, + r_pcrel:1, + r_length:2, + r_extern:1, + r_type:4; + // for i386 + #define GENERIC_RELOC_VANILLA 0 + #define GENERIC_RELOC_PAIR 1 + #define GENERIC_RELOC_SECTDIFF 2 + #define GENERIC_RELOC_PB_LA_PTR 3 + #define GENERIC_RELOC_LOCAL_SECTDIFF 4 + + // for x86_64 + #define X86_64_RELOC_UNSIGNED 0 + #define X86_64_RELOC_SIGNED 1 + #define X86_64_RELOC_BRANCH 2 + #define X86_64_RELOC_GOT_LOAD 3 + #define X86_64_RELOC_GOT 4 + #define X86_64_RELOC_SUBTRACTOR 5 + #define X86_64_RELOC_SIGNED_1 6 + #define X86_64_RELOC_SIGNED_2 7 + #define X86_64_RELOC_SIGNED_4 8 +}; + +struct scattered_relocation_info +{ + #if LITTLE_ENDIAN + uint32_t r_address:24, + r_type:4, + r_length:2, + r_pcrel:1, + r_scattered:1; + int32_t r_value; + #elif BIG_ENDIAN + uint32_t r_scattered:1, + r_pcrel:1, + r_length:2, + r_type:4, + r_address:24; + int32_t r_value; + #endif +}; + +#endif diff --git a/backend/machobj.c b/backend/machobj.c new file mode 100644 index 00000000..a710ea02 --- /dev/null +++ b/backend/machobj.c @@ -0,0 +1,2757 @@ + +// Copyright (c) 2009-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#if SCPP || MARS +#include +#include +#include +#include +#include +#include +#include + +#if _WIN32 || linux +#include +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#endif + +#if __APPLE__ +#import + +const SInt32 MacOSX_10_5 = 0x1050; +const SInt32 MacOSX_10_6 = 0x1060; +#endif + +#include "cc.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "mach.h" +#include "outbuf.h" +#include "filespec.h" +#include "cv4.h" +#include "cgcv.h" +#include "dt.h" + +#include "aa.h" +#include "tinfo.h" + +#if MACHOBJ + +#if MARS +#include "mars.h" +#endif + +#include "mach.h" +#include "dwarf.h" + +// for x86_64 +#define X86_64_RELOC_UNSIGNED 0 +#define X86_64_RELOC_SIGNED 1 +#define X86_64_RELOC_BRANCH 2 +#define X86_64_RELOC_GOT_LOAD 3 +#define X86_64_RELOC_GOT 4 +#define X86_64_RELOC_SUBTRACTOR 5 +#define X86_64_RELOC_SIGNED_1 6 +#define X86_64_RELOC_SIGNED_2 7 +#define X86_64_RELOC_SIGNED_4 8 + +static Outbuffer *fobjbuf; + +regm_t BYTEREGS = BYTEREGS_INIT; +regm_t ALLREGS = ALLREGS_INIT; + +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" + +#define DEST_LEN (IDMAX + IDOHD + 1) +char *obj_mangle2(Symbol *s,char *dest); + +#if MARS +// C++ name mangling is handled by front end +#define cpp_mangle(s) ((s)->Sident) +#endif + + +/****************************************** + */ + +symbol *GOTsym; // global offset table reference + +symbol *elfobj_getGOTsym() +{ + if (!GOTsym) + { + GOTsym = symbol_name("_GLOBAL_OFFSET_TABLE_",SCglobal,tspvoid); + } + return GOTsym; +} + +static void objfile_write(FILE *fd, void *buffer, unsigned len); + +STATIC char * objmodtoseg (const char *modname); +STATIC void obj_browse_flush(); +STATIC void objfixupp (struct FIXUP *); +STATIC void ledata_new (int seg,targ_size_t offset); + +static long elf_align(targ_size_t size, long offset); + +// The object file is built is several separate pieces + + +// String Table - String table for all other names +static Outbuffer *symtab_strings; + +// Section Headers +Outbuffer *SECbuf; // Buffer to build section table in +#define SecHdrTab ((struct section *)SECbuf->buf) +#define SecHdrTab64 ((struct section_64 *)SECbuf->buf) + +// The relocation for text and data seems to get lost. +// Try matching the order gcc output them +// This means defining the sections and then removing them if they are +// not used. +static int section_cnt; // Number of sections in table +#define SEC_TAB_INIT 16 // Initial number of sections in buffer +#define SEC_TAB_INC 4 // Number of sections to increment buffer by + +#define SYM_TAB_INIT 100 // Initial number of symbol entries in buffer +#define SYM_TAB_INC 50 // Number of symbols to increment buffer by + +/* Three symbol tables, because the different types of symbols + * are grouped into 3 different types (and a 4th for comdef's). + */ + +static Outbuffer *local_symbuf; +static Outbuffer *public_symbuf; +static Outbuffer *extern_symbuf; + +struct Comdef { symbol *sym; targ_size_t size; int count; }; +static Outbuffer *comdef_symbuf; // Comdef's are stored here + +static Outbuffer *indirectsymbuf1; // indirect symbol table of Symbol*'s +static int jumpTableSeg; // segment index for __jump_table + +static Outbuffer *indirectsymbuf2; // indirect symbol table of Symbol*'s +static int pointersSeg; // segment index for __pointers + +/* If an objextdef() happens, set this to the string index, + * to be added last to the symbol table. + * Obviously, there can be only one. + */ +static IDXSTR extdef; + +#if 0 +#define STI_FILE 1 // Where file symbol table entry is +#define STI_TEXT 2 +#define STI_DATA 3 +#define STI_BSS 4 +#define STI_GCC 5 // Where "gcc2_compiled" symbol is */ +#define STI_RODAT 6 // Symbol for readonly data +#define STI_COM 8 +#endif + +// Each compiler segment is a section +// Predefined compiler segments CODE,DATA,CDATA,UDATA map to indexes +// into SegData[] +// New compiler segments are added to end. + +/****************************** + * Returns !=0 if this segment is a code segment. + */ + +int seg_data::isCode() +{ + if (I64) + { + //printf("SDshtidx = %d, x%x\n", SDshtidx, SecHdrTab64[SDshtidx].flags); + return strcmp(SecHdrTab64[SDshtidx].segname, "__TEXT") == 0; + } + else + { + //printf("SDshtidx = %d, x%x\n", SDshtidx, SecHdrTab[SDshtidx].flags); + return strcmp(SecHdrTab[SDshtidx].segname, "__TEXT") == 0; + } +} + + +seg_data **SegData; +int seg_count; +int seg_max; +int seg_tlsseg = UNKNOWN; +int seg_tlsseg_bss = UNKNOWN; + +/******************************************************* + * Because the Mach-O relocations cannot be computed until after + * all the segments are written out, and we need more information + * than the Mach-O relocations provide, make our own relocation + * type. Later, translate to Mach-O relocation structure. + */ + +struct Relocation +{ // Relocations are attached to the struct seg_data they refer to + targ_size_t offset; // location in segment to be fixed up + symbol *funcsym; // function in which offset lies, if any + symbol *targsym; // if !=NULL, then location is to be fixed up + // to address of this symbol + unsigned targseg; // if !=0, then location is to be fixed up + // to address of start of this segment + unsigned char rtype; // RELxxxx +#define RELaddr 0 // straight address +#define RELrel 1 // relative to location to be fixed up + short val; // 0, -1, -2, -4 +}; + + +/******************************* + * Output a string into a string table + * Input: + * strtab = string table for entry + * str = string to add + * + * Returns index into the specified string table. + */ + +IDXSTR elf_addstr(Outbuffer *strtab, const char *str) +{ + //printf("elf_addstr(strtab = %p str = '%s')\n",strtab,str); + IDXSTR idx = strtab->size(); // remember starting offset + strtab->writeString(str); + //printf("\tidx %d, new size %d\n",idx,strtab->size()); + return idx; +} + +/******************************* + * Find a string in a string table + * Input: + * strtab = string table for entry + * str = string to find + * + * Returns index into the specified string table or 0. + */ + +static IDXSTR elf_findstr(Outbuffer *strtab, const char *str, const char *suffix) +{ + const char *ent = (char *)strtab->buf+1; + const char *pend = ent+strtab->size() - 1; + const char *s = str; + const char *sx = suffix; + int len = strlen(str); + + if (suffix) + len += strlen(suffix); + + while(ent < pend) + { + if(*ent == 0) // end of table entry + { + if(*s == 0 && !sx) // end of string - found a match + { + return ent - (const char *)strtab->buf - len; + } + else // table entry too short + { + s = str; // back to beginning of string + sx = suffix; + ent++; // start of next table entry + } + } + else if (*s == 0 && sx && *sx == *ent) + { // matched first string + s = sx+1; // switch to suffix + ent++; + sx = NULL; + } + else // continue comparing + { + if (*ent == *s) + { // Have a match going + ent++; + s++; + } + else // no match + { + while(*ent != 0) // skip to end of entry + ent++; + ent++; // start of next table entry + s = str; // back to beginning of string + sx = suffix; + } + } + } + return 0; // never found match +} + +/******************************* + * Output a mangled string into the symbol string table + * Input: + * str = string to add + * + * Returns index into the table. + */ + +static IDXSTR elf_addmangled(Symbol *s) +{ + //printf("elf_addmangled(%s)\n", s->Sident); + char dest[DEST_LEN]; + char *destr; + const char *name; + int len; + IDXSTR namidx; + + namidx = symtab_strings->size(); + destr = obj_mangle2(s, dest); + name = destr; + if (CPP && name[0] == '_' && name[1] == '_') + { + if (strncmp(name,"__ct__",6) == 0) + name += 4; +#if 0 + switch(name[2]) + { + case 'c': + if (strncmp(name,"__ct__",6) == 0) + name += 4; + break; + case 'd': + if (strcmp(name,"__dl__FvP") == 0) + name = "__builtin_delete"; + break; + case 'v': + //if (strcmp(name,"__vec_delete__FvPiUIPi") == 0) + //name = "__builtin_vec_del"; + //else + //if (strcmp(name,"__vn__FPUI") == 0) + //name = "__builtin_vec_new"; + break; + case 'n': + if (strcmp(name,"__nw__FPUI") == 0) + name = "__builtin_new"; + break; + } +#endif + } + else if (tyfunc(s->ty()) && s->Sfunc && s->Sfunc->Fredirect) + name = s->Sfunc->Fredirect; + len = strlen(name); + symtab_strings->reserve(len+1); + strcpy((char *)symtab_strings->p,name); + symtab_strings->setsize(namidx+len+1); + if (destr != dest) // if we resized result + mem_free(destr); + //dbg_printf("\telf_addmagled symtab_strings %s namidx %d len %d size %d\n",name, namidx,len,symtab_strings->size()); + return namidx; +} + +/************************** + * Ouput read only data and generate a symbol for it. + * + */ + +symbol * elf_sym_cdata(tym_t ty,char *p,int len) +{ + symbol *s; + +#if 0 + if (I64) + { + alignOffset(DATA, tysize(ty)); + s = symboldata(Doffset, ty); + SegData[DATA]->SDbuf->write(p,len); + s->Sseg = DATA; + s->Soffset = Doffset; // Remember its offset into DATA section + Doffset += len; + } + else +#endif + { + //printf("elf_sym_cdata(ty = %x, p = %x, len = %d, CDoffset = %x)\n", ty, p, len, CDoffset); + alignOffset(CDATA, tysize(ty)); + s = symboldata(CDoffset, ty); + s->Sseg = CDATA; + //objpubdef(CDATA, s, CDoffset); + obj_bytes(CDATA, CDoffset, len, p); + } + + s->Sfl = /*(config.flags3 & CFG3pic) ? FLgotoff :*/ FLextern; + return s; +} + +/************************** + * Ouput read only data for data + * + */ + +int elf_data_cdata(char *p, int len, int *pseg) +{ + int oldoff; + if (I64) + { + oldoff = Doffset; + SegData[DATA]->SDbuf->reserve(len); + SegData[DATA]->SDbuf->writen(p,len); + Doffset += len; + *pseg = DATA; + } + else + { + oldoff = CDoffset; + SegData[CDATA]->SDbuf->reserve(len); + SegData[CDATA]->SDbuf->writen(p,len); + CDoffset += len; + *pseg = CDATA; + } + return oldoff; +} + +int elf_data_cdata(char *p, int len) +{ + int pseg; + + return elf_data_cdata(p, len, &pseg); +} + +/****************************** + * Perform initialization that applies to all .o output files. + * Called before any other obj_xxx routines + */ + +void obj_init(Outbuffer *objbuf, const char *filename, const char *csegname) +{ + //printf("obj_init()\n"); + cseg = CODE; + fobjbuf = objbuf; + + seg_tlsseg = UNKNOWN; + seg_tlsseg_bss = UNKNOWN; + GOTsym = NULL; + + // Initialize buffers + + if (symtab_strings) + symtab_strings->setsize(1); + else + { symtab_strings = new Outbuffer(1024); + symtab_strings->reserve(2048); + symtab_strings->writeByte(0); + } + + if (!local_symbuf) + local_symbuf = new Outbuffer(sizeof(symbol *) * SYM_TAB_INIT); + local_symbuf->setsize(0); + + if (!public_symbuf) + public_symbuf = new Outbuffer(sizeof(symbol *) * SYM_TAB_INIT); + public_symbuf->setsize(0); + + if (!extern_symbuf) + extern_symbuf = new Outbuffer(sizeof(symbol *) * SYM_TAB_INIT); + extern_symbuf->setsize(0); + + if (!comdef_symbuf) + comdef_symbuf = new Outbuffer(sizeof(symbol *) * SYM_TAB_INIT); + comdef_symbuf->setsize(0); + + extdef = 0; + + if (indirectsymbuf1) + indirectsymbuf1->setsize(0); + jumpTableSeg = 0; + + if (indirectsymbuf2) + indirectsymbuf2->setsize(0); + pointersSeg = 0; + + // Initialize segments for CODE, DATA, UDATA and CDATA + size_t struct_section_size = I64 ? sizeof(struct section_64) : sizeof(struct section); + if (SECbuf) + { + SECbuf->setsize(struct_section_size); + } + else + { + SECbuf = new Outbuffer(SYM_TAB_INC * struct_section_size); + SECbuf->reserve(SEC_TAB_INIT * struct_section_size); + // Ignore the first section - section numbers start at 1 + SECbuf->writezeros(struct_section_size); + } + section_cnt = 1; + + seg_count = 0; + int align = I64 ? 4 : 2; // align to 16 bytes for floating point + mach_getsegment("__text", "__TEXT", 2, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS); + mach_getsegment("__data", "__DATA", align, S_REGULAR); // DATA + mach_getsegment("__const", "__TEXT", 2, S_REGULAR); // CDATA + mach_getsegment("__bss", "__DATA", 4, S_ZEROFILL); // UDATA + + if (config.fulltypes) + dwarf_initfile(filename); +} + +/************************** + * Initialize the start of object output for this particular .o file. + * + * Input: + * filename: Name of source file + * csegname: User specified default code segment name + */ + +void obj_initfile(const char *filename, const char *csegname, const char *modname) +{ + //dbg_printf("obj_initfile(filename = %s, modname = %s)\n",filename,modname); +#if SCPP + if (csegname && *csegname && strcmp(csegname,".text")) + { // Define new section and make it the default for cseg segment + // NOTE: cseg is initialized to CODE + IDXSEC newsecidx; + Elf32_Shdr *newtextsec; + IDXSYM newsymidx; + assert(!I64); // fix later + SegData[cseg]->SDshtidx = newsecidx = + elf_newsection(csegname,0,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR); + newtextsec = &SecHdrTab[newsecidx]; + newtextsec->sh_addralign = 4; + SegData[cseg]->SDsymidx = + elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, newsecidx); + } +#endif + if (config.fulltypes) + dwarf_initmodule(filename, modname); +} + +/************************************ + * Patch pseg/offset by adding in the vmaddr difference from + * pseg/offset to start of seg. + */ + +int32_t *patchAddr(int seg, targ_size_t offset) +{ + return(int32_t *)(fobjbuf->buf + SecHdrTab[SegData[seg]->SDshtidx].offset + offset); +} + +int32_t *patchAddr64(int seg, targ_size_t offset) +{ + return(int32_t *)(fobjbuf->buf + SecHdrTab64[SegData[seg]->SDshtidx].offset + offset); +} + +void patch(seg_data *pseg, targ_size_t offset, int seg, targ_size_t value) +{ + //printf("patch(offset = x%04x, seg = %d, value = x%llx)\n", (unsigned)offset, seg, value); + if (I64) + { + int32_t *p = (int32_t *)(fobjbuf->buf + SecHdrTab64[pseg->SDshtidx].offset + offset); +#if 0 + printf("\taddr1 = x%llx\n\taddr2 = x%llx\n\t*p = x%llx\n\tdelta = x%llx\n", + SecHdrTab64[pseg->SDshtidx].addr, + SecHdrTab64[SegData[seg]->SDshtidx].addr, + *p, + SecHdrTab64[SegData[seg]->SDshtidx].addr - + (SecHdrTab64[pseg->SDshtidx].addr + offset)); +#endif + *p += SecHdrTab64[SegData[seg]->SDshtidx].addr - + (SecHdrTab64[pseg->SDshtidx].addr - value); + } + else + { + int32_t *p = (int32_t *)(fobjbuf->buf + SecHdrTab[pseg->SDshtidx].offset + offset); +#if 0 + printf("\taddr1 = x%x\n\taddr2 = x%x\n\t*p = x%x\n\tdelta = x%x\n", + SecHdrTab[pseg->SDshtidx].addr, + SecHdrTab[SegData[seg]->SDshtidx].addr, + *p, + SecHdrTab[SegData[seg]->SDshtidx].addr - + (SecHdrTab[pseg->SDshtidx].addr + offset)); +#endif + *p += SecHdrTab[SegData[seg]->SDshtidx].addr - + (SecHdrTab[pseg->SDshtidx].addr - value); + } +} + +/*************************** + * Number symbols so they are + * ordered as locals, public and then extern/comdef + */ + +void mach_numbersyms() +{ + //printf("mach_numbersyms()\n"); + int n = 0; + + int dim; + dim = local_symbuf->size() / sizeof(symbol *); + for (int i = 0; i < dim; i++) + { symbol *s = ((symbol **)local_symbuf->buf)[i]; + s->Sxtrnnum = n; + n++; + } + + dim = public_symbuf->size() / sizeof(symbol *); + for (int i = 0; i < dim; i++) + { symbol *s = ((symbol **)public_symbuf->buf)[i]; + s->Sxtrnnum = n; + n++; + } + + dim = extern_symbuf->size() / sizeof(symbol *); + for (int i = 0; i < dim; i++) + { symbol *s = ((symbol **)extern_symbuf->buf)[i]; + s->Sxtrnnum = n; + n++; + } + + dim = comdef_symbuf->size() / sizeof(Comdef); + for (int i = 0; i < dim; i++) + { Comdef *c = ((Comdef *)comdef_symbuf->buf) + i; + c->sym->Sxtrnnum = n; + n++; + } +} + + +/*************************** + * Fixup and terminate object file. + */ + +void obj_termfile() +{ + //dbg_printf("obj_termfile\n"); + if (configv.addlinenumbers) + { + dwarf_termmodule(); + } +} + +/********************************* + * Terminate package. + */ + +void obj_term() +{ + //printf("obj_term()\n"); +#if SCPP + if (!errcnt) +#endif + { + outfixlist(); // backpatches + } + + if (configv.addlinenumbers) + { + dwarf_termfile(); + } + +#if SCPP + if (errcnt) + return; +#endif + + /* Write out the object file in the following order: + * header + * commands + * segment_command + * { sections } + * symtab_command + * dysymtab_command + * { segment contents } + * { relocations } + * symbol table + * string table + * indirect symbol table + */ + + unsigned foffset; + unsigned headersize; + unsigned sizeofcmds; + + // Write out the bytes for the header + if (I64) + { + mach_header_64 header; + + header.magic = MH_MAGIC_64; + header.cputype = CPU_TYPE_X86_64; + header.cpusubtype = CPU_SUBTYPE_I386_ALL; + header.filetype = MH_OBJECT; + header.ncmds = 3; + header.sizeofcmds = sizeof(segment_command_64) + + (section_cnt - 1) * sizeof(struct section_64) + + sizeof(symtab_command) + + sizeof(dysymtab_command); + header.flags = MH_SUBSECTIONS_VIA_SYMBOLS; + header.reserved = 0; + fobjbuf->write(&header, sizeof(header)); + foffset = sizeof(header); // start after header + headersize = sizeof(header); + sizeofcmds = header.sizeofcmds; + + // Write the actual data later + fobjbuf->writezeros(header.sizeofcmds); + foffset += header.sizeofcmds; + } + else + { + mach_header header; + + header.magic = MH_MAGIC; + header.cputype = CPU_TYPE_I386; + header.cpusubtype = CPU_SUBTYPE_I386_ALL; + header.filetype = MH_OBJECT; + header.ncmds = 3; + header.sizeofcmds = sizeof(segment_command) + + (section_cnt - 1) * sizeof(struct section) + + sizeof(symtab_command) + + sizeof(dysymtab_command); + header.flags = MH_SUBSECTIONS_VIA_SYMBOLS; + fobjbuf->write(&header, sizeof(header)); + foffset = sizeof(header); // start after header + headersize = sizeof(header); + sizeofcmds = header.sizeofcmds; + + // Write the actual data later + fobjbuf->writezeros(header.sizeofcmds); + foffset += header.sizeofcmds; + } + + struct segment_command segment_cmd; + struct segment_command_64 segment_cmd64; + struct symtab_command symtab_cmd; + struct dysymtab_command dysymtab_cmd; + + memset(&segment_cmd, 0, sizeof(segment_cmd)); + memset(&segment_cmd64, 0, sizeof(segment_cmd64)); + memset(&symtab_cmd, 0, sizeof(symtab_cmd)); + memset(&dysymtab_cmd, 0, sizeof(dysymtab_cmd)); + + if (I64) + { + segment_cmd64.cmd = LC_SEGMENT_64; + segment_cmd64.cmdsize = sizeof(segment_cmd64) + + (section_cnt - 1) * sizeof(struct section_64); + segment_cmd64.nsects = section_cnt - 1; + segment_cmd64.maxprot = 7; + segment_cmd64.initprot = 7; + } + else + { + segment_cmd.cmd = LC_SEGMENT; + segment_cmd.cmdsize = sizeof(segment_cmd) + + (section_cnt - 1) * sizeof(struct section); + segment_cmd.nsects = section_cnt - 1; + segment_cmd.maxprot = 7; + segment_cmd.initprot = 7; + } + + symtab_cmd.cmd = LC_SYMTAB; + symtab_cmd.cmdsize = sizeof(symtab_cmd); + + dysymtab_cmd.cmd = LC_DYSYMTAB; + dysymtab_cmd.cmdsize = sizeof(dysymtab_cmd); + + /* If a __pointers section was emitted, need to set the .reserved1 + * field to the symbol index in the indirect symbol table of the + * start of the __pointers symbols. + */ + if (pointersSeg) + { + seg_data *pseg = SegData[pointersSeg]; + if (I64) + { + struct section_64 *psechdr = &SecHdrTab64[pseg->SDshtidx]; // corresponding section + psechdr->reserved1 = indirectsymbuf1 + ? indirectsymbuf1->size() / sizeof(Symbol *) + : 0; + } + else + { + struct section *psechdr = &SecHdrTab[pseg->SDshtidx]; // corresponding section + psechdr->reserved1 = indirectsymbuf1 + ? indirectsymbuf1->size() / sizeof(Symbol *) + : 0; + } + } + + // Walk through sections determining size and file offsets + + // + // First output individual section data associate with program + // code and data + // + foffset = elf_align(I64 ? 8 : 4, foffset); + if (I64) + segment_cmd64.fileoff = foffset; + else + segment_cmd.fileoff = foffset; + unsigned vmaddr = 0; + + //printf("Setup offsets and sizes foffset %d\n\tsection_cnt %d, seg_count %d\n",foffset,section_cnt,seg_count); + // Zero filled segments go at the end, so go through segments twice + for (int i = 0; i < 2; i++) + { + for (int seg = 1; seg <= seg_count; seg++) + { + seg_data *pseg = SegData[seg]; + if (I64) + { + struct section_64 *psechdr = &SecHdrTab64[pseg->SDshtidx]; // corresponding section + + // Do zero-fill the second time through this loop + if (i ^ (psechdr->flags == S_ZEROFILL)) + continue; + + int align = 1 << psechdr->align; + foffset = elf_align(align, foffset); + vmaddr = (vmaddr + align - 1) & ~(align - 1); + if (psechdr->flags == S_ZEROFILL) + { + psechdr->offset = 0; + psechdr->size = pseg->SDoffset; // accumulated size + } + else + { + psechdr->offset = foffset; + psechdr->size = 0; + //printf("\tsection name %s,", psechdr->sectname); + if (pseg->SDbuf && pseg->SDbuf->size()) + { + //printf("\tsize %d\n", pseg->SDbuf->size()); + psechdr->size = pseg->SDbuf->size(); + fobjbuf->write(pseg->SDbuf->buf, psechdr->size); + foffset += psechdr->size; + } + } + psechdr->addr = vmaddr; + vmaddr += psechdr->size; + //printf(" assigned offset %d, size %d\n", foffset, psechdr->sh_size); + } + else + { + struct section *psechdr = &SecHdrTab[pseg->SDshtidx]; // corresponding section + + // Do zero-fill the second time through this loop + if (i ^ (psechdr->flags == S_ZEROFILL)) + continue; + + int align = 1 << psechdr->align; + foffset = elf_align(align, foffset); + vmaddr = (vmaddr + align - 1) & ~(align - 1); + if (psechdr->flags == S_ZEROFILL) + { + psechdr->offset = 0; + psechdr->size = pseg->SDoffset; // accumulated size + } + else + { + psechdr->offset = foffset; + psechdr->size = 0; + //printf("\tsection name %s,", psechdr->sectname); + if (pseg->SDbuf && pseg->SDbuf->size()) + { + //printf("\tsize %d\n", pseg->SDbuf->size()); + psechdr->size = pseg->SDbuf->size(); + fobjbuf->write(pseg->SDbuf->buf, psechdr->size); + foffset += psechdr->size; + } + } + psechdr->addr = vmaddr; + vmaddr += psechdr->size; + //printf(" assigned offset %d, size %d\n", foffset, psechdr->sh_size); + } + } + } + + if (I64) + { + segment_cmd64.vmsize = vmaddr; + segment_cmd64.filesize = foffset - segment_cmd64.fileoff; + /* Bugzilla 5331: Apparently having the filesize field greater than the vmsize field is an + * error, and is happening sometimes. + */ + if (segment_cmd64.filesize > vmaddr) + segment_cmd64.vmsize = segment_cmd64.filesize; + } + else + { + segment_cmd.vmsize = vmaddr; + segment_cmd.filesize = foffset - segment_cmd.fileoff; + /* Bugzilla 5331: Apparently having the filesize field greater than the vmsize field is an + * error, and is happening sometimes. + */ + if (segment_cmd.filesize > vmaddr) + segment_cmd.vmsize = segment_cmd.filesize; + } + + // Put out relocation data + mach_numbersyms(); + for (int seg = 1; seg <= seg_count; seg++) + { + seg_data *pseg = SegData[seg]; + struct section *psechdr = NULL; + struct section_64 *psechdr64 = NULL; + if (I64) + { + psechdr64 = &SecHdrTab64[pseg->SDshtidx]; // corresponding section + //printf("psechdr->addr = x%llx\n", psechdr64->addr); + } + else + { + psechdr = &SecHdrTab[pseg->SDshtidx]; // corresponding section + //printf("psechdr->addr = x%x\n", psechdr->addr); + } + foffset = elf_align(I64 ? 8 : 4, foffset); + unsigned reloff = foffset; + unsigned nreloc = 0; + if (pseg->SDrel) + { Relocation *r = (Relocation *)pseg->SDrel->buf; + Relocation *rend = (Relocation *)(pseg->SDrel->buf + pseg->SDrel->size()); + for (; r != rend; r++) + { symbol *s = r->targsym; + const char *rs = r->rtype == RELaddr ? "addr" : "rel"; + //printf("%d:x%04llx : tseg %d tsym %s REL%s\n", seg, r->offset, r->targseg, s ? s->Sident : "0", rs); + relocation_info rel; + scattered_relocation_info srel; + if (s) + { + //printf("Relocation\n"); + //symbol_print(s); + if (pseg->isCode()) + { + if (I64) + { + rel.r_type = (r->rtype == RELrel) + ? X86_64_RELOC_BRANCH + : X86_64_RELOC_SIGNED; + if (r->val == -1) + rel.r_type = X86_64_RELOC_SIGNED_1; + else if (r->val == -2) + rel.r_type = X86_64_RELOC_SIGNED_2; + if (r->val == -4) + rel.r_type = X86_64_RELOC_SIGNED_4; + + if (s->Sclass == SCextern || + s->Sclass == SCcomdef || + s->Sclass == SCcomdat || + s->Sclass == SCglobal) + { + if ((s->Sfl == FLfunc || s->Sfl == FLextern || s->Sclass == SCglobal || s->Sclass == SCcomdat || s->Sclass == SCcomdef) && r->rtype == RELaddr) + rel.r_type = X86_64_RELOC_GOT_LOAD; + rel.r_address = r->offset; + rel.r_symbolnum = s->Sxtrnnum; + rel.r_pcrel = 1; + rel.r_length = 2; + rel.r_extern = 1; + fobjbuf->write(&rel, sizeof(rel)); + foffset += sizeof(rel); + nreloc++; + continue; + } + else + { + rel.r_address = r->offset; + rel.r_symbolnum = s->Sseg; + rel.r_pcrel = 1; + rel.r_length = 2; + rel.r_extern = 0; + fobjbuf->write(&rel, sizeof(rel)); + foffset += sizeof(rel); + nreloc++; + + int32_t *p = patchAddr64(seg, r->offset); + // Absolute address; add in addr of start of targ seg +//printf("*p = x%x, .addr = x%x, Soffset = x%x\n", *p, (int)SecHdrTab64[SegData[s->Sseg]->SDshtidx].addr, (int)s->Soffset); +//printf("pseg = x%x, r->offset = x%x\n", (int)SecHdrTab64[pseg->SDshtidx].addr, (int)r->offset); + *p += SecHdrTab64[SegData[s->Sseg]->SDshtidx].addr; + *p += s->Soffset; + *p -= SecHdrTab64[pseg->SDshtidx].addr + r->offset + 4; + //patch(pseg, r->offset, s->Sseg, s->Soffset); + continue; + } + } + } + else + { + if (s->Sclass == SCextern || + s->Sclass == SCcomdef || + s->Sclass == SCcomdat) + { + rel.r_address = r->offset; + rel.r_symbolnum = s->Sxtrnnum; + rel.r_pcrel = 0; + rel.r_length = 2; + rel.r_extern = 1; + rel.r_type = GENERIC_RELOC_VANILLA; + if (I64) + { + rel.r_type = X86_64_RELOC_UNSIGNED; + rel.r_length = 3; + } + fobjbuf->write(&rel, sizeof(rel)); + foffset += sizeof(rel); + nreloc++; + continue; + } + else + { + rel.r_address = r->offset; + rel.r_symbolnum = s->Sseg; + rel.r_pcrel = 0; + rel.r_length = 2; + rel.r_extern = 0; + rel.r_type = GENERIC_RELOC_VANILLA; + if (I64) + { + rel.r_type = X86_64_RELOC_UNSIGNED; + rel.r_length = 3; + if (0 && s->Sseg != seg) + rel.r_type = X86_64_RELOC_BRANCH; + } + fobjbuf->write(&rel, sizeof(rel)); + foffset += sizeof(rel); + nreloc++; + if (I64) + { + rel.r_length = 3; + int32_t *p = patchAddr64(seg, r->offset); + // Absolute address; add in addr of start of targ seg + *p += SecHdrTab64[SegData[s->Sseg]->SDshtidx].addr + s->Soffset; + //patch(pseg, r->offset, s->Sseg, s->Soffset); + } + else + { + int32_t *p = patchAddr(seg, r->offset); + // Absolute address; add in addr of start of targ seg + *p += SecHdrTab[SegData[s->Sseg]->SDshtidx].addr + s->Soffset; + //patch(pseg, r->offset, s->Sseg, s->Soffset); + } + continue; + } + } + } + else if (r->rtype == RELaddr && pseg->isCode()) + { + int32_t *p = NULL; + int32_t *p64 = NULL; + if (I64) + p64 = patchAddr64(seg, r->offset); + else + p = patchAddr(seg, r->offset); + srel.r_scattered = 1; + + srel.r_address = r->offset; + srel.r_length = 2; + if (I64) + { + srel.r_type = X86_64_RELOC_GOT; + srel.r_value = SecHdrTab64[SegData[r->targseg]->SDshtidx].addr + *p64; + //printf("SECTDIFF: x%llx + x%llx = x%x\n", SecHdrTab[SegData[r->targseg]->SDshtidx].addr, *p, srel.r_value); + } + else + { + srel.r_type = GENERIC_RELOC_LOCAL_SECTDIFF; + srel.r_value = SecHdrTab[SegData[r->targseg]->SDshtidx].addr + *p; + //printf("SECTDIFF: x%x + x%x = x%x\n", SecHdrTab[SegData[r->targseg]->SDshtidx].addr, *p, srel.r_value); + } + srel.r_pcrel = 0; + fobjbuf->write(&srel, sizeof(srel)); + foffset += sizeof(srel); + nreloc++; + + srel.r_address = 0; + srel.r_type = GENERIC_RELOC_PAIR; + srel.r_length = 2; + if (I64) + srel.r_value = SecHdrTab64[pseg->SDshtidx].addr + + r->funcsym->Slocalgotoffset + NPTRSIZE; + else + srel.r_value = SecHdrTab[pseg->SDshtidx].addr + + r->funcsym->Slocalgotoffset + NPTRSIZE; + srel.r_pcrel = 0; + fobjbuf->write(&srel, sizeof(srel)); + foffset += sizeof(srel); + nreloc++; + + // Recalc due to possible realloc of fobjbuf->buf + if (I64) + { + p64 = patchAddr64(seg, r->offset); + //printf("address = x%x, p64 = %p *p64 = x%llx\n", r->offset, p64, *p64); + *p64 += SecHdrTab64[SegData[r->targseg]->SDshtidx].addr - + (SecHdrTab64[pseg->SDshtidx].addr + r->funcsym->Slocalgotoffset + NPTRSIZE); + } + else + { + p = patchAddr(seg, r->offset); + //printf("address = x%x, p = %p *p = x%x\n", r->offset, p, *p); + *p += SecHdrTab[SegData[r->targseg]->SDshtidx].addr - + (SecHdrTab[pseg->SDshtidx].addr + r->funcsym->Slocalgotoffset + NPTRSIZE); + } + continue; + } + else + { + rel.r_address = r->offset; + rel.r_symbolnum = r->targseg; + rel.r_pcrel = (r->rtype == RELaddr) ? 0 : 1; + rel.r_length = 2; + rel.r_extern = 0; + rel.r_type = GENERIC_RELOC_VANILLA; + if (I64) + { + rel.r_type = X86_64_RELOC_UNSIGNED; + rel.r_length = 3; + if (0 && r->targseg != seg) + rel.r_type = X86_64_RELOC_BRANCH; + } + fobjbuf->write(&rel, sizeof(rel)); + foffset += sizeof(rel); + nreloc++; + if (I64) + { + int32_t *p64 = patchAddr64(seg, r->offset); + //int64_t before = *p64; + if (rel.r_pcrel) + // Relative address + patch(pseg, r->offset, r->targseg, 0); + else + { // Absolute address; add in addr of start of targ seg +//printf("*p = x%x, targ.addr = x%x\n", *p64, (int)SecHdrTab64[SegData[r->targseg]->SDshtidx].addr); +//printf("pseg = x%x, r->offset = x%x\n", (int)SecHdrTab64[pseg->SDshtidx].addr, (int)r->offset); + *p64 += SecHdrTab64[SegData[r->targseg]->SDshtidx].addr; + //*p64 -= SecHdrTab64[pseg->SDshtidx].addr; + } + //printf("%d:x%04x before = x%04llx, after = x%04llx pcrel = %d\n", seg, r->offset, before, *p64, rel.r_pcrel); + } + else + { + int32_t *p = patchAddr(seg, r->offset); + //int32_t before = *p; + if (rel.r_pcrel) + // Relative address + patch(pseg, r->offset, r->targseg, 0); + else + // Absolute address; add in addr of start of targ seg + *p += SecHdrTab[SegData[r->targseg]->SDshtidx].addr; + //printf("%d:x%04x before = x%04x, after = x%04x pcrel = %d\n", seg, r->offset, before, *p, rel.r_pcrel); + } + continue; + } + } + } + if (nreloc) + { + if (I64) + { + psechdr64->reloff = reloff; + psechdr64->nreloc = nreloc; + } + else + { + psechdr->reloff = reloff; + psechdr->nreloc = nreloc; + } + } + } + + // Put out symbol table + foffset = elf_align(I64 ? 8 : 4, foffset); + symtab_cmd.symoff = foffset; + dysymtab_cmd.ilocalsym = 0; + dysymtab_cmd.nlocalsym = local_symbuf->size() / sizeof(symbol *); + dysymtab_cmd.iextdefsym = dysymtab_cmd.nlocalsym; + dysymtab_cmd.nextdefsym = public_symbuf->size() / sizeof(symbol *); + dysymtab_cmd.iundefsym = dysymtab_cmd.iextdefsym + dysymtab_cmd.nextdefsym; + int nexterns = extern_symbuf->size() / sizeof(symbol *); + int ncomdefs = comdef_symbuf->size() / sizeof(Comdef); + dysymtab_cmd.nundefsym = nexterns + ncomdefs; + symtab_cmd.nsyms = dysymtab_cmd.nlocalsym + + dysymtab_cmd.nextdefsym + + dysymtab_cmd.nundefsym; + fobjbuf->reserve(symtab_cmd.nsyms * (I64 ? sizeof(struct nlist_64) : sizeof(struct nlist))); + for (int i = 0; i < dysymtab_cmd.nlocalsym; i++) + { symbol *s = ((symbol **)local_symbuf->buf)[i]; + struct nlist_64 sym; + sym.n_un.n_strx = elf_addmangled(s); + sym.n_type = N_SECT; + sym.n_desc = 0; + if (s->Sclass == SCcomdat) + sym.n_desc = N_WEAK_DEF; + sym.n_sect = s->Sseg; + if (I64) + { + sym.n_value = s->Soffset + SecHdrTab64[SegData[s->Sseg]->SDshtidx].addr; + fobjbuf->write(&sym, sizeof(sym)); + } + else + { + struct nlist sym32; + sym32.n_un.n_strx = sym.n_un.n_strx; + sym32.n_value = s->Soffset + SecHdrTab[SegData[s->Sseg]->SDshtidx].addr; + sym32.n_type = sym.n_type; + sym32.n_desc = sym.n_desc; + sym32.n_sect = sym.n_sect; + fobjbuf->write(&sym32, sizeof(sym32)); + } + } + for (int i = 0; i < dysymtab_cmd.nextdefsym; i++) + { symbol *s = ((symbol **)public_symbuf->buf)[i]; + + //printf("Writing public symbol %d:x%x %s\n", s->Sseg, s->Soffset, s->Sident); + struct nlist_64 sym; + sym.n_un.n_strx = elf_addmangled(s); + sym.n_type = N_EXT | N_SECT; + sym.n_desc = 0; + if (s->Sclass == SCcomdat) + sym.n_desc = N_WEAK_DEF; + sym.n_sect = s->Sseg; + if (I64) + { + sym.n_value = s->Soffset + SecHdrTab64[SegData[s->Sseg]->SDshtidx].addr; + fobjbuf->write(&sym, sizeof(sym)); + } + else + { + struct nlist sym32; + sym32.n_un.n_strx = sym.n_un.n_strx; + sym32.n_value = s->Soffset + SecHdrTab[SegData[s->Sseg]->SDshtidx].addr; + sym32.n_type = sym.n_type; + sym32.n_desc = sym.n_desc; + sym32.n_sect = sym.n_sect; + fobjbuf->write(&sym32, sizeof(sym32)); + } + } + for (int i = 0; i < nexterns; i++) + { symbol *s = ((symbol **)extern_symbuf->buf)[i]; + struct nlist_64 sym; + sym.n_un.n_strx = elf_addmangled(s); + sym.n_value = s->Soffset; + sym.n_type = N_EXT | N_UNDF; + sym.n_desc = tyfunc(s->ty()) ? REFERENCE_FLAG_UNDEFINED_LAZY + : REFERENCE_FLAG_UNDEFINED_NON_LAZY; + sym.n_sect = 0; + if (I64) + fobjbuf->write(&sym, sizeof(sym)); + else + { + struct nlist sym32; + sym32.n_un.n_strx = sym.n_un.n_strx; + sym32.n_value = sym.n_value; + sym32.n_type = sym.n_type; + sym32.n_desc = sym.n_desc; + sym32.n_sect = sym.n_sect; + fobjbuf->write(&sym32, sizeof(sym32)); + } + } + for (int i = 0; i < ncomdefs; i++) + { Comdef *c = ((Comdef *)comdef_symbuf->buf) + i; + struct nlist_64 sym; + sym.n_un.n_strx = elf_addmangled(c->sym); + sym.n_value = c->size * c->count; + sym.n_type = N_EXT | N_UNDF; + int align; + if (c->size < 2) + align = 0; // align is expressed as power of 2 + else if (c->size < 4) + align = 1; + else if (c->size < 8) + align = 2; + else if (c->size < 16) + align = 3; + else + align = 4; + sym.n_desc = align << 8; + sym.n_sect = 0; + if (I64) + fobjbuf->write(&sym, sizeof(sym)); + else + { + struct nlist sym32; + sym32.n_un.n_strx = sym.n_un.n_strx; + sym32.n_value = sym.n_value; + sym32.n_type = sym.n_type; + sym32.n_desc = sym.n_desc; + sym32.n_sect = sym.n_sect; + fobjbuf->write(&sym32, sizeof(sym32)); + } + } + if (extdef) + { + struct nlist_64 sym; + sym.n_un.n_strx = extdef; + sym.n_value = 0; + sym.n_type = N_EXT | N_UNDF; + sym.n_desc = 0; + sym.n_sect = 0; + if (I64) + fobjbuf->write(&sym, sizeof(sym)); + else + { + struct nlist sym32; + sym32.n_un.n_strx = sym.n_un.n_strx; + sym32.n_value = sym.n_value; + sym32.n_type = sym.n_type; + sym32.n_desc = sym.n_desc; + sym32.n_sect = sym.n_sect; + fobjbuf->write(&sym32, sizeof(sym32)); + } + symtab_cmd.nsyms++; + } + foffset += symtab_cmd.nsyms * (I64 ? sizeof(struct nlist_64) : sizeof(struct nlist)); + + // Put out string table + foffset = elf_align(I64 ? 8 : 4, foffset); + symtab_cmd.stroff = foffset; + symtab_cmd.strsize = symtab_strings->size(); + fobjbuf->write(symtab_strings->buf, symtab_cmd.strsize); + foffset += symtab_cmd.strsize; + + // Put out indirectsym table, which is in two parts + foffset = elf_align(I64 ? 8 : 4, foffset); + dysymtab_cmd.indirectsymoff = foffset; + if (indirectsymbuf1) + { dysymtab_cmd.nindirectsyms += indirectsymbuf1->size() / sizeof(Symbol *); + for (int i = 0; i < dysymtab_cmd.nindirectsyms; i++) + { Symbol *s = ((Symbol **)indirectsymbuf1->buf)[i]; + fobjbuf->write32(s->Sxtrnnum); + } + } + if (indirectsymbuf2) + { int n = indirectsymbuf2->size() / sizeof(Symbol *); + dysymtab_cmd.nindirectsyms += n; + for (int i = 0; i < n; i++) + { Symbol *s = ((Symbol **)indirectsymbuf2->buf)[i]; + fobjbuf->write32(s->Sxtrnnum); + } + } + foffset += dysymtab_cmd.nindirectsyms * 4; + + /* The correct offsets are now determined, so + * rewind and fix the header. + */ + fobjbuf->position(headersize, sizeofcmds); + if (I64) + { + fobjbuf->write(&segment_cmd64, sizeof(segment_cmd64)); + fobjbuf->write(SECbuf->buf + sizeof(struct section_64), (section_cnt - 1) * sizeof(struct section_64)); + } + else + { + fobjbuf->write(&segment_cmd, sizeof(segment_cmd)); + fobjbuf->write(SECbuf->buf + sizeof(struct section), (section_cnt - 1) * sizeof(struct section)); + } + fobjbuf->write(&symtab_cmd, sizeof(symtab_cmd)); + fobjbuf->write(&dysymtab_cmd, sizeof(dysymtab_cmd)); + fobjbuf->position(foffset, 0); + fobjbuf->flush(); +} + +/***************************** + * Line number support. + */ + +/*************************** + * Record file and line number at segment and offset. + * The actual .debug_line segment is put out by dwarf_termfile(). + * Input: + * cseg current code segment + */ + +void objlinnum(Srcpos srcpos, targ_size_t offset) +{ + if (srcpos.Slinnum == 0) + return; + +#if 0 +#if MARS || SCPP + printf("objlinnum(cseg=%d, offset=x%lx) ", cseg, offset); +#endif + srcpos.print(""); +#endif + +#if MARS + if (!srcpos.Sfilename) + return; +#endif +#if SCPP + if (!srcpos.Sfilptr) + return; + sfile_debug(&srcpos_sfile(srcpos)); + Sfile *sf = *srcpos.Sfilptr; +#endif + + size_t i; + seg_data *seg = SegData[cseg]; + + // Find entry i in SDlinnum_data[] that corresponds to srcpos filename + for (i = 0; 1; i++) + { + if (i == seg->SDlinnum_count) + { // Create new entry + if (seg->SDlinnum_count == seg->SDlinnum_max) + { // Enlarge array + unsigned newmax = seg->SDlinnum_max * 2 + 1; + //printf("realloc %d\n", newmax * sizeof(linnum_data)); + seg->SDlinnum_data = (linnum_data *)mem_realloc( + seg->SDlinnum_data, newmax * sizeof(linnum_data)); + memset(seg->SDlinnum_data + seg->SDlinnum_max, 0, + (newmax - seg->SDlinnum_max) * sizeof(linnum_data)); + seg->SDlinnum_max = newmax; + } + seg->SDlinnum_count++; +#if MARS + seg->SDlinnum_data[i].filename = srcpos.Sfilename; +#endif +#if SCPP + seg->SDlinnum_data[i].filptr = sf; +#endif + break; + } +#if MARS + if (seg->SDlinnum_data[i].filename == srcpos.Sfilename) +#endif +#if SCPP + if (seg->SDlinnum_data[i].filptr == sf) +#endif + break; + } + + linnum_data *ld = &seg->SDlinnum_data[i]; +// printf("i = %d, ld = x%x\n", i, ld); + if (ld->linoff_count == ld->linoff_max) + { + if (!ld->linoff_max) + ld->linoff_max = 8; + ld->linoff_max *= 2; + ld->linoff = (unsigned (*)[2])mem_realloc(ld->linoff, ld->linoff_max * sizeof(unsigned) * 2); + } + ld->linoff[ld->linoff_count][0] = srcpos.Slinnum; + ld->linoff[ld->linoff_count][1] = offset; + ld->linoff_count++; +} + + +/******************************* + * Set start address + */ + +void obj_startaddress(Symbol *s) +{ + //dbg_printf("obj_startaddress(Symbol *%s)\n",s->Sident); + //obj.startaddress = s; +} + +/******************************* + * Output library name. + * Output: + */ + +void obj_includelib(const char *name) +{ + //dbg_printf("obj_includelib(name *%s)\n",name); +} + +/************************** + * Embed string in executable. + */ + +void obj_exestr(const char *p) +{ + //dbg_printf("obj_exestr(char *%s)\n",p); +} + +/************************** + * Embed string in obj. + */ + +void obj_user(const char *p) +{ + //dbg_printf("obj_user(char *%s)\n",p); +} + +/******************************* + * Output a weak extern record. + */ + +void obj_wkext(Symbol *s1,Symbol *s2) +{ + //dbg_printf("obj_wkext(Symbol *%s,Symbol *s2)\n",s1->Sident,s2->Sident); +} + +/******************************* + * Output file name record. + * + * Currently assumes that obj_filename will not be called + * twice for the same file. + */ + +void obj_filename(const char *modname) +{ + //dbg_printf("obj_filename(char *%s)\n",modname); + // Not supported by Mach-O +} + +/******************************* + * Embed compiler version in .obj file. + */ + +void obj_compiler() +{ + //dbg_printf("obj_compiler\n"); +} + +//#if NEWSTATICDTOR + +/************************************** + * Symbol is the function that calls the static constructors. + * Put a pointer to it into a special segment that the startup code + * looks at. + * Input: + * s static constructor function + * dtor !=0 if leave space for static destructor + * seg 1: user + * 2: lib + * 3: compiler + */ + +void obj_staticctor(Symbol *s,int dtor,int none) +{ +#if 0 + IDXSEC seg; + Outbuffer *buf; + + //dbg_printf("obj_staticctor(%s) offset %x\n",s->Sident,s->Soffset); + //symbol_print(s); + s->Sseg = seg = + elf_getsegment(".ctors", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE, 4); + buf = SegData[seg]->SDbuf; + if (I64) + buf->write64(s->Soffset); + else + buf->write32(s->Soffset); + mach_addrel(seg, SegData[seg]->SDoffset, s, RELaddr); + SegData[seg]->SDoffset = buf->size(); +#endif +} + +/************************************** + * Symbol is the function that calls the static destructors. + * Put a pointer to it into a special segment that the exit code + * looks at. + * Input: + * s static destructor function + */ + +void obj_staticdtor(Symbol *s) +{ +#if 0 + IDXSEC seg; + Outbuffer *buf; + + //dbg_printf("obj_staticdtor(%s) offset %x\n",s->Sident,s->Soffset); + //symbol_print(s); + seg = elf_getsegment(".dtors", NULL, SHT_PROGDEF, SHF_ALLOC|SHF_WRITE, 4); + buf = SegData[seg]->SDbuf; + if (I64) + buf->write64(s->Soffset); + else + buf->write32(s->Soffset); + mach_addrel(seg, SegData[seg]->SDoffset, s, RELaddr); + SegData[seg]->SDoffset = buf->size(); +#endif +} + +//#else + +/*************************************** + * Stuff pointer to function in its own segment. + * Used for static ctor and dtor lists. + */ + +void obj_funcptr(Symbol *s) +{ + //dbg_printf("obj_funcptr(%s) \n",s->Sident); +} + +//#endif + +/*************************************** + * Stuff the following data (instance of struct FuncTable) in a separate segment: + * pointer to function + * pointer to ehsym + * length of function + */ + +void obj_ehtables(Symbol *sfunc,targ_size_t size,Symbol *ehsym) +{ + //dbg_printf("obj_ehtables(%s) \n",sfunc->Sident); + + /* BUG: this should go into a COMDAT if sfunc is in a COMDAT + * otherwise the duplicates aren't removed. + */ + + int align = I64 ? 3 : 2; // align to NPTRSIZE + // The size is sizeof(struct FuncTable) in deh2.d + mach_getsegment("__deh_beg", "__DATA", align, S_COALESCED, 3 * NPTRSIZE); + int seg = mach_getsegment("__deh_eh", "__DATA", align, S_REGULAR); + mach_getsegment("__deh_end", "__DATA", align, S_COALESCED, NPTRSIZE); + + Outbuffer *buf = SegData[seg]->SDbuf; + if (I64) + { reftoident(seg, buf->size(), sfunc, 0, CFoff | CFoffset64); + reftoident(seg, buf->size(), ehsym, 0, CFoff | CFoffset64); + buf->write64(sfunc->Ssize); + } + else + { reftoident(seg, buf->size(), sfunc, 0, CFoff); + reftoident(seg, buf->size(), ehsym, 0, CFoff); + buf->write32(sfunc->Ssize); + } +} + +/********************************************* + * Put out symbols that define the beginning/end of the .deh_eh section. + * This gets called if this is the module with "main()" in it. + */ + +void obj_ehsections() +{ + //printf("obj_ehsections()\n"); +#if 0 + /* Determine Mac OSX version, and put out the sections slightly differently for each. + * This is needed because the linker on OSX 10.5 behaves differently than + * the linker on 10.6. + * See Bugzilla 3502 for more information. + */ + static SInt32 MacVersion; + if (!MacVersion) + Gestalt(gestaltSystemVersion, &MacVersion); + + /* Exception handling sections + */ + // 12 is size of struct FuncTable in D runtime + mach_getsegment("__deh_beg", "__DATA", 2, S_COALESCED, 12); + int seg = mach_getsegment("__deh_eh", "__DATA", 2, S_REGULAR); + Outbuffer *buf = SegData[seg]->SDbuf; + buf->writezeros(12); // 12 is size of struct FuncTable in D runtime, + // this entry gets skipped over by __eh_finddata() + + mach_getsegment("__deh_end", "__DATA", 2, S_COALESCED, 4); + + /* Thread local storage sections + */ + mach_getsegment("__tls_beg", "__DATA", 2, S_COALESCED, 4); + mach_getsegment("__tls_data", "__DATA", 2, S_REGULAR, 4); + mach_getsegment("__tlscoal_nt", "__DATA", 4, S_COALESCED, 4); + mach_getsegment("__tls_end", "__DATA", 2, S_COALESCED, 4); + + /* Module info sections + */ + mach_getsegment("__minfo_beg", "__DATA", 2, S_COALESCED, 4); + mach_getsegment("__minfodata", "__DATA", 2, S_REGULAR, 4); + mach_getsegment("__minfo_end", "__DATA", 2, S_COALESCED, 4); +#endif +} + +/********************************* + * Setup for Symbol s to go into a COMDAT segment. + * Output (if s is a function): + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * "segment index" of COMDAT + */ + +int obj_comdat(Symbol *s) +{ + const char *sectname; + const char *segname; + int align; + int flags; + + //printf("obj_comdat(Symbol* %s)\n",s->Sident); + //symbol_print(s); + symbol_debug(s); + + if (tyfunc(s->ty())) + { + sectname = "__textcoal_nt"; + segname = "__TEXT"; + align = 2; // 4 byte alignment + flags = S_COALESCED | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS; + s->Sseg = mach_getsegment(sectname, segname, align, flags); + } + else if ((s->ty() & mTYLINK) == mTYthread) + { + s->Sfl = FLtlsdata; + align = I64 ? 4 : 2; // align to 16 bytes for floating point + mach_getsegment("__tls_beg", "__DATA", align, S_COALESCED, 4); + mach_getsegment("__tls_data", "__DATA", align, S_REGULAR, 4); + s->Sseg = mach_getsegment("__tlscoal_nt", "__DATA", 4, S_COALESCED); + mach_getsegment("__tls_end", "__DATA", align, S_COALESCED, 4); + elf_data_start(s, 1 << align, s->Sseg); + } + else + { + s->Sfl = FLdata; + sectname = "__datacoal_nt"; + segname = "__DATA"; + align = 4; // 16 byte alignment + flags = S_COALESCED; + s->Sseg = mach_getsegment(sectname, segname, align, flags); + } + // find or create new segment + s->Soffset = SegData[s->Sseg]->SDoffset; + if (s->Sfl == FLdata || s->Sfl == FLtlsdata) + { // Code symbols are 'published' by elf_func_start() + + objpubdef(s->Sseg,s,s->Soffset); + searchfixlist(s); // backpatch any refs to this symbol + } + return s->Sseg; +} + +/********************************** + * Get segment. + * Input: + * flags2 put out some data for this, so the linker will keep things in order + * align segment alignment as power of 2 + * Returns: + * segment index of found or newly created segment + */ + +int mach_getsegment(const char *sectname, const char *segname, + int align, int flags, int flags2) +{ + assert(strlen(sectname) <= 16); + assert(strlen(segname) <= 16); + for (int seg = 1; seg <= seg_count; seg++) + { seg_data *pseg = SegData[seg]; + if (I64) + { + if (strncmp(SecHdrTab64[pseg->SDshtidx].sectname, sectname, 16) == 0 && + strncmp(SecHdrTab64[pseg->SDshtidx].segname, segname, 16) == 0) + return seg; // return existing segment + } + else + { + if (strncmp(SecHdrTab[pseg->SDshtidx].sectname, sectname, 16) == 0 && + strncmp(SecHdrTab[pseg->SDshtidx].segname, segname, 16) == 0) + return seg; // return existing segment + } + } + + int seg = ++seg_count; + if (seg_count >= seg_max) + { // need more room in segment table + seg_max += 10; + SegData = (seg_data **)mem_realloc(SegData,seg_max * sizeof(seg_data *)); + memset(&SegData[seg_count], 0, (seg_max - seg_count) * sizeof(seg_data *)); + } + assert(seg_count < seg_max); + if (SegData[seg]) + { seg_data *pseg = SegData[seg]; + Outbuffer *b1 = pseg->SDbuf; + Outbuffer *b2 = pseg->SDrel; + memset(pseg, 0, sizeof(seg_data)); + if (b1) + b1->setsize(0); + if (b2) + b2->setsize(0); + pseg->SDbuf = b1; + pseg->SDrel = b2; + } + else + { + seg_data *pseg = (seg_data *)mem_calloc(sizeof(seg_data)); + SegData[seg] = pseg; + if (flags != S_ZEROFILL) + { pseg->SDbuf = new Outbuffer(4096); + pseg->SDbuf->reserve(4096); + } + } + + //dbg_printf("\tNew segment - %d size %d\n", seg,SegData[seg]->SDbuf); + seg_data *pseg = SegData[seg]; + + pseg->SDseg = seg; + pseg->SDoffset = 0; + + if (I64) + { + struct section_64 *sec = (struct section_64 *) + SECbuf->writezeros(sizeof(struct section_64)); + strncpy(sec->sectname, sectname, 16); + strncpy(sec->segname, segname, 16); + sec->align = align; + sec->flags = flags; + } + else + { + struct section *sec = (struct section *) + SECbuf->writezeros(sizeof(struct section)); + strncpy(sec->sectname, sectname, 16); + strncpy(sec->segname, segname, 16); + sec->align = align; + sec->flags = flags; + } + + pseg->SDshtidx = section_cnt++; + pseg->SDaranges_offset = 0; + pseg->SDlinnum_count = 0; + + if (flags2) + { + /* If we don't write something to each seg, then the linker won't put + * them in this necessary order. In fact, it will ignore the segment entirely. + */ + static SInt32 MacVersion; + if (!MacVersion) + Gestalt(gestaltSystemVersion, &MacVersion); + + if (flags == S_COALESCED) + { type *t = type_fake(TYint); + t->Tmangle = mTYman_c; + symbol *s_deh_beg = symbol_name(sectname + 1, SCcomdat, t); + objpubdef(seg, s_deh_beg, 0); + } + if (MacVersion >= MacOSX_10_6) + obj_bytes(seg, 0, flags2, NULL); // 12 is size of struct FuncTable in D runtime + } + + //printf("seg_count = %d\n", seg_count); + return seg; +} + +/******************************** + * Define a new code segment. + * Input: + * name name of segment, if NULL then revert to default + * suffix 0 use name as is + * 1 append "_TEXT" to name + * Output: + * cseg segment index of new current code segment + * Coffset starting offset in cseg + * Returns: + * segment index of newly created code segment + */ + +int obj_codeseg(char *name,int suffix) +{ + //dbg_printf("obj_codeseg(%s,%x)\n",name,suffix); +#if 0 + const char *sfx = (suffix) ? "_TEXT" : NULL; + + if (!name) // returning to default code segment + { + if (cseg != CODE) // not the current default + { + SegData[cseg]->SDoffset = Coffset; + Coffset = SegData[CODE]->SDoffset; + cseg = CODE; + } + return cseg; + } + + int seg = elf_getsegment(name, sfx, SHT_PROGDEF, SHF_ALLOC|SHF_EXECINSTR, 4); + // find or create code segment + + cseg = seg; // new code segment index + Coffset = 0; + return seg; +#else + return 0; +#endif +} + +/********************************* + * Define segments for Thread Local Storage. + * Output: + * seg_tlsseg set to segment number for TLS segment. + * Returns: + * segment for TLS segment + */ + +seg_data *obj_tlsseg() +{ + //printf("obj_tlsseg(\n"); + + if (seg_tlsseg == UNKNOWN) + { + int align = I64 ? 4 : 2; // align to 16 bytes for floating point + mach_getsegment("__tls_beg", "__DATA", align, S_COALESCED, 4); + seg_tlsseg = mach_getsegment("__tls_data", "__DATA", align, S_REGULAR); + mach_getsegment("__tlscoal_nt", "__DATA", 4, S_COALESCED, 4); + mach_getsegment("__tls_end", "__DATA", align, S_COALESCED, 4); + } + return SegData[seg_tlsseg]; +} + + +/********************************* + * Define segments for Thread Local Storage. + * Output: + * seg_tlsseg_bss set to segment number for TLS segment. + * Returns: + * segment for TLS segment + */ + +seg_data *obj_tlsseg_bss() +{ + /* Because Mach-O does not support tls, it's easier to support + * if we have all the tls in one segment. + */ + return obj_tlsseg(); +} + + +/******************************* + * Output an alias definition record. + */ + +void obj_alias(const char *n1,const char *n2) +{ + //printf("obj_alias(%s,%s)\n",n1,n2); + assert(0); +#if NOT_DONE + unsigned len; + char *buffer; + + buffer = (char *) alloca(strlen(n1) + strlen(n2) + 2 * ONS_OHD); + len = obj_namestring(buffer,n1); + len += obj_namestring(buffer + len,n2); + objrecord(ALIAS,buffer,len); +#endif +} + +char *unsstr (unsigned value) +{ + static char buffer [64]; + + sprintf (buffer, "%d", value); + return buffer; +} + +/******************************* + * Mangle a name. + * Returns: + * mangled name + */ + +char *obj_mangle2(Symbol *s,char *dest) +{ + size_t len; + char *name; + + //printf("obj_mangle(s = %p, '%s'), mangle = x%x\n",s,s->Sident,type_mangle(s->Stype)); + symbol_debug(s); + assert(dest); +#if SCPP + name = CPP ? cpp_mangle(s) : s->Sident; +#elif MARS + name = cpp_mangle(s); +#else + name = s->Sident; +#endif + len = strlen(name); // # of bytes in name + //dbg_printf("len %d\n",len); + switch (type_mangle(s->Stype)) + { + case mTYman_pas: // if upper case + case mTYman_for: + if (len >= DEST_LEN) + dest = (char *)mem_malloc(len + 1); + memcpy(dest,name,len + 1); // copy in name and ending 0 + strupr(dest); // to upper case + break; + case mTYman_std: +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (tyfunc(s->ty()) && !variadic(s->Stype)) +#else + if (!(config.flags4 & CFG4oldstdmangle) && + config.exe == EX_NT && tyfunc(s->ty()) && + !variadic(s->Stype)) +#endif + { + char *pstr = unsstr(type_paramsize(s->Stype)); + size_t pstrlen = strlen(pstr); + size_t destlen = len + 1 + pstrlen + 1; + + if (destlen > DEST_LEN) + dest = (char *)mem_malloc(destlen); + memcpy(dest,name,len); + dest[len] = '@'; + memcpy(dest + 1 + len, pstr, pstrlen + 1); + break; + } + case mTYman_cpp: + case mTYman_d: + case mTYman_sys: + case 0: + if (len >= DEST_LEN) + dest = (char *)mem_malloc(len + 1); + memcpy(dest,name,len+1);// copy in name and trailing 0 + break; + + case mTYman_c: + if (len >= DEST_LEN - 1) + dest = (char *)mem_malloc(1 + len + 1); + dest[0] = '_'; + memcpy(dest + 1,name,len+1);// copy in name and trailing 0 + break; + + + default: +#ifdef DEBUG + printf("mangling %x\n",type_mangle(s->Stype)); + symbol_print(s); +#endif + printf("%d\n", type_mangle(s->Stype)); + assert(0); + } + //dbg_printf("\t %s\n",dest); + return dest; +} + +/******************************* + * Export a function name. + */ + +void obj_export(Symbol *s,unsigned argsize) +{ + //dbg_printf("obj_export(%s,%d)\n",s->Sident,argsize); +} + +/******************************* + * Update data information about symbol + * align for output and assign segment + * if not already specified. + * + * Input: + * sdata data symbol + * datasize output size + * seg default seg if not known + * Returns: + * actual seg + */ + +int elf_data_start(Symbol *sdata, targ_size_t datasize, int seg) +{ + targ_size_t alignbytes; + //dbg_printf("elf_data_start(%s,size %d,seg %d)\n",sdata->Sident,datasize,seg); + //symbol_print(sdata); + + if (sdata->Sseg == UNKNOWN) // if we don't know then there + sdata->Sseg = seg; // wasn't any segment override + else + seg = sdata->Sseg; + targ_size_t offset = Offset(seg); + alignbytes = align(datasize, offset) - offset; + if (alignbytes) + obj_lidata(seg, offset, alignbytes); + sdata->Soffset = offset + alignbytes; + return seg; +} + +/******************************* + * Update function info before codgen + * + * If code for this function is in a different segment + * than the current default in cseg, switch cseg to new segment. + */ + +void elf_func_start(Symbol *sfunc) +{ + //printf("elf_func_start(%s)\n",sfunc->Sident); + symbol_debug(sfunc); + + if (sfunc->Sseg == UNKNOWN) + sfunc->Sseg = CODE; + //printf("sfunc->Sseg %d CODE %d cseg %d Coffset x%x\n",sfunc->Sseg,CODE,cseg,Coffset); + cseg = sfunc->Sseg; + assert(cseg == CODE || cseg > UDATA); + objpubdef(cseg, sfunc, Coffset); + sfunc->Soffset = Coffset; + + if (config.fulltypes) + dwarf_func_start(sfunc); +} + +/******************************* + * Update function info after codgen + */ + +void elf_func_term(Symbol *sfunc) +{ + //dbg_printf("elf_func_term(%s) offset %x, Coffset %x symidx %d\n", +// sfunc->Sident, sfunc->Soffset,Coffset,sfunc->Sxtrnnum); + +#if 0 + // fill in the function size + if (I64) + SymbolTable64[sfunc->Sxtrnnum].st_size = Coffset - sfunc->Soffset; + else + SymbolTable[sfunc->Sxtrnnum].st_size = Coffset - sfunc->Soffset; +#endif + if (config.fulltypes) + dwarf_func_term(sfunc); +} + +/******************************** + * Output a public definition. + * Input: + * seg = segment index that symbol is defined in + * s -> symbol + * offset = offset of name within segment + */ + +void objpubdef(int seg, Symbol *s, targ_size_t offset) +{ +#if 0 + printf("objpubdef(%d:x%x s=%p, %s)\n", seg, offset, s, s->Sident); + //symbol_print(s); +#endif + symbol_debug(s); + + s->Soffset = offset; + s->Sseg = seg; + switch (s->Sclass) + { + case SCglobal: + case SCinline: + public_symbuf->write(&s, sizeof(s)); + break; + case SCcomdat: + case SCcomdef: + public_symbuf->write(&s, sizeof(s)); + break; + default: + local_symbuf->write(&s, sizeof(s)); + break; + } + //printf("%p\n", *(void**)public_symbuf->buf); + s->Sxtrnnum = 1; +} + +/******************************* + * Output an external symbol for name. + * Input: + * name Name to do EXTDEF on + * (Not to be mangled) + * Returns: + * Symbol table index of the definition + * NOTE: Numbers will not be linear. + */ + +int objextern(const char *name) +{ + //printf("objextdef('%s')\n",name); + assert(name); + assert(extdef == 0); + extdef = elf_addstr(symtab_strings, name); + return 0; +} + +int objextdef(const char *name) +{ + return objextern(name); +} + +/******************************* + * Output an external for existing symbol. + * Input: + * s Symbol to do EXTDEF on + * (Name is to be mangled) + * Returns: + * Symbol table index of the definition + * NOTE: Numbers will not be linear. + */ + +int objextern(Symbol *s) +{ + //printf("objextern('%s') %x\n",s->Sident,s->Svalue); + symbol_debug(s); + extern_symbuf->write(&s, sizeof(s)); + s->Sxtrnnum = 1; +} + +/******************************* + * Output a common block definition. + * Input: + * p -> external identifier + * size size in bytes of each elem + * count number of elems + * Returns: + * Symbol table index for symbol + */ + +int obj_comdef(Symbol *s,targ_size_t size,targ_size_t count) +{ + //printf("obj_comdef('%s', size=%d, count=%d)\n",s->Sident,size,count); + symbol_debug(s); + + // can't have code or thread local comdef's + assert(!(s->ty() & ( +#if TARGET_SEGMENTED + mTYcs | +#endif + mTYthread))); + + struct Comdef comdef; + comdef.sym = s; + comdef.size = size; + comdef.count = count; + comdef_symbuf->write(&comdef, sizeof(comdef)); + s->Sxtrnnum = 1; + return 0; // should return void +} + +int obj_comdef(Symbol *s, int flag, targ_size_t size, targ_size_t count) +{ + return obj_comdef(s, size, count); +} + +/*************************************** + * Append an iterated data block of 0s. + * (uninitialized data only) + */ + +void obj_write_zeros(seg_data *pseg, targ_size_t count) +{ + obj_lidata(pseg->SDseg, pseg->SDoffset, count); +} + +/*************************************** + * Output an iterated data block of 0s. + * + * For boundary alignment and initialization + */ + +void obj_lidata(int seg,targ_size_t offset,targ_size_t count) +{ + //printf("obj_lidata(%d,%x,%d)\n",seg,offset,count); + size_t idx = SegData[seg]->SDshtidx; + if ((I64 ? SecHdrTab64[idx].flags : SecHdrTab[idx].flags) == S_ZEROFILL) + { // Use SDoffset to record size of bss section + SegData[seg]->SDoffset += count; + } + else + { + obj_bytes(seg, offset, count, NULL); + } +} + +/*********************************** + * Append byte to segment. + */ + +void obj_write_byte(seg_data *pseg, unsigned byte) +{ + obj_byte(pseg->SDseg, pseg->SDoffset, byte); +} + +/************************************ + * Output byte to object file. + */ + +void obj_byte(int seg,targ_size_t offset,unsigned byte) +{ + Outbuffer *buf = SegData[seg]->SDbuf; + int save = buf->size(); + //dbg_printf("obj_byte(seg=%d, offset=x%lx, byte=x%x)\n",seg,offset,byte); + buf->setsize(offset); + buf->writeByte(byte); + if (save > offset+1) + buf->setsize(save); + else + SegData[seg]->SDoffset = offset+1; + //dbg_printf("\tsize now %d\n",buf->size()); +} + +/*********************************** + * Append bytes to segment. + */ + +void obj_write_bytes(seg_data *pseg, unsigned nbytes, void *p) +{ + obj_bytes(pseg->SDseg, pseg->SDoffset, nbytes, p); +} + +/************************************ + * Output bytes to object file. + * Returns: + * nbytes + */ + +unsigned obj_bytes(int seg, targ_size_t offset, unsigned nbytes, void *p) +{ +#if 0 + if (!(seg >= 0 && seg <= seg_count)) + { printf("obj_bytes: seg = %d, seg_count = %d\n", seg, seg_count); + *(char*)0=0; + } +#endif + assert(seg >= 0 && seg <= seg_count); + Outbuffer *buf = SegData[seg]->SDbuf; + if (buf == NULL) + { + //dbg_printf("obj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", seg, offset, nbytes, p); + //raise(SIGSEGV); +if (!buf) halt(); + assert(buf != NULL); + } + int save = buf->size(); + //dbg_printf("obj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", + //seg,offset,nbytes,p); + buf->setsize(offset); + buf->reserve(nbytes); + if (p) + { + buf->writen(p,nbytes); + } + else + { // Zero out the bytes + buf->clearn(nbytes); + } + if (save > offset+nbytes) + buf->setsize(save); + else + SegData[seg]->SDoffset = offset+nbytes; + return nbytes; +} + +/********************************************* + * Add a relocation entry for seg/offset. + */ + +void mach_addrel(int seg, targ_size_t offset, symbol *targsym, + unsigned targseg, int rtype, int val) +{ + Relocation rel; + rel.offset = offset; + rel.targsym = targsym; + rel.targseg = targseg; + rel.rtype = rtype; + rel.funcsym = funcsym_p; + rel.val = val; + seg_data *pseg = SegData[seg]; + if (!pseg->SDrel) + pseg->SDrel = new Outbuffer(); + pseg->SDrel->write(&rel, sizeof(rel)); +} + +/**************************************** + * Sort the relocation entry buffer. + */ + +#if __DMC__ +static int __cdecl rel_fp(const void *e1, const void *e2) +{ Relocation *r1 = (Relocation *)e1; + Relocation *r2 = (Relocation *)e2; + + return r1->offset - r2->offset; +} +#else +extern "C" { +static int rel_fp(const void *e1, const void *e2) +{ Relocation *r1 = (Relocation *)e1; + Relocation *r2 = (Relocation *)e2; + + return r1->offset - r2->offset; +} +} +#endif + +void mach_relsort(Outbuffer *buf) +{ + qsort(buf->buf, buf->size() / sizeof(Relocation), sizeof(Relocation), &rel_fp); +} + +/******************************* + * Output a relocation entry for a segment + * Input: + * seg = where the address is going + * offset = offset within seg + * type = ELF relocation type + * index = Related symbol table index + * val = addend or displacement from address + */ + +void elf_addrel(int seg, targ_size_t offset, unsigned type, + IDXSYM symidx, targ_size_t val) +{ +} + +/******************************* + * Refer to address that is in the data segment. + * Input: + * seg:offset = the address being fixed up + * val = displacement from start of target segment + * targetdatum = target segment number (DATA, CDATA or UDATA, etc.) + * flags = CFoff, CFseg + * Example: + * int *abc = &def[3]; + * to allocate storage: + * reftodatseg(DATA,offset,3 * sizeof(int *),UDATA); + */ + +void reftodatseg(int seg,targ_size_t offset,targ_size_t val, + unsigned targetdatum,int flags) +{ + Outbuffer *buf = SegData[seg]->SDbuf; + int save = buf->size(); + buf->setsize(offset); +#if 0 + printf("reftodatseg(seg:offset=%d:x%llx, val=x%llx, targetdatum %x, flags %x )\n", + seg,offset,val,targetdatum,flags); +#endif + if (SegData[seg]->isCode() && SegData[targetdatum]->isCode()) + { + assert(0); + } + mach_addrel(seg, offset, NULL, targetdatum, RELaddr); + if (I64) + { + if (flags & CFoffset64) + { + buf->write64(val); + if (save > offset + 8) + buf->setsize(save); + return; + } + } + buf->write32(val); + if (save > offset + 4) + buf->setsize(save); +} + +/******************************* + * Refer to address that is in the current function code (funcsym_p). + * Only offsets are output, regardless of the memory model. + * Used to put values in switch address tables. + * Input: + * seg = where the address is going (CODE or DATA) + * offset = offset within seg + * val = displacement from start of this module + */ + +void reftocodseg(int seg,targ_size_t offset,targ_size_t val) +{ + //printf("reftocodseg(seg=%d, offset=x%lx, val=x%lx )\n",seg,(unsigned long)offset,(unsigned long)val); + assert(seg > 0); + Outbuffer *buf = SegData[seg]->SDbuf; + int save = buf->size(); + buf->setsize(offset); + val -= funcsym_p->Soffset; + mach_addrel(seg, offset, funcsym_p, 0, RELaddr); +// if (I64) +// buf->write64(val); +// else + buf->write32(val); + if (save > offset + 4) + buf->setsize(save); +} + +/******************************* + * Refer to an identifier. + * Input: + * seg = where the address is going (CODE or DATA) + * offset = offset within seg + * s -> Symbol table entry for identifier + * val = displacement from identifier + * flags = CFselfrel: self-relative + * CFseg: get segment + * CFoff: get offset + * CFpc32: [RIP] addressing, val is 0, -1, -2 or -4 + * CFoffset64: 8 byte offset for 64 bit builds + * Returns: + * number of bytes in reference (4 or 8) + */ + +int reftoident(int seg, targ_size_t offset, Symbol *s, targ_size_t val, + int flags) +{ + int retsize = (flags & CFoffset64) ? 8 : 4; +#if 0 + dbg_printf("\nreftoident('%s' seg %d, offset x%llx, val x%llx, flags x%x)\n", + s->Sident,seg,(unsigned long long)offset,(unsigned long long)val,flags); + printf("retsize = %d\n", retsize); + //dbg_printf("Sseg = %d, Sxtrnnum = %d\n",s->Sseg,s->Sxtrnnum); + symbol_print(s); +#endif + assert(seg > 0); + if (s->Sclass != SClocstat && !s->Sxtrnnum) + { // It may get defined later as public or local, so defer + addtofixlist(s, offset, seg, val, flags); + } + else + { + if (I64) + { + //if (s->Sclass != SCcomdat) + //val += s->Soffset; + int v = 0; + if (flags & CFpc32) + v = (int)val; + if (flags & CFselfrel) + { + mach_addrel(seg, offset, s, 0, RELrel, v); + } + else + { + mach_addrel(seg, offset, s, 0, RELaddr, v); + } + } + else + { + if (SegData[seg]->isCode() && flags & CFselfrel) + { + if (!jumpTableSeg) + { + jumpTableSeg = + mach_getsegment("__jump_table", "__IMPORT", 0, S_SYMBOL_STUBS | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_SELF_MODIFYING_CODE); + } + seg_data *pseg = SegData[jumpTableSeg]; + if (I64) + SecHdrTab64[pseg->SDshtidx].reserved2 = 5; + else + SecHdrTab[pseg->SDshtidx].reserved2 = 5; + + if (!indirectsymbuf1) + indirectsymbuf1 = new Outbuffer(); + else + { // Look through indirectsym to see if it is already there + int n = indirectsymbuf1->size() / sizeof(Symbol *); + Symbol **psym = (Symbol **)indirectsymbuf1->buf; + for (int i = 0; i < n; i++) + { // Linear search, pretty pathetic + if (s == psym[i]) + { val = i * 5; + goto L1; + } + } + } + + val = pseg->SDbuf->size(); + static char halts[5] = { 0xF4,0xF4,0xF4,0xF4,0xF4 }; + pseg->SDbuf->write(halts, 5); + + // Add symbol s to indirectsymbuf1 + indirectsymbuf1->write(&s, sizeof(Symbol *)); + L1: + val -= offset + 4; + mach_addrel(seg, offset, NULL, jumpTableSeg, RELrel); + } + else if (SegData[seg]->isCode() && + ((s->Sclass != SCextern && SegData[s->Sseg]->isCode()) || s->Sclass == SClocstat || s->Sclass == SCstatic)) + { + val += s->Soffset; + mach_addrel(seg, offset, NULL, s->Sseg, RELaddr); + } + else if (SegData[seg]->isCode() && !tyfunc(s->ty())) + { + if (!pointersSeg) + { + pointersSeg = + mach_getsegment("__pointers", "__IMPORT", 0, S_NON_LAZY_SYMBOL_POINTERS); + } + seg_data *pseg = SegData[pointersSeg]; + + if (!indirectsymbuf2) + indirectsymbuf2 = new Outbuffer(); + else + { // Look through indirectsym to see if it is already there + int n = indirectsymbuf2->size() / sizeof(Symbol *); + Symbol **psym = (Symbol **)indirectsymbuf2->buf; + for (int i = 0; i < n; i++) + { // Linear search, pretty pathetic + if (s == psym[i]) + { val = i * 4; + goto L2; + } + } + } + + val = pseg->SDbuf->size(); + pseg->SDbuf->writezeros(NPTRSIZE); + + // Add symbol s to indirectsymbuf2 + indirectsymbuf2->write(&s, sizeof(Symbol *)); + + L2: + //printf("reftoident: seg = %d, offset = x%x, s = %s, val = x%x, pointersSeg = %d\n", seg, offset, s->Sident, val, pointersSeg); + mach_addrel(seg, offset, NULL, pointersSeg, RELaddr); + } + else + { //val -= s->Soffset; + mach_addrel(seg, offset, s, 0, RELaddr); + } + } + + Outbuffer *buf = SegData[seg]->SDbuf; + int save = buf->size(); + buf->setsize(offset); + //printf("offset = x%llx, val = x%llx\n", offset, val); + if (retsize == 8) + buf->write64(val); + else + buf->write32(val); + if (save > offset + retsize) + buf->setsize(save); + } + return retsize; +} + +/***************************************** + * Generate far16 thunk. + * Input: + * s Symbol to generate a thunk for + */ + +void obj_far16thunk(Symbol *s) +{ + //dbg_printf("obj_far16thunk('%s')\n", s->Sident); + assert(0); +} + +/************************************** + * Mark object file as using floating point. + */ + +void obj_fltused() +{ + //dbg_printf("obj_fltused()\n"); +} + +/************************************ + * Close and delete .OBJ file. + */ + +void objfile_delete() +{ + //remove(fobjname); // delete corrupt output file +} + +/********************************** + * Terminate. + */ + +void objfile_term() +{ +#if TERMCODE + mem_free(fobjname); + fobjname = NULL; +#endif +} + +/********************************** + * Write to the object file + */ +void objfile_write(FILE *fd, void *buffer, unsigned len) +{ + fobjbuf->write(buffer, len); +} + +long elf_align(targ_size_t size, long foffset) +{ + long offset; + switch (size) + { + case 0: + case 1: + return foffset; + case 2: + offset = (foffset + 1) & ~1; + break; + case 4: + offset = (foffset + 3) & ~3; + break; + case 8: + offset = (foffset + 7) & ~7; + break; + case 16: + offset = (foffset + 15) & ~15; + break; + case 32: + offset = (foffset + 31) & ~31; + break; + default: + dbg_printf("size was %lu\n",(unsigned long)size); + assert(0); + break; + } + if (offset > foffset) + fobjbuf->writezeros(offset - foffset); + return offset; +} + +/*************************************** + * Stuff pointer to ModuleInfo in its own segment. + */ + +#if MARS + +void obj_moduleinfo(Symbol *scc) +{ + int align = I64 ? 4 : 2; + + mach_getsegment("__minfo_beg", "__DATA", align, S_COALESCED, 4); + + int seg = mach_getsegment("__minfodata", "__DATA", align, S_REGULAR); + //printf("obj_moduleinfo(%s) seg = %d:x%x\n", scc->Sident, seg, Offset(seg)); + +#if 0 + type *t = type_fake(TYint); + t->Tmangle = mTYman_c; + char *p = (char *)malloc(5 + strlen(scc->Sident) + 1); + strcpy(p, "SUPER"); + strcpy(p + 5, scc->Sident); + symbol *s_minfo_beg = symbol_name(p, SCglobal, t); + objpubdef(seg, s_minfo_beg, 0); +#endif + + int flags = CFoff; + if (I64) + flags |= CFoffset64; + SegData[seg]->SDoffset += reftoident(seg, Offset(seg), scc, 0, flags); + + mach_getsegment("__minfo_end", "__DATA", align, S_COALESCED, 4); +} + +#endif + +/************************************* + */ + +void elfobj_gotref(symbol *s) +{ + //printf("elfobj_gotref(%x '%s', %d)\n",s,s->Sident, s->Sclass); + switch(s->Sclass) + { + case SCstatic: + case SClocstat: + s->Sfl = FLgotoff; + break; + + case SCextern: + case SCglobal: + case SCcomdat: + case SCcomdef: + s->Sfl = FLgot; + break; + + default: + break; + } +} + +#endif +#endif diff --git a/backend/md5.c b/backend/md5.c new file mode 100644 index 00000000..8675d4a2 --- /dev/null +++ b/backend/md5.c @@ -0,0 +1,277 @@ +/* + ********************************************************************** + ** md5.c ** + ** RSA Data Security, Inc. MD5 Message Digest Algorithm ** + ** Created: 2/17/90 RLR ** + ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version ** + ********************************************************************** + */ + +/* + ********************************************************************** + ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. ** + ** ** + ** License to copy and use this software is granted provided that ** + ** it is identified as the "RSA Data Security, Inc. MD5 Message ** + ** Digest Algorithm" in all material mentioning or referencing this ** + ** software or this function. ** + ** ** + ** License is also granted to make and use derivative works ** + ** provided that such works are identified as "derived from the RSA ** + ** Data Security, Inc. MD5 Message Digest Algorithm" in all ** + ** material mentioning or referencing the derived work. ** + ** ** + ** RSA Data Security, Inc. makes no representations concerning ** + ** either the merchantability of this software or the suitability ** + ** of this software for any particular purpose. It is provided "as ** + ** is" without express or implied warranty of any kind. ** + ** ** + ** These notices must be retained in any copies of any part of this ** + ** documentation and/or software. ** + ********************************************************************** + */ + +/* -- include the following line if the md5.h header file is separate -- */ +#include "md5.h" + +/* forward declaration */ +static void Transform (UINT4 *buf, UINT4 *in); + +static unsigned char PADDING[64] = { + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +/* F, G and H are basic MD5 functions: selection, majority, parity */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE_LEFT rotates x left n bits */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */ +/* Rotation is separate from addition to prevent recomputation */ +#define FF(a, b, c, d, x, s, ac) \ + {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) \ + {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) \ + {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) \ + {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } + +void MD5Init (mdContext) +MD5_CTX *mdContext; +{ + mdContext->i[0] = mdContext->i[1] = (UINT4)0; + + /* Load magic initialization constants. + */ + mdContext->buf[0] = (UINT4)0x67452301; + mdContext->buf[1] = (UINT4)0xefcdab89; + mdContext->buf[2] = (UINT4)0x98badcfe; + mdContext->buf[3] = (UINT4)0x10325476; +} + +void MD5Update (mdContext, inBuf, inLen) +MD5_CTX *mdContext; +unsigned char *inBuf; +unsigned int inLen; +{ + UINT4 in[16]; + int mdi; + unsigned int i, ii; + + /* compute number of bytes mod 64 */ + mdi = (int)((mdContext->i[0] >> 3) & 0x3F); + + /* update number of bits */ + if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) + mdContext->i[1]++; + mdContext->i[0] += ((UINT4)inLen << 3); + mdContext->i[1] += ((UINT4)inLen >> 29); + + while (inLen--) { + /* add new character to buffer, increment mdi */ + mdContext->in[mdi++] = *inBuf++; + + /* transform if necessary */ + if (mdi == 0x40) { + for (i = 0, ii = 0; i < 16; i++, ii += 4) + in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | + (((UINT4)mdContext->in[ii+2]) << 16) | + (((UINT4)mdContext->in[ii+1]) << 8) | + ((UINT4)mdContext->in[ii]); + Transform (mdContext->buf, in); + mdi = 0; + } + } +} + +void MD5Final (mdContext) +MD5_CTX *mdContext; +{ + UINT4 in[16]; + int mdi; + unsigned int i, ii; + unsigned int padLen; + + /* save number of bits */ + in[14] = mdContext->i[0]; + in[15] = mdContext->i[1]; + + /* compute number of bytes mod 64 */ + mdi = (int)((mdContext->i[0] >> 3) & 0x3F); + + /* pad out to 56 mod 64 */ + padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); + MD5Update (mdContext, PADDING, padLen); + + /* append length in bits and transform */ + for (i = 0, ii = 0; i < 14; i++, ii += 4) + in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | + (((UINT4)mdContext->in[ii+2]) << 16) | + (((UINT4)mdContext->in[ii+1]) << 8) | + ((UINT4)mdContext->in[ii]); + Transform (mdContext->buf, in); + + /* store buffer in digest */ + for (i = 0, ii = 0; i < 4; i++, ii += 4) { + mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF); + mdContext->digest[ii+1] = + (unsigned char)((mdContext->buf[i] >> 8) & 0xFF); + mdContext->digest[ii+2] = + (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); + mdContext->digest[ii+3] = + (unsigned char)((mdContext->buf[i] >> 24) & 0xFF); + } +} + +/* Basic MD5 step. Transform buf based on in. + */ +static void Transform (buf, in) +UINT4 *buf; +UINT4 *in; +{ + UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3]; + + /* Round 1 */ +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 + FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */ + FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */ + FF ( c, d, a, b, in[ 2], S13, 606105819); /* 3 */ + FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */ + FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */ + FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */ + FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */ + FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */ + FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */ + FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */ + FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */ + FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */ + FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */ + FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */ + FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */ + FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */ + + /* Round 2 */ +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 + GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */ + GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */ + GG ( c, d, a, b, in[11], S23, 643717713); /* 19 */ + GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */ + GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */ + GG ( d, a, b, c, in[10], S22, 38016083); /* 22 */ + GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */ + GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */ + GG ( a, b, c, d, in[ 9], S21, 568446438); /* 25 */ + GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */ + GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */ + GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */ + GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */ + GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */ + GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */ + GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */ + + /* Round 3 */ +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 + HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */ + HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */ + HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */ + HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */ + HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */ + HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */ + HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */ + HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */ + HH ( a, b, c, d, in[13], S31, 681279174); /* 41 */ + HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */ + HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */ + HH ( b, c, d, a, in[ 6], S34, 76029189); /* 44 */ + HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */ + HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */ + HH ( c, d, a, b, in[15], S33, 530742520); /* 47 */ + HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */ + + /* Round 4 */ +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */ + II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */ + II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */ + II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */ + II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */ + II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */ + II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */ + II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */ + II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */ + II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */ + II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */ + II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */ + II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */ + II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */ + II ( c, d, a, b, in[ 2], S43, 718787259); /* 63 */ + II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */ + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} + +/* + ********************************************************************** + ** End of md5.c ** + ******************************* (cut) ******************************** + */ + diff --git a/backend/md5.h b/backend/md5.h new file mode 100644 index 00000000..b7a7418d --- /dev/null +++ b/backend/md5.h @@ -0,0 +1,61 @@ +/* + ********************************************************************** + ** md5.h -- Header file for implementation of MD5 ** + ** RSA Data Security, Inc. MD5 Message Digest Algorithm ** + ** Created: 2/17/90 RLR ** + ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version ** + ** Revised (for MD5): RLR 4/27/91 ** + ** -- G modified to have y&~z instead of y&z ** + ** -- FF, GG, HH modified to add in last register done ** + ** -- Access pattern: round 2 works mod 5, round 3 works mod 3 ** + ** -- distinct additive constant for each step ** + ** -- round 4 added, working mod 7 ** + ********************************************************************** + */ + +/* + ********************************************************************** + ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. ** + ** ** + ** License to copy and use this software is granted provided that ** + ** it is identified as the "RSA Data Security, Inc. MD5 Message ** + ** Digest Algorithm" in all material mentioning or referencing this ** + ** software or this function. ** + ** ** + ** License is also granted to make and use derivative works ** + ** provided that such works are identified as "derived from the RSA ** + ** Data Security, Inc. MD5 Message Digest Algorithm" in all ** + ** material mentioning or referencing the derived work. ** + ** ** + ** RSA Data Security, Inc. makes no representations concerning ** + ** either the merchantability of this software or the suitability ** + ** of this software for any particular purpose. It is provided "as ** + ** is" without express or implied warranty of any kind. ** + ** ** + ** These notices must be retained in any copies of any part of this ** + ** documentation and/or software. ** + ********************************************************************** + */ + +/* typedef a 32 bit type */ +typedef unsigned long int UINT4; + +/* Data structure for MD5 (Message Digest) computation */ +typedef struct { + UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ + UINT4 buf[4]; /* scratch buffer */ + unsigned char in[64]; /* input buffer */ + unsigned char digest[16]; /* actual digest after MD5Final call */ +} MD5_CTX; + +void MD5Init (MD5_CTX *mdContext); +void MD5Update (MD5_CTX *mdContext, unsigned char *inBuf, unsigned inLen); +void MD5Final (MD5_CTX *mdContext); + +/* + ********************************************************************** + ** End of md5.h ** + ******************************* (cut) ******************************** + */ + + diff --git a/backend/melf.h b/backend/melf.h new file mode 100644 index 00000000..3af989e3 --- /dev/null +++ b/backend/melf.h @@ -0,0 +1,381 @@ + +/* ELF file format */ + +typedef unsigned short elf_u16_f32; +typedef unsigned int elf_u32_f32; +typedef int elf_s32_f32; +typedef unsigned int elf_add_f32; +typedef unsigned int elf_off_f32; +typedef unsigned char elf_u8_f32; + +#define EI_NIDENT 16 +typedef struct + { +// unsigned char EHident[EI_NIDENT]; /* Header identification info */ + #define EI_MAG0 0 /* Identification byte offset 0*/ + #define EI_MAG1 1 /* Identification byte offset 1*/ + #define EI_MAG2 2 /* Identification byte offset 2*/ + #define EI_MAG3 3 /* Identification byte offset 3*/ + #define ELFMAG0 0x7f /* Magic number byte 0 */ + #define ELFMAG1 'E' /* Magic number byte 1 */ + #define ELFMAG2 'L' /* Magic number byte 2 */ + #define ELFMAG3 'F' /* Magic number byte 3 */ + + #define EI_CLASS 4 /* File class byte offset 4 */ + #define ELFCLASSNONE 0 // invalid + #define ELFCLASS32 1 /* 32-bit objects */ + #define ELFCLASS64 2 /* 64-bit objects */ + + #define EI_DATA 5 /* Data encoding byte offset 5 */ + #define ELFDATANONE 0 // invalid + #define ELFDATA2LSB 1 /* 2's comp,lsb low address */ + #define ELFDATA2MSB 2 /* 2's comp,msb low address */ + + #define EI_VERSION 6 /* Header version byte offset 6 */ + //#define EV_CURRENT 1 /* Current header format */ + + #define EI_OSABI 7 /* OS ABI byte offset 7 */ + #define ELFOSABI_SYSV 0 /* UNIX System V ABI */ + #define ELFOSABI_HPUX 1 /* HP-UX */ + #define ELFOSABI_NETBSD 2 + #define ELFOSABI_LINUX 3 + #define ELFOSABI_FREEBSD 9 + #define ELFOSABI_ARM 97 /* ARM */ + #define ELFOSABI_STANDALONE 255 /* Standalone/embedded */ + + #define EI_ABIVERSION 8 /* ABI version byte offset 8 */ + + #define EI_PAD 9 /* Byte to start of padding */ + + elf_u16_f32 e_type; /* Object file type */ + #define ET_NONE 0 /* No specified file type */ + #define ET_REL 1 /* Relocatable object file */ + #define ET_EXEC 2 /* Executable file */ + #define ET_DYN 3 /* Dynamic link object file */ + #define ET_CORE 4 /* Core file */ + #define ET_LOPROC 0xff00 /* Processor low index */ + #define ET_HIPROC 0xffff /* Processor hi index */ + + elf_u16_f32 e_machine; /* Machine architecture */ + #define EM_386 3 /* Intel 80386 */ + #define EM_486 6 /* Intel 80486 */ + #define EM_X86_64 62 // Advanced Micro Devices X86-64 processor + + elf_u32_f32 e_version; /* File format version */ + #define EV_NONE 0 // invalid version + #define EV_CURRENT 1 // Current file format + + elf_add_f32 e_entry; /* Entry point virtual address */ + elf_off_f32 e_phoff; /* Program header table(PHT)offset */ + elf_off_f32 e_shoff; /* Section header table(SHT)offset */ + elf_u32_f32 e_flags; /* Processor-specific flags */ + elf_u16_f32 e_ehsize; /* Size of ELF header (bytes) */ + #define EH_HEADER_SIZE 0x34 + elf_u16_f32 e_phentsize; /* Size of PHT (bytes) */ + #define EH_PHTENT_SIZE 0x20 + elf_u16_f32 e_phnum; /* Number of PHT entries */ + elf_u16_f32 e_shentsize; /* Size of SHT entry in bytes */ + #define EH_SHTENT_SIZE 0x28 + elf_u16_f32 e_shnum; /* Number of SHT entries */ + elf_u16_f32 e_shstrndx; /* SHT index for string table */ + } Elf32_Hdr; + +/* Section header. */ + +typedef struct +{ + elf_u32_f32 sh_name; /* String table offset for section name */ + elf_u32_f32 sh_type; /* Section type */ + #define SHT_NULL 0 /* SHT entry unused */ + #define SHT_PROGDEF 1 /* Program defined data */ + #define SHT_SYMTAB 2 /* Symbol table */ + #define SHT_STRTAB 3 /* String table */ + #define SHT_RELA 4 /* Relocations with addends */ + #define SHT_HASHTAB 5 /* Symbol hash table */ + #define SHT_DYNAMIC 6 /* String table for dynamic symbols */ + #define SHT_NOTE 7 /* Notes */ + #define SHT_RESDATA 8 /* Reserved data space */ + #define SHT_NOBITS SHT_RESDATA + #define SHT_REL 9 /* Relocations no addends */ + #define SHT_RESTYPE 10 /* Reserved section type*/ + #define SHT_DYNTAB 11 /* Dynamic linker symbol table */ + #define SHT_GROUP 17 /* Section group (COMDAT) */ + elf_u32_f32 sh_flags; /* Section attribute flags */ + #define SHF_WRITE (1 << 0) /* Writable during execution */ + #define SHF_ALLOC (1 << 1) /* In memory during execution */ + #define SHF_EXECINSTR (1 << 2) /* Executable machine instructions*/ + #define SHF_TLS (1 << 10) /* Thread local */ + #define SHF_MASKPROC 0xf0000000 /* Mask for processor-specific */ + elf_add_f32 sh_addr; /* Starting virtual memory address */ + elf_off_f32 sh_offset; /* Offset to section in file */ + elf_u32_f32 sh_size; /* Size of section */ + elf_u32_f32 sh_link; /* Index to optional related section */ + elf_u32_f32 sh_info; /* Optional extra section information */ + elf_u32_f32 sh_addralign; /* Required section alignment */ + elf_u32_f32 sh_entsize; /* Size of fixed size section entries */ +} Elf32_Shdr; + +// Special Section Header Table Indices +#define SHT_UNDEF 0 /* Undefined section */ +#define SHT_ABS 0xfff1 /* Absolute value for symbol references */ +#define SHT_COMMON 0xfff2 /* Symbol defined in common section */ +#define SHT_RESVSTART 0xff00 /* Start of reserved indices */ +#define SHT_PROCSTART 0xff00 /* Start of processor-specific */ +#define SHT_PROCEND 0xff1f /* End of processor-specific */ +#define SHT_RESVEND 0xffff /* End of reserved indices */ + +/* Symbol Table */ + +typedef struct +{ + elf_u32_f32 st_name; /* string table index for symbol name */ + elf_add_f32 st_value; /* Associated symbol value */ + elf_u32_f32 st_size; /* Symbol size */ + unsigned char st_info; /* Symbol type and binding */ + #define ELF_ST_BIND(s) ((s)>>4) + #define ELF_ST_TYPE(s) ((s)&0xf) + #define ELF_ST_INFO(b,t) (((b) << 4) + ((t) & 0xf)) + + #define STB_LOCAL 0 /* Local symbol */ + #define STB_GLOBAL 1 /* Global symbol */ + #define STB_WEAK 2 /* Weak symbol */ + #define ST_NUM_BINDINGS 3 /* Number of defined types. */ + #define STB_LOOS 10 /* Start of OS-specific */ + #define STB_HIOS 12 /* End of OS-specific */ + #define STB_LOPROC 13 /* Start of processor-specific */ + #define STB_HIPROC 15 /* End of processor-specific */ + + #define STT_NOTYPE 0 /* Symbol type is unspecified */ + #define STT_OBJECT 1 /* Symbol is a data object */ + #define STT_FUNC 2 /* Symbol is a code object */ + #define STT_SECTION 3 /* Symbol associated with a section */ + #define STT_FILE 4 /* Symbol's name is file name */ + #define STT_COMMON 5 + #define STT_TLS 6 + #define STT_NUM 5 /* Number of defined types. */ + #define STT_LOOS 11 /* Start of OS-specific */ + #define STT_HIOS 12 /* End of OS-specific */ + #define STT_LOPROC 13 /* Start of processor-specific */ + #define STT_HIPROC 15 /* End of processor-specific */ + + + unsigned char st_other; /* Currently not defined */ + elf_u16_f32 st_shndx; /* SHT index for symbol definition */ +} Elf32_Sym; + + +/* Relocation table entry without addend (in section of type SHT_REL). */ + +typedef struct +{ + elf_add_f32 r_offset; /* Address */ + elf_u32_f32 r_info; /* Relocation type and symbol index */ + #define ELF32_R_IDX(i) ((i) >> 8) /* Symbol idx */ + #define ELF32_R_TYPE(i)((i) & 0xff) /* Type of relocation */ + #define ELF32_R_INFO(i, t) (((i) << 8) + ((t) & 0xff)) + + #define RI_TYPE_NONE 0 /* No reloc */ + #define RI_TYPE_SYM32 1 /* Symbol value 32 bit */ + #define RI_TYPE_PC32 2 /* PC relative 32 bit */ + #define RI_TYPE_GOT32 3 /* 32 bit GOT entry */ + #define RI_TYPE_PLT32 4 /* 32 bit PLT address */ + #define RI_TYPE_COPY 5 /* Copy symbol at runtime */ + #define RI_TYPE_GLOBDAT 6 /* Create GOT entry */ + #define RI_TYPE_JMPSLOT 7 /* Create PLT entry */ + #define RI_TYPE_REL 8 /* Adjust by program base */ + #define RI_TYPE_GOTOFF 9 /* 32 bit offset to GOT */ + #define RI_TYPE_GOTPC 10 /* 32 bit PC relative offset to GOT */ + #define RI_TYPE_TLS_TPOFF 14 + #define RI_TYPE_TLS_IE 15 + #define RI_TYPE_TLS_GOTIE 16 + #define RI_TYPE_TLS_LE 17 /* negative offset relative to static TLS */ + #define RI_TYPE_TLS_GD 18 + #define RI_TYPE_TLS_LDM 19 + #define RI_TYPE_TLS_GD_32 24 + #define RI_TYPE_TLS_GD_PUSH 25 + #define RI_TYPE_TLS_GD_CALL 26 + #define RI_TYPE_TLS_GD_POP 27 + #define RI_TYPE_TLS_LDM_32 28 + #define RI_TYPE_TLS_LDM_PUSH 29 + #define RI_TYPE_TLS_LDM_CALL 30 + #define RI_TYPE_TLS_LDM_POP 31 + #define RI_TYPE_TLS_LDO_32 32 + #define RI_TYPE_TLS_IE_32 33 + #define RI_TYPE_TLS_LE_32 34 + #define RI_TYPE_TLS_DTPMOD32 35 + #define RI_TYPE_TLS_DTPOFF32 36 + #define RI_TYPE_TLS_TPOFF32 37 +} Elf32_Rel; + +/* stabs debug records */ + +typedef struct +{ + elf_u32_f32 DBstring; /* string table index for the symbol */ + elf_u8_f32 DBtype; /* type of the symbol */ + #define DBT_UNDEF 0x00 /* undefined symbol */ + #define DBT_EXT 0x01 /* exernal modifier */ + #define DBT_ABS 0x02 /* absolute */ + #define DBT_TEXT 0x04 /* code text */ + #define DBT_DATA 0x06 /* data */ + #define DBT_BSS 0x08 /* BSS */ + #define DBT_INDR 0x0a /* indirect to another symbol */ + #define DBT_COMM 0x12 /* common -visible after shr'd lib link */ + #define DBT_SETA 0x14 /* Absolue set element */ + #define DBT_SETT 0x16 /* code text segment set element */ + #define DBT_SETD 0x18 /* data segment set element */ + #define DBT_SETB 0x1a /* BSS segment set element */ + #define DBT_SETV 0x1c /* Pointer to set vector */ + #define DBT_WARNING 0x1e /* print warning during link */ + #define DBT_FN 0x1f /* name of object file */ + + #define DBT_GSYM 0x20 /* global symbol */ + #define DBT_FUN 0x24 /* function name */ + #define DBT_STSYM 0x26 /* static data */ + #define DBT_LCSYM 0x28 /* static bss */ + #define DBT_MAIN 0x2a /* main routine */ + #define DBT_RO 0x2c /* read only */ + #define DBT_OPT 0x3c /* target option? */ + #define DBT_REG 0x40 /* register variable */ + #define DBT_TLINE 0x44 /* text line number */ + #define DBT_DLINE 0x46 /* dat line number */ + #define DBT_BLINE 0x48 /* bss line number */ + #define DBT_STUN 0x62 /* structure or union */ + #define DBT_SRCF 0x64 /* source file */ + #define DBT_AUTO 0x80 /* stack variable */ + #define DBT_TYPE 0x80 /* type definition */ + #define DBT_INCS 0x84 /* include file start */ + #define DBT_PARAM 0xa0 /* parameter */ + #define DBT_INCE 0xa2 /* include file end */ + elf_u8_f32 DBmisc; /* misc. info */ + elf_u16_f32 DBdesc; /* description field */ + elf_u32_f32 DBvalu; /* symbol value */ +} elf_stab; + + +/* Program header. */ + +typedef struct +{ + elf_u32_f32 PHtype; /* Program type */ + #define PHT_NULL 0 /* SHT entry unused */ + elf_off_f32 PHoff; /* Offset to segment in file */ + elf_add_f32 PHvaddr; /* Starting virtual memory address */ + elf_add_f32 PHpaddr; /* Starting absolute memory address */ + elf_u32_f32 PHfilesz; /* Size of file image */ + elf_u32_f32 PHmemsz; /* Size of memory image */ + elf_u32_f32 PHflags; /* Program attribute flags */ + elf_u32_f32 PHalign; /* Program loading alignment */ +} elf_pht; + + + +/* Legal values for sh_flags (section flags). */ + +/***************************** 64 bit Elf *****************************************/ + +typedef unsigned long long Elf64_Addr; +typedef unsigned long long Elf64_Off; +typedef unsigned long long Elf64_Xword; +typedef long long Elf64_Sxword; +typedef int Elf64_Sword; +typedef unsigned int Elf64_Word; +typedef unsigned short Elf64_Half; + +typedef struct +{ + Elf64_Half e_type; + Elf64_Half e_machine; + Elf64_Word e_version; + Elf64_Addr e_entry; + Elf64_Off e_phoff; + Elf64_Off e_shoff; + Elf64_Word e_flags; + Elf64_Half e_ehsize; + Elf64_Half e_phentsize; + Elf64_Half e_phnum; + Elf64_Half e_shentsize; + Elf64_Half e_shnum; + Elf64_Half e_shstrndx; +} Elf64_Ehdr; + +typedef struct { + Elf64_Word sh_name; + Elf64_Word sh_type; + Elf64_Xword sh_flags; + Elf64_Addr sh_addr; + Elf64_Off sh_offset; + Elf64_Xword sh_size; + Elf64_Word sh_link; + Elf64_Word sh_info; + Elf64_Xword sh_addralign; + Elf64_Xword sh_entsize; +} Elf64_Shdr; + +typedef struct { + Elf64_Word p_type; + Elf64_Word p_flags; + Elf64_Off p_offset; + Elf64_Addr p_vaddr; + Elf64_Addr p_paddr; + Elf64_Xword p_filesz; + Elf64_Xword p_memsz; + Elf64_Xword p_align; +} Elf64_Phdr; + +typedef struct { + Elf64_Word st_name; + unsigned char st_info; + unsigned char st_other; + Elf64_Half st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; +} Elf64_Sym; + +typedef struct { + Elf64_Addr r_offset; + Elf64_Xword r_info; + #define ELF64_R_SYM(i) ((Elf64_Word)((i)>>32)) + #define ELF64_R_TYPE(i) ((Elf64_Word)(i & 0xFFFFFFFF)) + #define ELF64_R_INFO(s,t) ((((Elf64_Xword)(s))<<32)|(Elf64_Word)(t)) + + // X86-64 Relocation types + + #define R_X86_64_NONE 0 // -- No relocation + #define R_X86_64_64 1 // 64 Direct 64 bit + #define R_X86_64_PC32 2 // 32 PC relative 32 bit signed + #define R_X86_64_GOT32 3 // 32 32 bit GOT entry + #define R_X86_64_PLT32 4 // 32 bit PLT address + #define R_X86_64_COPY 5 // -- Copy symbol at runtime + #define R_X86_64_GLOB_DAT 6 // 64 Create GOT entry + #define R_X86_64_JUMP_SLOT 7 // 64 Create PLT entry + #define R_X86_64_RELATIVE 8 // 64 Adjust by program base + #define R_X86_64_GOTPCREL 9 // 32 32 bit signed pc relative offset to GOT + #define R_X86_64_32 10 // 32 Direct 32 bit zero extended + #define R_X86_64_32S 11 // 32 Direct 32 bit sign extended + #define R_X86_64_16 12 // 16 Direct 16 bit zero extended + #define R_X86_64_PC16 13 // 16 16 bit sign extended pc relative + #define R_X86_64_8 14 // 8 Direct 8 bit sign extended + #define R_X86_64_PC8 15 // 8 8 bit sign extended pc relative + #define R_X86_64_DTPMOD64 16 // 64 ID of module containing symbol + #define R_X86_64_DTPOFF64 17 // 64 Offset in TLS block + #define R_X86_64_TPOFF64 18 // 64 Offset in initial TLS block + #define R_X86_64_TLSGD 19 // 32 PC relative offset to GD GOT block + #define R_X86_64_TLSLD 20 // 32 PC relative offset to LD GOT block + #define R_X86_64_DTPOFF32 21 // 32 Offset in TLS block + #define R_X86_64_GOTTPOFF 22 // 32 PC relative offset to IE GOT entry + #define R_X86_64_TPOFF32 23 // 32 Offset in initial TLS block + #define R_X86_64_PC64 24 // 64 + #define R_X86_64_GOTOFF64 25 // 64 + #define R_X86_64_GOTPC32 26 // 32 + #define R_X86_64_GNU_VTINHERIT 250 // GNU C++ hack + #define R_X86_64_GNU_VTENTRY 251 // GNU C++ hack +} Elf64_Rel; + +typedef struct { + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; +} Elf64_Rela; + + diff --git a/backend/newman.c b/backend/newman.c new file mode 100644 index 00000000..c0ac6c86 --- /dev/null +++ b/backend/newman.c @@ -0,0 +1,1707 @@ +// Copyright (C) 1992-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include +#include + +#include "cc.h" +#include "token.h" +#include "global.h" +#include "oper.h" +#include "el.h" +#include "type.h" +#include "filespec.h" + +#if NEWMANGLE + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +#define BUFIDMAX (2 * IDMAX) + +struct Mangle +{ + char buf[BUFIDMAX + 2]; + + char *np; // index into buf[] + + // Used for compression of redundant znames + const char *zname[10]; + int znamei; + + type *arg[10]; // argument_replicator + int argi; // number used in arg[] +}; + +static Mangle mangle; + +static int mangle_inuse; + +struct MangleInuse +{ + MangleInuse() + { +#if 0 + assert(mangle_inuse == 0); + mangle_inuse++; +#endif + } + + ~MangleInuse() + { +#if 0 + assert(mangle_inuse == 1); + mangle_inuse--; +#endif + } +}; + +/* Names for special variables */ +char cpp_name_new[] = "?2"; +char cpp_name_delete[] = "?3"; +char cpp_name_anew[] = "?_P"; +char cpp_name_adelete[] = "?_Q"; +char cpp_name_ct[] = "?0"; +char cpp_name_dt[] = "?1"; +char cpp_name_as[] = "?4"; +char cpp_name_vc[] = "?_H"; +char cpp_name_primdt[] = "?_D"; +char cpp_name_scaldeldt[] = "?_G"; +char cpp_name_priminv[] = "?_R"; + +STATIC int cpp_cvidx ( tym_t ty ); +STATIC int cpp_protection ( symbol *s ); +STATIC void cpp_decorated_name ( symbol *s ); +STATIC void cpp_symbol_name ( symbol *s ); +STATIC void cpp_zname ( const char *p ); +STATIC void cpp_scope ( symbol *s ); +STATIC void cpp_type_encoding ( symbol *s ); +STATIC void cpp_external_function_type(symbol *s); +STATIC void cpp_external_data_type ( symbol *s ); +STATIC void cpp_member_function_type ( symbol *s ); +STATIC void cpp_static_member_function_type ( symbol *s ); +STATIC void cpp_static_member_data_type ( symbol *s ); +STATIC void cpp_local_static_data_type ( symbol *s ); +STATIC void cpp_vftable_type(symbol *s); +STATIC void cpp_adjustor_thunk_type(symbol *s); +STATIC void cpp_function_type ( type *t ); +STATIC void cpp_throw_types ( type *t ); +STATIC void cpp_ecsu_name ( symbol *s ); +STATIC void cpp_return_type ( symbol *s ); +STATIC void cpp_data_type ( type *t ); +STATIC void cpp_storage_convention ( symbol *s ); +STATIC void cpp_this_type ( type *t,Classsym *s ); +STATIC void cpp_vcall_model_type ( void ); +STATIC void cpp_calling_convention ( type *t ); +STATIC void cpp_argument_types ( type *t ); +STATIC void cpp_argument_list ( type *t, int flag ); +STATIC void cpp_primary_data_type ( type *t ); +STATIC void cpp_reference_type ( type *t ); +STATIC void cpp_pointer_type ( type *t ); +STATIC void cpp_ecsu_data_indirect_type ( type *t ); +STATIC void cpp_data_indirect_type ( type *t ); +STATIC void cpp_function_indirect_type ( type *t ); +STATIC void cpp_basic_data_type ( type *t ); +STATIC void cpp_ecsu_data_type(type *t); +STATIC void cpp_pointer_data_type ( type *t ); +STATIC void cpp_reference_data_type ( type *t, int flag ); +STATIC void cpp_enum_name ( symbol *s ); +STATIC void cpp_dimension ( targ_ullong u ); +STATIC void cpp_dimension_ld ( targ_ldouble ld ); +STATIC void cpp_string ( char *s, size_t len ); + +/**************************** + */ + +struct OPTABLE +#if MARS +{ + unsigned char tokn; + unsigned char oper; + char __near *string; + char *pretty; +} +#endif + oparray[] = { + { TKnew, OPnew, cpp_name_new, "new" }, + { TKdelete, OPdelete, cpp_name_delete,"del" }, + { TKadd, OPadd, "?H", "+" }, + { TKadd, OPuadd, "?H", "+" }, + { TKmin, OPmin, "?G", "-" }, + { TKmin, OPneg, "?G", "-" }, + { TKstar, OPmul, "?D", "*" }, + { TKstar, OPind, "?D", "*" }, + { TKdiv, OPdiv, "?K", "/" }, + { TKmod, OPmod, "?L", "%" }, + { TKxor, OPxor, "?T", "^" }, + { TKand, OPand, "?I", "&" }, + { TKand, OPaddr, "?I", "&" }, + { TKor, OPor, "?U", "|" }, + { TKcom, OPcom, "?S", "~" }, + { TKnot, OPnot, "?7", "!" }, + { TKeq, OPeq, cpp_name_as, "=" }, + { TKeq, OPstreq, "?4", "=" }, + { TKlt, OPlt, "?M", "<" }, + { TKgt, OPgt, "?O", ">" }, + { TKnew, OPanew, cpp_name_anew, "n[]" }, + { TKdelete, OPadelete, cpp_name_adelete,"d[]" }, + { TKunord, OPunord, "?_S", "!<>=" }, + { TKlg, OPlg, "?_T", "<>" }, + { TKleg, OPleg, "?_U", "<>=" }, + { TKule, OPule, "?_V", "!>" }, + { TKul, OPul, "?_W", "!>=" }, + { TKuge, OPuge, "?_X", "!<" }, + { TKug, OPug, "?_Y", "!<=" }, + { TKue, OPue, "?_Z", "!<>" }, + { TKaddass, OPaddass, "?Y", "+=" }, + { TKminass, OPminass, "?Z", "-=" }, + { TKmulass, OPmulass, "?X", "*=" }, + { TKdivass, OPdivass, "?_0", "/=" }, + { TKmodass, OPmodass, "?_1", "%=" }, + { TKxorass, OPxorass, "?_6", "^=" }, + { TKandass, OPandass, "?_4", "&=" }, + { TKorass, OPorass, "?_5", "|=" }, + { TKshl, OPshl, "?6", "<<" }, + { TKshr, OPshr, "?5", ">>" }, + { TKshrass, OPshrass, "?_2", ">>=" }, + { TKshlass, OPshlass, "?_3", "<<=" }, + { TKeqeq, OPeqeq, "?8", "==" }, + { TKne, OPne, "?9", "!=" }, + { TKle, OPle, "?N", "<=" }, + { TKge, OPge, "?P", ">=" }, + { TKandand, OPandand, "?V", "&&" }, + { TKoror, OPoror, "?W", "||" }, + { TKplpl, OPpostinc, "?E", "++" }, + { TKplpl, OPpreinc, "?E", "++" }, + { TKmimi, OPpostdec, "?F", "--" }, + { TKmimi, OPpredec, "?F", "--" }, + { TKlpar, OPcall, "?R", "()" }, + { TKlbra, OPbrack, "?A", "[]" }, + { TKarrow, OParrow, "?C", "->" }, + { TKcomma, OPcomma, "?Q", "," }, + { TKarrowstar, OParrowstar, "?J", "->*" }, +}; + +/**************************************** + * Convert from identifier to operator + */ + +#if __GNUC__ // NOT DONE - FIX +char * unmangle_pt(const char **s) +{ + return (char *)*s; +} +#else +#if __cplusplus +extern "C" +#endif + char * __cdecl unmangle_pt(const char **); + +#endif + +char *cpp_unmangleident(const char *p) +{ int i; + MangleInuse m; + + //printf("cpp_unmangleident('%s')\n", p); + if (*p == '$') // if template name + { char *s; + const char *q; + + L1: + q = p; + s = unmangle_pt(&q); + if (s) + { if (strlen(s) <= BUFIDMAX) + p = strcpy(mangle.buf, s); + free(s); + } + } + else if (*p == '?') // if operator name + { int i; + + if (NEWTEMPMANGLE && p[1] == '$') // if template name + goto L1; + for (i = 0; i < arraysize(oparray); i++) + { if (strcmp(p,oparray[i].string) == 0) + { char *s; + + strcpy(mangle.buf, "operator "); + switch (oparray[i].oper) + { case OPanew: + s = "new[]"; + break; + case OPadelete: + s = "delete[]"; + break; + case OPdelete: + s = "delete"; + break; + default: + s = oparray[i].pretty; + break; + } + strcat(mangle.buf,s); + p = mangle.buf; + break; + } + } + } + //printf("-cpp_unmangleident() = '%s'\n", p); + return (char *)p; +} + +/**************************************** + * Find index in oparray[] for operator. + * Returns: + * index or -1 if not found + */ + +int cpp_opidx(int op) +{ int i; + + for (i = 0; i < arraysize(oparray); i++) + if (oparray[i].oper == op) + return i; + return -1; +} + +/*************************************** + * Find identifier string associated with operator. + * Returns: + * NULL if not found + */ + +#if SCPP + +char *cpp_opident(int op) +{ int i; + + i = cpp_opidx(op); + return (i == -1) ? NULL : oparray[i].string; +} + +#endif + +/********************************** + * Convert from operator token to name. + * Output: + * *poper OPxxxx + * *pt set to type for user defined conversion + * Returns: + * pointer to corresponding name + */ + +#if SCPP + +char *cpp_operator(int *poper,type **pt) +{ + int i; + type *typ_spec; + char *s; + + *pt = NULL; + stoken(); /* skip over operator keyword */ + for (i = 0; i < arraysize(oparray); i++) + { if (oparray[i].tokn == tok.TKval) + goto L1; + } + + /* Look for type conversion */ + if (type_specifier(&typ_spec)) + { type *t; + + t = ptr_operator(typ_spec); // parse ptr-operator + fixdeclar(t); + type_free(typ_spec); + *pt = t; + return cpp_typetostring(t,"?B"); + } + + cpperr(EM_not_overloadable); // that token cannot be overloaded + s = "_"; + goto L2; + +L1: + s = oparray[i].string; + *poper = oparray[i].oper; + switch (*poper) + { case OPcall: + if (stoken() != TKrpar) + synerr(EM_rpar); /* ')' expected */ + break; + + case OPbrack: + if (stoken() != TKrbra) + synerr(EM_rbra); /* ']' expected */ + break; + + case OPnew: + if (stoken() != TKlbra) + goto Lret; + *poper = OPanew; // operator new[] + s = cpp_name_anew; + goto L3; + + case OPdelete: + if (stoken() != TKlbra) + goto Lret; + *poper = OPadelete; // operator delete[] + s = cpp_name_adelete; + L3: + if (stoken() != TKrbra) + synerr(EM_rbra); // ']' expected + if (!(config.flags4 & CFG4anew)) + { cpperr(EM_enable_anew); // throw -Aa to support this + config.flags4 |= CFG4anew; + } + break; + } +L2: + stoken(); +Lret: + return s; +} + +/****************************************** + * Alternate version that works on a list of token's. + * Input: + * to list of tokens + * Output: + * *pcastoverload 1 if user defined type conversion + */ + +char *cpp_operator2(token_t *to, int *pcastoverload) +{ + int i; + char *s; + token_t *tn; + int oper; + + *pcastoverload = 0; + if (!to || !to->TKnext) + return NULL; + + for (i = 0; i < arraysize(oparray); i++) + { + //printf("[%d] %d, %d\n", i, oparray[i].tokn, tok.TKval); + if (oparray[i].tokn == to->TKval) + goto L1; + } + + //printf("cpp_operator2(): castoverload\n"); + *pcastoverload = 1; + return NULL; + +L1: + tn = to->TKnext; + s = oparray[i].string; + oper = oparray[i].oper; + switch (oper) + { case OPcall: + if (tn->TKval != TKrpar) + synerr(EM_rpar); // ')' expected + break; + + case OPbrack: + if (tn->TKval != TKrbra) + synerr(EM_rbra); // ']' expected + break; + + case OPnew: + if (tn->TKval != TKlbra) + break; + oper = OPanew; // operator new[] + s = cpp_name_anew; + goto L3; + + case OPdelete: + if (tn->TKval != TKlbra) + break; + oper = OPadelete; // operator delete[] + s = cpp_name_adelete; + L3: + if (tn->TKval != TKrbra) + synerr(EM_rbra); // ']' expected + if (!(config.flags4 & CFG4anew)) + { cpperr(EM_enable_anew); // throw -Aa to support this + config.flags4 |= CFG4anew; + } + break; + } +Lret: + return s; +} + +#endif + +/*********************************** + * Generate and return a pointer to a string constructed from + * the type, appended to the prefix. + * Since these generated strings determine the uniqueness of names, + * they are also used to determine if two types are the same. + * Returns: + * pointer to static name[] + */ + +char *cpp_typetostring(type *t,char *prefix) +{ int i; + + if (prefix) + { strcpy(mangle.buf,prefix); + i = strlen(prefix); + } + else + i = 0; + //dbg_printf("cpp_typetostring:\n"); + //type_print(t); + MangleInuse m; + mangle.znamei = 0; + mangle.argi = 0; + mangle.np = mangle.buf + i; + mangle.buf[BUFIDMAX + 1] = 0x55; + cpp_data_type(t); + *mangle.np = 0; // 0-terminate mangle.buf[] + //dbg_printf("cpp_typetostring: '%s'\n", mangle.buf); + assert(strlen(mangle.buf) <= BUFIDMAX); + assert(mangle.buf[BUFIDMAX + 1] == 0x55); + return mangle.buf; +} + +/******************************** + * 'Mangle' a name for output. + * Returns: + * pointer to mangled name (a static buffer) + */ + +char *cpp_mangle(symbol *s) +{ + symbol_debug(s); + //printf("cpp_mangle(s = %p, '%s')\n", s, s->Sident); + //type_print(s->Stype); + +#if SCPP + if (!CPP) + return symbol_ident(s); +#endif + + if (type_mangle(s->Stype) != mTYman_cpp) + return symbol_ident(s); + else + { + MangleInuse m; + + mangle.znamei = 0; + mangle.argi = 0; + mangle.np = mangle.buf; + mangle.buf[BUFIDMAX + 1] = 0x55; + cpp_decorated_name(s); + *mangle.np = 0; // 0-terminate cpp_name[] + //dbg_printf("cpp_mangle() = '%s'\n", mangle.buf); + assert(strlen(mangle.buf) <= BUFIDMAX); + assert(mangle.buf[BUFIDMAX + 1] == 0x55); + return mangle.buf; + } +} + +/////////////////////////////////////////////////////// + +/********************************* + * Add char into cpp_name[]. + */ + +STATIC void __inline CHAR(char c) +{ + if (mangle.np < &mangle.buf[BUFIDMAX]) + *mangle.np++ = c; +} + +/********************************* + * Add char into cpp_name[]. + */ + +STATIC void STR(const char *p) +{ + size_t len; + + len = strlen(p); + if (mangle.np + len <= &mangle.buf[BUFIDMAX]) + { memcpy(mangle.np,p,len); + mangle.np += len; + } + else + for (; *p; p++) + CHAR(*p); +} + +/*********************************** + * Convert const volatile combinations into 0..3 + */ + +STATIC int cpp_cvidx(tym_t ty) +{ int i; + + i = (ty & mTYconst) ? 1 : 0; + i |= (ty & mTYvolatile) ? 2 : 0; + return i; +} + +/****************************** + * Turn protection into 0..2 + */ + +STATIC int cpp_protection(symbol *s) +{ int i; + + switch (s->Sflags & SFLpmask) + { case SFLprivate: i = 0; break; + case SFLprotected: i = 1; break; + case SFLpublic: i = 2; break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + return i; +} + +/*********************************** + * Create mangled name for template instantiation. + */ + +#if SCPP + +char *template_mangle(symbol *s,param_t *arglist) +{ + /* mangling ::= '$' template_name { type | expr } + type ::= "T" mangled type + expr ::= integer | string | address | float | double | long_double + integer ::= "I" dimension + string ::= "S" string + address ::= "R" zname + float ::= "F" hex_digits + double ::= "D" hex_digits + long_double ::= "L" hex_digits + */ + param_t *p; + + assert(s); + symbol_debug(s); + //assert(s->Sclass == SCtemplate); + + //printf("\ntemplate_mangle(s = '%s', arglist = %p)\n", s->Sident, arglist); + //arglist->print_list(); + + MangleInuse m; + mangle.znamei = 0; + mangle.argi = 0; + mangle.np = mangle.buf; + mangle.buf[BUFIDMAX + 1] = 0x55; + + if (NEWTEMPMANGLE) + STR("?$"); + else + CHAR('$'); + + // BUG: this is for templates nested inside class scopes. + // Need to check if it creates names that are properly unmanglable. + cpp_zname(s->Sident); + if (s->Sscope) + cpp_scope(s->Sscope); + + for (p = arglist; p; p = p->Pnext) + { + if (p->Ptype) + { /* Argument is a type */ + if (!NEWTEMPMANGLE) + CHAR('T'); + cpp_argument_list(p->Ptype, 1); + } + else if (p->Psym) + { + CHAR('V'); // this is a 'class' name, but it should be a 'template' name + cpp_ecsu_name(p->Psym); + } + else + { /* Argument is an expression */ + elem *e = p->Pelem; + tym_t ty = tybasic(e->ET->Tty); + char *p; + char a[2]; + int ni; + char c; + + L2: + switch (e->Eoper) + { case OPconst: + switch (ty) + { case TYfloat: ni = FLOATSIZE; c = 'F'; goto L1; + case TYdouble_alias: + case TYdouble: ni = DOUBLESIZE; c = 'D'; goto L1; + case TYldouble: ni = LNGDBLSIZE; c = 'L'; goto L1; + L1: + if (NEWTEMPMANGLE) + CHAR('$'); + CHAR(c); + p = (char *)&e->EV.Vdouble; + while (ni--) + { char c; +#if __GNUC__ + static char hex[16] = + {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; +#else + static char hex[16] = "0123456789ABCDEF"; +#endif + + c = *p++; + CHAR(hex[c & 15]); + CHAR(hex[(c >> 4) & 15]); + } + break; + default: +#ifdef DEBUG + if (!tyintegral(ty) && !tymptr(ty)) + elem_print(e); +#endif + assert(tyintegral(ty) || tymptr(ty)); + if (NEWTEMPMANGLE) + STR("$0"); + else + CHAR('I'); + cpp_dimension(el_tolongt(e)); + break; + } + break; + case OPstring: + if (NEWTEMPMANGLE) + STR("$S"); + else + CHAR('S'); + if (e->EV.ss.Voffset) + synerr(EM_const_init); // constant initializer expected + cpp_string(e->EV.ss.Vstring,e->EV.ss.Vstrlen); + break; + case OPrelconst: + if (e->EV.sp.Voffset) + synerr(EM_const_init); // constant initializer expected + s = e->EV.sp.Vsym; + if (NEWTEMPMANGLE) + { STR("$1"); + cpp_decorated_name(s); + } + else + { CHAR('R'); + cpp_zname(s->Sident); + } + break; + case OPvar: + if (e->EV.sp.Vsym->Sflags & SFLvalue && + tybasic(e->ET->Tty) != TYstruct) + { + e = e->EV.sp.Vsym->Svalue; + goto L2; + } + else if (e->EV.sp.Vsym->Sclass == SCconst /*&& + pstate.STintemplate*/) + { + CHAR('V'); // pretend to be a class name + cpp_zname(e->EV.sp.Vsym->Sident); + break; + } + default: +#if SCPP +#ifdef DEBUG + if (!errcnt) + elem_print(e); +#endif + synerr(EM_const_init); // constant initializer expected + assert(errcnt); +#endif + break; + } + } + } + *mangle.np = 0; + //printf("template_mangle() = '%s'\n", mangle.buf); + assert(strlen(mangle.buf) <= BUFIDMAX); + assert(mangle.buf[BUFIDMAX + 1] == 0x55); + return mangle.buf; +} + +#endif + +////////////////////////////////////////////////////// +// Functions corresponding to the name mangling grammar in the +// "Microsoft Object Mapping Specification" + +STATIC void cpp_string(char *s,size_t len) +{ char c; + + for (; --len; s++) + { static char special_char[] = ",/\\:. \n\t'-"; + char *p; + + c = *s; + if (c & 0x80 && isalpha(c & 0x7F)) + { CHAR('?'); + c &= 0x7F; + } + else if (isalnum(c)) + ; + else + { + CHAR('?'); + if ((p = (char *)strchr(special_char,c)) != NULL) + c = '0' + (p - special_char); + else + { + CHAR('$'); + CHAR('A' + ((c >> 4) & 0x0F)); + c = 'A' + (c & 0x0F); + } + } + CHAR(c); + } + CHAR('@'); +} + +STATIC void cpp_dimension(targ_ullong u) +{ + if (u && u <= 10) + CHAR('0' + (char)u - 1); + else + { char buffer[sizeof(u) * 2 + 1]; + char __ss *p; + + buffer[sizeof(buffer) - 1] = 0; + for (p = &buffer[sizeof(buffer) - 1]; u; u >>= 4) + { + *--p = 'A' + (u & 0x0F); + } + STR(p); + CHAR('@'); + } +} + +#if 0 +STATIC void cpp_dimension_ld(targ_ldouble ld) +{ unsigned char ldbuf[sizeof(targ_ldouble)]; + + memcpy(ldbuf,&ld,sizeof(ld)); + if (u && u <= 10) + CHAR('0' + (char)u - 1); + else + { char buffer[sizeof(u) * 2 + 1]; + char __ss *p; + + buffer[sizeof(buffer) - 1] = 0; + for (p = &buffer[sizeof(buffer) - 1]; u; u >>= 4) + { + *--p = 'A' + (u & 0x0F); + } + STR(p); + CHAR('@'); + } +} +#endif + +STATIC void cpp_enum_name(symbol *s) +{ type *t; + char c; + + t = tsint; + switch (tybasic(t->Tty)) + { + case TYschar: c = '0'; break; + case TYuchar: c = '1'; break; + case TYshort: c = '2'; break; + case TYushort: c = '3'; break; + case TYint: c = '4'; break; + case TYuint: c = '5'; break; + case TYlong: c = '6'; break; + case TYulong: c = '7'; break; + default: assert(0); + } + CHAR(c); + cpp_ecsu_name(s); +} + +STATIC void cpp_reference_data_type(type *t, int flag) +{ + if (tybasic(t->Tty) == TYarray) + { + int ndim; + type *tn; + int i; + + CHAR('Y'); + + // Compute number of dimensions (we have at least one) + ndim = 0; + tn = t; + do + { ndim++; + tn = tn->Tnext; + } while (tybasic(tn->Tty) == TYarray); + + cpp_dimension(ndim); + for (; tybasic(t->Tty) == TYarray; t = t->Tnext) + { + if (t->Tflags & TFvla) + CHAR('X'); // DMC++ extension + else + cpp_dimension(t->Tdim); + } + + // DMC++ extension + if (flag) // if template type argument + { + i = cpp_cvidx(t->Tty); + if (i) + { CHAR('_'); + //CHAR('X' + i - 1); // _X, _Y, _Z + CHAR('O' + i - 1); // _O, _P, _Q + } + } + + cpp_basic_data_type(t); + } + else + cpp_basic_data_type(t); +} + +STATIC void cpp_pointer_data_type(type *t) +{ + if (tybasic(t->Tty) == TYvoid) + CHAR('X'); + else + cpp_reference_data_type(t, 0); +} + +STATIC void cpp_ecsu_data_type(type *t) +{ char c; + symbol *stag; + int i; + + type_debug(t); + switch (tybasic(t->Tty)) + { + case TYstruct: + stag = t->Ttag; + switch (stag->Sstruct->Sflags & (STRclass | STRunion)) + { case 0: c = 'U'; break; + case STRunion: c = 'T'; break; + case STRclass: c = 'V'; break; + default: + assert(0); + } + CHAR(c); + cpp_ecsu_name(stag); + break; + case TYenum: + CHAR('W'); + cpp_enum_name(t->Ttag); + break; + default: +#ifdef DEBUG + type_print(t); +#endif + assert(0); + } +} + +STATIC void cpp_basic_data_type(type *t) +{ char c; + int i; + + //printf("cpp_basic_data_type(t)\n"); + //type_print(t); + switch (tybasic(t->Tty)) + { + case TYschar: c = 'C'; goto dochar; + case TYchar: c = 'D'; goto dochar; + case TYuchar: c = 'E'; goto dochar; + case TYshort: c = 'F'; goto dochar; + case TYushort: c = 'G'; goto dochar; + case TYint: c = 'H'; goto dochar; + case TYuint: c = 'I'; goto dochar; + case TYlong: c = 'J'; goto dochar; + case TYulong: c = 'K'; goto dochar; + case TYfloat: c = 'M'; goto dochar; + case TYdouble: c = 'N'; goto dochar; + + case TYdouble_alias: + if (intsize == 4) + { c = 'O'; + goto dochar; + } + c = 'Z'; + goto dochar2; + + case TYldouble: + if (intsize == 2) + { c = 'O'; + goto dochar; + } + c = 'Z'; + goto dochar2; + dochar: + CHAR(c); + break; + + case TYllong: c = 'J'; goto dochar2; + case TYullong: c = 'K'; goto dochar2; + case TYbool: c = 'N'; goto dochar2; // was 'X' prior to 8.1b8 + case TYwchar_t: + if (config.flags4 & CFG4nowchar_t) + { + c = 'G'; + goto dochar; // same as TYushort + } + else + { + pstate.STflags |= PFLmfc; + c = 'Y'; + goto dochar2; + } + + // Digital Mars extensions + case TYifloat: c = 'R'; goto dochar2; + case TYidouble: c = 'S'; goto dochar2; + case TYildouble: c = 'T'; goto dochar2; + case TYcfloat: c = 'U'; goto dochar2; + case TYcdouble: c = 'V'; goto dochar2; + case TYcldouble: c = 'W'; goto dochar2; + + case TYchar16: c = 'X'; goto dochar2; + case TYdchar: c = 'Y'; goto dochar2; + case TYnullptr: c = 'Z'; goto dochar2; + + dochar2: + CHAR('_'); + goto dochar; + +#if TARGET_SEGMENTED + case TYsptr: + case TYcptr: + case TYf16ptr: + case TYfptr: + case TYhptr: + case TYvptr: +#endif +#if !MARS + case TYmemptr: +#endif + case TYnptr: + c = 'P' + cpp_cvidx(t->Tty); + CHAR(c); + cpp_pointer_type(t); + break; + case TYstruct: + case TYenum: + cpp_ecsu_data_type(t); + break; + case TYarray: + i = cpp_cvidx(t->Tty); + i |= 1; // always const + CHAR('P' + i); + cpp_pointer_type(t); + break; + case TYvoid: + c = 'X'; + goto dochar; +#if !MARS + case TYident: + if (pstate.STintemplate) + { + CHAR('V'); // pretend to be a class name + cpp_zname(t->Tident); + } + else + { +#if SCPP + cpperr(EM_no_type,t->Tident); // no type for argument +#endif + c = 'X'; + goto dochar; + } + break; + case TYtemplate: + if (pstate.STintemplate) + { + CHAR('V'); // pretend to be a class name + cpp_zname(((typetemp_t *)t)->Tsym->Sident); + } + else + goto Ldefault; + break; +#endif + + default: + Ldefault: + if (tyfunc(t->Tty)) + cpp_function_type(t); + else + { +#if SCPP +#ifdef DEBUG + if (!errcnt) + type_print(t); +#endif + assert(errcnt); +#endif + } + } +} + +STATIC void cpp_function_indirect_type(type *t) +{ int farfunc; + + farfunc = tyfarfunc(t->Tnext->Tty) != 0; +#if !MARS + if (tybasic(t->Tty) == TYmemptr) + { + CHAR('8' + farfunc); + cpp_scope(t->Ttag); + CHAR('@'); + //cpp_this_type(t->Tnext,t->Ttag); // MSC doesn't do this + } + else +#endif + CHAR('6' + farfunc); +} + +STATIC void cpp_data_indirect_type(type *t) +{ int i; +#if !MARS + if (tybasic(t->Tty) == TYmemptr) // if pointer to member + { + i = cpp_cvidx(t->Tty); + if (t->Tty & mTYfar) + i += 4; + CHAR('Q' + i); + cpp_scope(t->Ttag); + CHAR('@'); + } + else +#endif + cpp_ecsu_data_indirect_type(t); +} + +STATIC void cpp_ecsu_data_indirect_type(type *t) +{ int i; + tym_t ty; + + i = 0; + if (t->Tnext) + { ty = t->Tnext->Tty & (mTYconst | mTYvolatile); + switch (tybasic(t->Tty)) + { +#if TARGET_SEGMENTED + case TYfptr: + case TYvptr: + case TYfref: + ty |= mTYfar; + break; + + case TYhptr: + i += 8; + break; + case TYref: + case TYarray: + if (LARGEDATA && !(ty & mTYLINK)) + ty |= mTYfar; + break; +#endif + } + } + else + ty = t->Tty & (mTYLINK | mTYconst | mTYvolatile); + i |= cpp_cvidx(ty); +#if TARGET_SEGMENTED + if (ty & (mTYcs | mTYfar)) + i += 4; +#endif + CHAR('A' + i); +} + +STATIC void cpp_pointer_type(type *t) +{ tym_t ty; + + if (tyfunc(t->Tnext->Tty)) + { + cpp_function_indirect_type(t); + cpp_function_type(t->Tnext); + } + else + { + cpp_data_indirect_type(t); + cpp_pointer_data_type(t->Tnext); + } +} + +STATIC void cpp_reference_type(type *t) +{ + cpp_data_indirect_type(t); + cpp_reference_data_type(t->Tnext, 0); +} + +STATIC void cpp_primary_data_type(type *t) +{ + if (tyref(t->Tty)) + { +#if 1 + // C++98 8.3.2 says cv-qualified references are ignored + CHAR('A'); +#else + switch (t->Tty & (mTYconst | mTYvolatile)) + { + case 0: CHAR('A'); break; + case mTYvolatile: CHAR('B'); break; + + // Digital Mars extensions + case mTYconst | mTYvolatile: CHAR('_'); CHAR('L'); break; + case mTYconst: CHAR('_'); CHAR('M'); break; + } +#endif + cpp_reference_type(t); + } + else + cpp_basic_data_type(t); +} + +/***** + * flag: 1 = template argument + */ + +STATIC void cpp_argument_list(type *t, int flag) +{ int i; + tym_t ty; + + //printf("cpp_argument_list(flag = %d)\n", flag); + // If a data type that encodes only into one character + ty = tybasic(t->Tty); + if (ty <= TYldouble && ty != TYenum + && ty != TYbool // added for versions >= 8.1b9 +#if OVERLOAD_CV_PARAM + && !(t->Tty & (mTYconst | mTYvolatile)) +#endif + ) + { + cpp_primary_data_type(t); + } + else + { + // See if a match with a previously used type + for (i = 0; 1; i++) + { + if (i == mangle.argi) // no match + { +#if OVERLOAD_CV_PARAM + if (ty <= TYcldouble || ty == TYstruct) + { + int cvidx = cpp_cvidx(t->Tty); + if (cvidx) + { + // Digital Mars extensions + CHAR('_'); + CHAR('N' + cvidx); // _O, _P, _Q prefix + } + } +#endif + if (flag && tybasic(t->Tty) == TYarray) + { + cpp_reference_data_type(t, flag); + } + else + cpp_primary_data_type(t); + if (mangle.argi < 10) + mangle.arg[mangle.argi++] = t; + break; + } + if (typematch(t,mangle.arg[i],0)) + { + CHAR('0' + i); // argument_replicator + break; + } + } + } +} + +STATIC void cpp_argument_types(type *t) +{ param_t *p; + char c; + + //printf("cpp_argument_types()\n"); + //type_debug(t); + for (p = t->Tparamtypes; p; p = p->Pnext) + cpp_argument_list(p->Ptype, 0); + if (t->Tflags & TFfixed) + c = t->Tparamtypes ? '@' : 'X'; + else + c = 'Z'; + CHAR(c); +} + +STATIC void cpp_calling_convention(type *t) +{ char c; + + switch (tybasic(t->Tty)) + { + case TYnfunc: + case TYhfunc: +#if TARGET_SEGMENTED + case TYffunc: +#endif + c = 'A'; break; +#if TARGET_SEGMENTED + case TYf16func: + case TYfpfunc: +#endif + case TYnpfunc: + c = 'C'; break; + case TYnsfunc: +#if TARGET_SEGMENTED + case TYfsfunc: +#endif + c = 'G'; break; + case TYjfunc: + case TYmfunc: +#if TARGET_SEGMENTED + case TYnsysfunc: + case TYfsysfunc: +#endif + c = 'E'; break; + case TYifunc: + c = 'K'; break; + default: + assert(0); + } + CHAR(c); +} + +STATIC void cpp_vcall_model_type() +{ +} + +#if SCPP || MARS + +STATIC void cpp_this_type(type *tfunc,Classsym *stag) +{ type *t; + + type_debug(tfunc); + symbol_debug(stag); +#if MARS + t = type_allocn(TYnptr, stag->Stype); + t->Tcount++; +#else + t = cpp_thistype(tfunc,stag); +#endif + //cpp_data_indirect_type(t); + cpp_ecsu_data_indirect_type(t); + type_free(t); +} + +#endif + +STATIC void cpp_storage_convention(symbol *s) +{ tym_t ty; + type *t = s->Stype; + + ty = t->Tty; +#if TARGET_SEGMENTED + if (LARGEDATA && !(ty & mTYLINK)) + t->Tty |= mTYfar; +#endif + cpp_data_indirect_type(t); + t->Tty = ty; +} + +STATIC void cpp_data_type(type *t) +{ + type_debug(t); + switch (tybasic(t->Tty)) + { case TYvoid: + CHAR('X'); + break; + case TYstruct: + case TYenum: + CHAR('?'); + cpp_ecsu_data_indirect_type(t); + cpp_ecsu_data_type(t); + break; + default: + cpp_primary_data_type(t); + break; + } +} + +STATIC void cpp_return_type(symbol *s) +{ + if (s->Sfunc->Fflags & (Fctor | Fdtor)) // if ctor or dtor + CHAR('@'); // no type + else + cpp_data_type(s->Stype->Tnext); +} + +STATIC void cpp_ecsu_name(symbol *s) +{ + //printf("cpp_ecsu_name(%s)\n", symbol_ident(s)); + cpp_zname(symbol_ident(s)); +#if SCPP || MARS + if (s->Sscope) + cpp_scope(s->Sscope); +#endif + CHAR('@'); +} + +STATIC void cpp_throw_types(type *t) +{ + //cpp_argument_types(?); + CHAR('Z'); +} + +STATIC void cpp_function_type(type *t) +{ tym_t ty; + type *tn; + + //printf("cpp_function_type()\n"); + //type_debug(t); + assert(tyfunc(t->Tty)); + cpp_calling_convention(t); + //cpp_return_type(s); + tn = t->Tnext; + ty = tn->Tty; +#if TARGET_SEGMENTED + if (LARGEDATA && (tybasic(ty) == TYstruct || tybasic(ty) == TYenum) && + !(ty & mTYLINK)) + tn->Tty |= mTYfar; +#endif + cpp_data_type(tn); + tn->Tty = ty; + cpp_argument_types(t); + cpp_throw_types(t); +} + +STATIC void cpp_adjustor_thunk_type(symbol *s) +{ +} + +STATIC void cpp_vftable_type(symbol *s) +{ + cpp_ecsu_data_indirect_type(s->Stype); +// vpath_name(); + CHAR('@'); +} + +STATIC void cpp_local_static_data_type(symbol *s) +{ + //cpp_lexical_frame(?); + cpp_external_data_type(s); +} + +STATIC void cpp_static_member_data_type(symbol *s) +{ + cpp_external_data_type(s); +} + +STATIC void cpp_static_member_function_type(symbol *s) +{ + cpp_function_type(s->Stype); +} + +#if SCPP || MARS +STATIC void cpp_member_function_type(symbol *s) +{ + assert(tyfunc(s->Stype->Tty)); + cpp_this_type(s->Stype,(Classsym *)s->Sscope); + if (s->Sfunc->Fflags & (Fctor | Fdtor)) + { type *t = s->Stype; + + cpp_calling_convention(t); + CHAR('@'); // return_type for ctors & dtors + cpp_argument_types(t); + cpp_throw_types(t); + } + else + cpp_static_member_function_type(s); +} +#endif + +STATIC void cpp_external_data_type(symbol *s) +{ + cpp_primary_data_type(s->Stype); + cpp_storage_convention(s); +} + +STATIC void cpp_external_function_type(symbol *s) +{ + cpp_function_type(s->Stype); +} + +STATIC void cpp_type_encoding(symbol *s) +{ char c; + + //printf("cpp_type_encoding()\n"); + if (tyfunc(s->Stype->Tty)) + { int farfunc; + + farfunc = tyfarfunc(s->Stype->Tty) != 0; +#if SCPP || MARS + if (isclassmember(s)) + { // Member function + int protection; + int ftype; + + protection = cpp_protection(s); + if (s->Sfunc->Fthunk && !(s->Sfunc->Fflags & Finstance)) + ftype = 3; + else + switch (s->Sfunc->Fflags & (Fvirtual | Fstatic)) + { case Fvirtual: ftype = 2; break; + case Fstatic: ftype = 1; break; + case 0: ftype = 0; break; + default: assert(0); + } + CHAR('A' + farfunc + protection * 8 + ftype * 2); + switch (ftype) + { case 0: cpp_member_function_type(s); break; + case 1: cpp_static_member_function_type(s); break; + case 2: cpp_member_function_type(s); break; + case 3: cpp_adjustor_thunk_type(s); break; + } + } + else +#endif + { // Non-member function + CHAR('Y' + farfunc); + cpp_external_function_type(s); + } + } + else + { +#if SCPP || MARS + if (isclassmember(s)) + { + { // Static data member + CHAR(cpp_protection(s) + '0'); + cpp_static_member_data_type(s); + } + } + else +#endif + { + if (s->Sclass == SCstatic +#if SCPP || MARS + || (s->Sscope && + s->Sscope->Sclass != SCstruct && + s->Sscope->Sclass != SCnamespace) +#endif + ) + { CHAR('4'); + cpp_local_static_data_type(s); + } + else + { CHAR('3'); + cpp_external_data_type(s); + } + } + } +} + +STATIC void cpp_scope(symbol *s) +{ + /* scope ::= + zname [ scope ] + '?' decorated_name [ scope ] + '?' lexical_frame [ scope ] + '?' '$' template_name [ scope ] + */ + while (s) + { char *p; + + symbol_debug(s); + switch (s->Sclass) + { + case SCnamespace: + cpp_zname(s->Sident); + break; + + case SCstruct: + cpp_zname(symbol_ident(s)); + break; + + default: + STR("?1?"); // Why? Who knows. + cpp_decorated_name(s); + break; + } +#if SCPP || MARS + s = s->Sscope; +#else + break; +#endif + } +} + +STATIC void cpp_zname(const char *p) +{ + //printf("cpp_zname(%s)\n", p); + if (*p != '?' || // if not operator_name + (NEWTEMPMANGLE && p[1] == '$')) // ?$ is a template name + { +#if MARS + /* Scan forward past any dots + */ + for (const char *q = p; *q; q++) + { + if (*q == '.') + p = q + 1; + } +#endif + + for (int i = 0; i < mangle.znamei; i++) + { + if (strcmp(p,mangle.zname[i]) == 0) + { CHAR('0' + i); + return; + } + } + if (mangle.znamei < 10) + mangle.zname[mangle.znamei++] = p; + STR(p); + CHAR('@'); + } + else if (p[1] == 'B') + STR("?B"); // skip return value encoding + else + { + STR(p); + } +} + +STATIC void cpp_symbol_name(symbol *s) +{ char *p; + + p = s->Sident; +#if SCPP + if (tyfunc(s->Stype->Tty) && s->Sfunc) + { + if (s->Sfunc->Fflags & Finstance) + { + Mangle save = mangle; + char *q; + int len; + + p = template_mangle(s, s->Sfunc->Fptal); + len = strlen(p); + q = (char *)alloca(len + 1); + memcpy(q, p, len + 1); + mangle = save; + p = q; + } + else if (s->Sfunc->Fflags & Foperator) + { // operator_name ::= '?' operator_code + //CHAR('?'); // already there + STR(p); + return; + } + } +#endif + cpp_zname(p); +} + +STATIC void cpp_decorated_name(symbol *s) +{ char *p; + + CHAR('?'); + cpp_symbol_name(s); +#if SCPP || MARS + if (s->Sscope) + cpp_scope(s->Sscope); +#endif + CHAR('@'); + cpp_type_encoding(s); +} + +/********************************* + * Mangle a vtbl or vbtbl name. + * Returns: + * pointer to generated symbol with mangled name + */ + +#if SCPP + +symbol *mangle_tbl( + int flag, // 0: vtbl, 1: vbtbl + type *t, // type for symbol + Classsym *stag, // class we're putting tbl in + baseclass_t *b) // base class (NULL if none) +{ const char *id; + symbol *s; + +#if 0 + dbg_printf("mangle_tbl(stag = '%s', sbase = '%s', parent = '%s')\n", + stag->Sident,b ? b->BCbase->Sident : "NULL", b ? b->parent->Sident : "NULL"); +#endif + if (flag == 0) + id = config.flags3 & CFG3rtti ? "?_Q" : "?_7"; + else + id = "?_8"; + MangleInuse m; + mangle.znamei = 0; + mangle.argi = 0; + mangle.np = mangle.buf; + CHAR('?'); + cpp_zname(id); + cpp_scope(stag); + CHAR('@'); + CHAR('6' + flag); + cpp_ecsu_data_indirect_type(t); +#if 1 + while (b) + { + cpp_scope(b->BCbase); + CHAR('@'); + b = b->BCpbase; + } +#else + if (b) + { cpp_scope(b->BCbase); + CHAR('@'); + // BUG: what if b is more than one level down? + if (b->parent != stag) + { cpp_scope(b->BCparent); + CHAR('@'); + } + } +#endif + CHAR('@'); + *mangle.np = 0; // 0-terminate mangle.buf[] + assert(strlen(mangle.buf) <= BUFIDMAX); + s = scope_define(mangle.buf,SCTglobal | SCTnspace | SCTlocal,SCunde); + s->Stype = t; + t->Tcount++; + return s; +} + +#endif + +#endif + +#endif diff --git a/backend/nteh.c b/backend/nteh.c new file mode 100644 index 00000000..f8c91249 --- /dev/null +++ b/backend/nteh.c @@ -0,0 +1,915 @@ +// Copyright (C) 1994-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Support for NT exception handling + +#include +#include +#include + +#include "cc.h" +#include "el.h" +#include "code.h" +#include "oper.h" +#include "global.h" +#include "type.h" +#include "dt.h" +#if SCPP +#include "scope.h" +#endif +#include "exh.h" + +#if !SPP && NTEXCEPTIONS + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +static symbol *s_table; +static symbol *s_context; +static char s_name_context_tag[] = "__nt_context"; +static char s_name_context[] = "__context"; +static char s_name_ecode[] = "__ecode"; + +static char text_nt[] = + "struct __nt_context {" + "int esp; int info; int prev; int handler; int stable; int sindex; int ebp;" + "};\n"; + +// member stable is not used for MARS or C++ + +int nteh_EBPoffset_sindex() { return -4; } +int nteh_EBPoffset_prev() { return -nteh_contextsym_size() + 8; } +int nteh_EBPoffset_info() { return -nteh_contextsym_size() + 4; } +int nteh_EBPoffset_esp() { return -nteh_contextsym_size() + 0; } + +int nteh_offset_sindex() { return MARS ? 16 : 20; } +int nteh_offset_sindex_seh() { return 20; } +int nteh_offset_info() { return 4; } + +/*********************************** + */ + +unsigned char *nteh_context_string() +{ + if (config.flags2 & CFG2seh) + return (unsigned char *)text_nt; + else + return NULL; +} + +/******************************* + * Get symbol for scope table for current function. + * Returns: + * symbol of table + */ + +STATIC symbol *nteh_scopetable() +{ symbol *s; + type *t; + + if (!s_table) + { + t = type_alloc(TYint); + s = symbol_generate(SCstatic,t); + s->Sseg = UNKNOWN; + symbol_keep(s); + s_table = s; + } + return s_table; +} + +/************************************* + */ + +void nteh_filltables() +{ +#if MARS + symbol *s = s_table; + symbol_debug(s); + except_fillInEHTable(s); +#endif +} + +/**************************** + * Generate and output scope table. + * Not called for NTEH C++ exceptions + */ + +void nteh_gentables() +{ + symbol *s = s_table; + symbol_debug(s); +#if MARS + //except_fillInEHTable(s); +#else + /* NTEH table for C. + * The table consists of triples: + * parent index + * filter address + * handler address + */ + unsigned fsize = 4; // target size of function pointer + dt_t **pdt = &s->Sdt; + int sz = 0; // size so far + + for (block *b = startblock; b; b = b->Bnext) + { + if (b->BC == BC_try) + { dt_t *dt; + block *bhandler; + + pdt = dtdword(pdt,b->Blast_index); // parent index + + // If try-finally + if (list_nitems(b->Bsucc) == 2) + { + pdt = dtdword(pdt,0); // filter address + bhandler = list_block(list_next(b->Bsucc)); + assert(bhandler->BC == BC_finally); + // To successor of BC_finally block + bhandler = list_block(bhandler->Bsucc); + } + else // try-except + { + bhandler = list_block(list_next(b->Bsucc)); + assert(bhandler->BC == BC_filter); + pdt = dtcoff(pdt,bhandler->Boffset); // filter address + bhandler = list_block(list_next(list_next(b->Bsucc))); + assert(bhandler->BC == BC_except); + } + pdt = dtcoff(pdt,bhandler->Boffset); // handler address + sz += 4 + fsize * 2; + } + } + assert(sz != 0); +#endif + + outdata(s); // output the scope table +#if MARS + nteh_framehandler(s); +#endif + s_table = NULL; +} + +/************************** + * Declare frame variables. + */ + +void nteh_declarvars(Blockx *bx) +{ symbol *s; + + //printf("nteh_declarvars()\n"); +#if MARS + if (!(bx->funcsym->Sfunc->Fflags3 & Fnteh)) // if haven't already done it + { bx->funcsym->Sfunc->Fflags3 |= Fnteh; + s = symbol_name(s_name_context,SCbprel,tsint); + s->Soffset = -5 * 4; // -6 * 4 for C __try, __except, __finally + s->Sflags |= SFLfree | SFLnodebug; + type_setty(&s->Stype,mTYvolatile | TYint); + symbol_add(s); + bx->context = s; + } +#else + if (!(funcsym_p->Sfunc->Fflags3 & Fnteh)) // if haven't already done it + { funcsym_p->Sfunc->Fflags3 |= Fnteh; + if (!s_context) + s_context = scope_search(s_name_context_tag,CPP ? SCTglobal : SCTglobaltag); + symbol_debug(s_context); + + s = symbol_name(s_name_context,SCbprel,s_context->Stype); + s->Soffset = -6 * 4; // -5 * 4 for C++ + s->Sflags |= SFLfree; + symbol_add(s); + type_setty(&s->Stype,mTYvolatile | TYstruct); + + s = symbol_name(s_name_ecode,SCauto,type_alloc(mTYvolatile | TYint)); + s->Sflags |= SFLfree; + symbol_add(s); + } +#endif +} + +/************************************** + * Generate elem that sets the context index into the scope table. + */ + +#if MARS +elem *nteh_setScopeTableIndex(Blockx *blx, int scope_index) +{ + elem *e; + Symbol *s; + + s = blx->context; + symbol_debug(s); + e = el_var(s); + e->EV.sp.Voffset = nteh_offset_sindex(); + return el_bin(OPeq, TYint, e, el_long(TYint, scope_index)); +} +#endif + + +/********************************** + * Return pointer to context symbol. + */ + +symbol *nteh_contextsym() +{ SYMIDX si; + symbol *sp; + + for (si = 0; 1; si++) + { assert(si < globsym.top); + sp = globsym.tab[si]; + symbol_debug(sp); + if (strcmp(sp->Sident,s_name_context) == 0) + return sp; + } +} + +/********************************** + * Return size of context symbol on stack. + */ + +unsigned nteh_contextsym_size() +{ int sz; + + if (usednteh & NTEH_try) + { +#if MARS + sz = 5 * 4; +#elif SCPP + sz = 6 * 4; +#else + assert(0); +#endif + assert(usedalloca != 1); + } + else if (usednteh & NTEHcpp) + { sz = 5 * 4; // C++ context record + assert(usedalloca != 1); + } + else if (usednteh & NTEHpassthru) + { sz = 1 * 4; + } + else + sz = 0; // no context record + return sz; +} + +/********************************** + * Return pointer to ecode symbol. + */ + +symbol *nteh_ecodesym() +{ SYMIDX si; + symbol *sp; + + for (si = 0; 1; si++) + { assert(si < globsym.top); + sp = globsym.tab[si]; + symbol_debug(sp); + if (strcmp(sp->Sident,s_name_ecode) == 0) + return sp; + } +} + +/********************************* + * Mark EH variables as used so that they don't get optimized away. + */ + +void nteh_usevars() +{ +#if SCPP + // Turn off SFLdead and SFLunambig in Sflags + nteh_contextsym()->Sflags &= ~(SFLdead | SFLunambig); + nteh_contextsym()->Sflags |= SFLread; + nteh_ecodesym()->Sflags &= ~(SFLdead | SFLunambig); + nteh_ecodesym()->Sflags |= SFLread; +#else + // Turn off SFLdead and SFLunambig in Sflags + nteh_contextsym()->Sflags &= ~SFLdead; + nteh_contextsym()->Sflags |= SFLread; +#endif +} + +/********************************* + * Generate NT exception handling function prolog. + */ + +code *nteh_prolog() +{ + code cs; + code *c1; + code *c; + + if (usednteh & NTEHpassthru) + { + /* An sindex value of -2 is a magic value that tells the + * stack unwinder to skip this frame. + */ + assert(config.exe & (EX_LINUX | EX_LINUX64 | EX_OSX | EX_OSX64 | EX_FREEBSD | EX_FREEBSD64 | EX_SOLARIS | EX_SOLARIS64)); + cs.Iop = 0x68; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL2 = FLconst; + cs.IEV2.Vint = -2; + return gen(CNIL,&cs); // PUSH -2 + } + + /* Generate instance of struct __nt_context on stack frame: + [ ] // previous ebp already there + push -1 // sindex + mov EDX,FS:__except_list + push offset FLAT:scope_table // stable (not for MARS or C++) + push offset FLAT:__except_handler3 // handler + push EDX // prev + mov FS:__except_list,ESP + sub ESP,8 // info, esp for __except support + */ + +// useregs(mAX); // What is this for? + + cs.Iop = 0x68; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL2 = FLconst; + cs.IEV2.Vint = -1; + c1 = gen(CNIL,&cs); // PUSH -1 + + if (usednteh & NTEHcpp || MARS) + { + // PUSH &framehandler + cs.IFL2 = FLframehandler; +#if MARS + nteh_scopetable(); +#endif + } + else + { + // Do stable + cs.Iflags |= CFoff; + cs.IFL2 = FLextern; + cs.IEVsym2 = nteh_scopetable(); + cs.IEVoffset2 = 0; + c1 = gen(c1,&cs); // PUSH &scope_table + + cs.IFL2 = FLextern; + cs.IEVsym2 = rtlsym[RTLSYM_EXCEPT_HANDLER3]; + makeitextern(rtlsym[RTLSYM_EXCEPT_HANDLER3]); + } + c = gen(NULL,&cs); // PUSH &__except_handler3 + + if (config.exe == EX_NT) + { + makeitextern(rtlsym[RTLSYM_EXCEPT_LIST]); + #if 0 + cs.Iop = 0xFF; + cs.Irm = modregrm(0,6,BPRM); + cs.Iflags = CFfs; + cs.Irex = 0; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + gen(c,&cs); // PUSH FS:__except_list + #else + useregs(mDX); + cs.Iop = 0x8B; + cs.Irm = modregrm(0,DX,BPRM); + cs.Iflags = CFfs; + cs.Irex = 0; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + gen(c1,&cs); // MOV EDX,FS:__except_list + + gen1(c,0x50 + DX); // PUSH EDX + #endif + cs.Iop = 0x89; + NEWREG(cs.Irm,SP); + gen(c,&cs); // MOV FS:__except_list,ESP + } + + c = genc2(c,0x81,modregrm(3,5,SP),8); // SUB ESP,8 + + return cat(c1,c); +} + +/********************************* + * Generate NT exception handling function epilog. + */ + +code *nteh_epilog() +{ + if (!(config.flags2 & CFG2seh)) + return NULL; + + /* Generate: + mov ECX,__context[EBP].prev + mov FS:__except_list,ECX + */ + code cs; + code *c; + unsigned reg; + +#if MARS + reg = CX; +#else + reg = (tybasic(funcsym_p->Stype->Tnext->Tty) == TYvoid) ? AX : CX; +#endif + useregs(mask[reg]); + + cs.Iop = 0x8B; + cs.Irm = modregrm(2,reg,BPRM); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLconst; + // EBP offset of __context.prev + cs.IEV1.Vint = nteh_EBPoffset_prev(); + c = gen(CNIL,&cs); + + cs.Iop = 0x89; + cs.Irm = modregrm(0,reg,BPRM); + cs.Iflags |= CFfs; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + return gen(c,&cs); +} + +/************************** + * Set/Reset ESP from context. + */ + +code *nteh_setsp(int op) +{ code cs; + + cs.Iop = op; + cs.Irm = modregrm(2,SP,BPRM); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLconst; + // EBP offset of __context.esp + cs.IEV1.Vint = nteh_EBPoffset_esp(); + return gen(CNIL,&cs); // MOV ESP,__context[EBP].esp +} + +/**************************** + * Put out prolog for BC_filter block. + */ + +code *nteh_filter(block *b) +{ code *c; + code cs; + + assert(b->BC == BC_filter); + c = CNIL; + if (b->Bflags & BFLehcode) // if referenced __ecode + { + /* Generate: + mov EAX,__context[EBP].info + mov EAX,[EAX] + mov EAX,[EAX] + mov __ecode[EBP],EAX + */ + + c = getregs(mAX); + + cs.Iop = 0x8B; + cs.Irm = modregrm(2,AX,BPRM); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLconst; + // EBP offset of __context.info + cs.IEV1.Vint = nteh_EBPoffset_info(); + c = gen(c,&cs); // MOV EAX,__context[EBP].info + cs.Irm = modregrm(0,AX,0); + gen(c,&cs); // MOV EAX,[EAX] + gen(c,&cs); // MOV EAX,[EAX] + cs.Iop = 0x89; + cs.Irm = modregrm(2,AX,BPRM); + cs.IFL1 = FLauto; + cs.IEVsym1 = nteh_ecodesym(); + cs.IEVoffset1 = 0; + gen(c,&cs); // MOV __ecode[EBP],EAX + } + return c; +} + +/******************************* + * Generate C++ or D frame handler. + */ + +void nteh_framehandler(symbol *scopetable) +{ code *c; + + // Generate: + // MOV EAX,&scope_table + // JMP __cpp_framehandler + + if (scopetable) + { + symbol_debug(scopetable); + c = gencs(NULL,0xB8+AX,0,FLextern,scopetable); // MOV EAX,&scope_table + gencs(c,0xE9,0,FLfunc,rtlsym[RTLSYM_CPP_HANDLER]); // JMP __cpp_framehandler + + pinholeopt(c,NULL); + codout(c); + code_free(c); + } +} + +/********************************* + * Generate code to set scope index. + */ + +code *nteh_gensindex(int sindex) +{ code *c; + + if (!(config.flags2 & CFG2seh)) + return NULL; + + // Generate: + // MOV -4[EBP],sindex + + c = genc(NULL,0xC7,modregrm(1,0,BP),FLconst,(targ_uns)nteh_EBPoffset_sindex(),FLconst,sindex); // 7 bytes long + c->Iflags |= CFvolatile; +#ifdef DEBUG + //assert(GENSINDEXSIZE == calccodsize(c)); +#endif + return c; +} + +/********************************* + * Generate code for setjmp(). + */ + +code *cdsetjmp(elem *e,regm_t *pretregs) +{ code cs; + code *c; + regm_t retregs; + unsigned stackpushsave; + unsigned flag; + + c = NULL; + stackpushsave = stackpush; +#if SCPP + if (CPP && (funcsym_p->Sfunc->Fflags3 & Fcppeh || usednteh & NTEHcpp)) + { + /* If in C++ try block + If the frame that is calling setjmp has a try,catch block then + the call to setjmp3 is as follows: + __setjmp3(environment,3,__cpp_longjmp_unwind,trylevel,funcdata); + + __cpp_longjmp_unwind is a routine in the RTL. This is a + stdcall routine that will deal with unwinding for CPP Frames. + trylevel is the value that gets incremented at each catch, + constructor invocation. + funcdata is the same value that you put into EAX prior to + cppframehandler getting called. + */ + symbol *s; + + s = except_gensym(); + if (!s) + goto L1; + + c = gencs(c,0x68,0,FLextern,s); // PUSH &scope_table + stackpush += 4; + genadjesp(c,4); + + c = genc1(c,0xFF,modregrm(1,6,BP),FLconst,(targ_uns)-4); + // PUSH trylevel + stackpush += 4; + genadjesp(c,4); + + cs.Iop = 0x68; + cs.Iflags = CFoff; + cs.Irex = 0; + cs.IFL2 = FLextern; + cs.IEVsym2 = rtlsym[RTLSYM_CPP_LONGJMP]; + cs.IEVoffset2 = 0; + c = gen(c,&cs); // PUSH &_cpp_longjmp_unwind + stackpush += 4; + genadjesp(c,4); + + flag = 3; + } + else +#endif + if (funcsym_p->Sfunc->Fflags3 & Fnteh) + { + /* If in NT SEH try block + If the frame that is calling setjmp has a try, except block + then the call to setjmp3 is as follows: + __setjmp3(environment,2,__seh_longjmp_unwind,trylevel); + __seth_longjmp_unwind is supplied by the RTL and is a stdcall + function. It is the name that MSOFT uses, we should + probably use the same one. + trylevel is the value that you increment at each try and + decrement at the close of the try. This corresponds to the + index field of the ehrec. + */ + int sindex_off; + + sindex_off = 20; // offset of __context.sindex + cs.Iop = 0xFF; + cs.Irm = modregrm(2,6,BPRM); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLbprel; + cs.IEVsym1 = nteh_contextsym(); + cs.IEVoffset1 = sindex_off; + c = gen(c,&cs); // PUSH scope_index + stackpush += 4; + genadjesp(c,4); + + cs.Iop = 0x68; + cs.Iflags = CFoff; + cs.Irex = 0; + cs.IFL2 = FLextern; + cs.IEVsym2 = rtlsym[RTLSYM_LONGJMP]; + cs.IEVoffset2 = 0; + c = gen(c,&cs); // PUSH &_seh_longjmp_unwind + stackpush += 4; + genadjesp(c,4); + + flag = 2; + } + else + { + /* If the frame calling setjmp has neither a try..except, nor a + try..catch, then call setjmp3 as follows: + _setjmp3(environment,0) + */ + L1: + flag = 0; + } + + cs.Iop = 0x68; + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL2 = FLconst; + cs.IEV2.Vint = flag; + c = gen(c,&cs); // PUSH flag + stackpush += 4; + genadjesp(c,4); + + c = cat(c,params(e->E1,REGSIZE)); + + c = cat(c,getregs(~rtlsym[RTLSYM_SETJMP3]->Sregsaved & (ALLREGS | mES))); + gencs(c,0xE8,0,FLfunc,rtlsym[RTLSYM_SETJMP3]); // CALL __setjmp3 + + c = genc2(c,0x81,modregrm(3,0,SP),stackpush - stackpushsave); // ADD ESP,8 + genadjesp(c,-(stackpush - stackpushsave)); + + stackpush = stackpushsave; + retregs = regmask(e->Ety, TYnfunc); + return cat(c,fixresult(e,retregs,pretregs)); +} + +/**************************************** + * Call _local_unwind(), which means call the __finally blocks until + * index is reached. + */ + +code *nteh_unwind(regm_t retregs,unsigned index) +{ code *c; + code cs; + code *cs1; + code *cs2; + regm_t desregs; + int reg; + int local_unwind; + + // Shouldn't this always be CX? +#if SCPP + reg = AX; +#else + reg = CX; +#endif + +#if MARS + local_unwind = RTLSYM_D_LOCAL_UNWIND2; +#else + local_unwind = RTLSYM_LOCAL_UNWIND2; +#endif + desregs = (~rtlsym[local_unwind]->Sregsaved & (ALLREGS)) | mask[reg]; + gensaverestore(retregs & desregs,&cs1,&cs2); + + c = getregs(desregs); + + cs.Iop = 0x8D; + cs.Irm = modregrm(2,reg,BPRM); + cs.Iflags = 0; + cs.Irex = 0; + cs.IFL1 = FLconst; + // EBP offset of __context.prev + cs.IEV1.Vint = nteh_EBPoffset_prev(); + c = gen(c,&cs); // LEA ECX,contextsym + + genc2(c,0x68,0,index); // PUSH index + gen1(c,0x50 + reg); // PUSH ECX + +#if MARS + //gencs(c,0xB8+AX,0,FLextern,nteh_scopetable()); // MOV EAX,&scope_table + gencs(c,0x68,0,FLextern,nteh_scopetable()); // PUSH &scope_table + + gencs(c,0xE8,0,FLfunc,rtlsym[local_unwind]); // CALL __d_local_unwind2() + genc2(c,0x81,modregrm(3,0,SP),12); // ADD ESP,12 +#else + gencs(c,0xE8,0,FLfunc,rtlsym[local_unwind]); // CALL __local_unwind2() + genc2(c,0x81,modregrm(3,0,SP),8); // ADD ESP,8 +#endif + + c = cat4(cs1,c,cs2,NULL); + return c; +} + +/**************************************** + * Call _local_unwind(), which means call the __finally blocks until + * index is reached. + */ + +#if 0 // Replaced with inline calls to __finally blocks + +code *linux_unwind(regm_t retregs,unsigned index) +{ code *c; + code *cs1; + code *cs2; + int i; + regm_t desregs; + int reg; + int local_unwind; + + // Shouldn't this always be CX? +#if SCPP + reg = AX; +#else + reg = CX; +#endif + +#if MARS + local_unwind = RTLSYM_D_LOCAL_UNWIND2; +#else + local_unwind = RTLSYM_LOCAL_UNWIND2; +#endif + desregs = (~rtlsym[local_unwind]->Sregsaved & (ALLREGS)) | mask[reg]; + gensaverestore(retregs & desregs,&cs1,&cs2); + + c = getregs(desregs); + c = genc2(c,0x68,0,index); // PUSH index + +#if MARS +// gencs(c,0x68,0,FLextern,nteh_scopetable()); // PUSH &scope_table + + gencs(c,0xE8,0,FLfunc,rtlsym[local_unwind]); // CALL __d_local_unwind2() + genc2(c,0x81,modregrm(3,0,SP),4); // ADD ESP,12 +#else + gencs(c,0xE8,0,FLfunc,rtlsym[local_unwind]); // CALL __local_unwind2() + genc2(c,0x81,modregrm(3,0,SP),8); // ADD ESP,8 +#endif + + c = cat4(cs1,c,cs2,NULL); + return c; +} + +#endif + +/************************************************* + * Set monitor, hook monitor exception handler. + */ + +#if MARS + +code *nteh_monitor_prolog(Symbol *shandle) +{ + /* + * PUSH handle + * PUSH offset _d_monitor_handler + * PUSH FS:__except_list + * MOV FS:__except_list,ESP + * CALL _d_monitor_prolog + */ + code *c1 = NULL; + code *c; + code cs; + Symbol *s; + regm_t desregs; + + assert(config.flags2 & CFG2seh); // BUG: figure out how to implement for other EX's + + if (shandle->Sclass == SCfastpar) + { assert(shandle->Spreg != DX); + c = gen1(NULL,0x50 + shandle->Spreg); // PUSH shandle + } + else + { + // PUSH shandle +#if 0 + c = genc1(NULL,0xFF,modregrm(2,6,4),FLconst,4 * (1 + needframe) + shandle->Soffset + localsize); + c->Isib = modregrm(0,4,SP); +#else + useregs(mCX); + c = genc1(NULL,0x8B,modregrm(2,CX,4),FLconst,4 * (1 + needframe) + shandle->Soffset + localsize); + c->Isib = modregrm(0,4,SP); + gen1(c,0x50 + CX); // PUSH ECX +#endif + } + + s = rtlsym[RTLSYM_MONITOR_HANDLER]; + c = gencs(c,0x68,0,FLextern,s); // PUSH offset _d_monitor_handler + makeitextern(s); + +#if 0 + cs.Iop = 0xFF; + cs.Irm = modregrm(0,6,BPRM); + cs.Iflags = CFfs; + cs.Irex = 0; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + gen(c,&cs); // PUSH FS:__except_list +#else + useregs(mDX); + cs.Iop = 0x8B; + cs.Irm = modregrm(0,DX,BPRM); + cs.Iflags = CFfs; + cs.Irex = 0; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + c1 = gen(c1,&cs); // MOV EDX,FS:__except_list + + gen1(c,0x50 + DX); // PUSH EDX +#endif + + s = rtlsym[RTLSYM_MONITOR_PROLOG]; + desregs = ~s->Sregsaved & ALLREGS; + c = cat(c,getregs(desregs)); + c = gencs(c,0xE8,0,FLfunc,s); // CALL _d_monitor_prolog + + cs.Iop = 0x89; + NEWREG(cs.Irm,SP); + gen(c,&cs); // MOV FS:__except_list,ESP + + return cat(c1,c); +} + +#endif + +/************************************************* + * Release monitor, unhook monitor exception handler. + * Input: + * retregs registers to not destroy + */ + +#if MARS + +code *nteh_monitor_epilog(regm_t retregs) +{ + /* + * CALL _d_monitor_epilog + * POP FS:__except_list + */ + code cs; + code *c; + code *cs1; + code *cs2; + code *cpop; + regm_t desregs; + Symbol *s; + + assert(config.flags2 & CFG2seh); // BUG: figure out how to implement for other EX's + + s = rtlsym[RTLSYM_MONITOR_EPILOG]; + //desregs = ~s->Sregsaved & ALLREGS; + desregs = 0; + gensaverestore(retregs & desregs,&cs1,&cs2); + + c = getregs(desregs); + c = gencs(c,0xE8,0,FLfunc,s); // CALL __d_monitor_epilog + + cs.Iop = 0x8F; + cs.Irm = modregrm(0,0,BPRM); + cs.Iflags = CFfs; + cs.Irex = 0; + cs.IFL1 = FLextern; + cs.IEVsym1 = rtlsym[RTLSYM_EXCEPT_LIST]; + cs.IEVoffset1 = 0; + cpop = gen(NULL,&cs); // POP FS:__except_list + + c = cat4(cs1,c,cs2,cpop); + return c; +} + +#endif + +#endif diff --git a/backend/oper.h b/backend/oper.h new file mode 100644 index 00000000..6d1f2749 --- /dev/null +++ b/backend/oper.h @@ -0,0 +1,414 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if __SC__ +#pragma once +#endif + +#ifndef OPER_H +#define OPER_H 1 + +enum OPER +{ + OPunde, /* place holder for undefined operator */ + + OPadd, + OPmin, + OPmul, + OPdiv, + OPmod, + OPshr, // unsigned right shift + OPshl, + OPand, + OPxor, + OPor, + OPashr, // signed right shift + OPnot, + OPbool, /* "booleanize" */ + OPcom, + OPcond, + OPcomma, + OPoror, + OPandand, + OPbit, /* ref to bit field */ + OPind, /* *E */ + OPaddr, /* &E */ + OPneg, /* unary - */ + OPuadd, /* unary + */ +#if TX86 + OPvoid, // where casting to void is not a no-op + OPabs, /* absolute value */ + OPsqrt, /* square root */ + OPrndtol, // round to short, long, long long (inline 8087 only) + OPsin, // sine + OPcos, // cosine + OPrint, // round to int + OPscale, // ldexp + OPyl2x, // y * log2(x) + OPyl2xp1, // y * log2(x + 1) + OPstrlen, /* strlen() */ + OPstrcpy, /* strcpy() */ + OPstrcat, /* strcat() */ + OPstrcmp, /* strcmp() */ + OPmemcpy, + OPmemcmp, + OPmemset, + OPsetjmp, // setjmp() +#endif + + OPremquo, // / and % in one operation + +#if TX86 + OPbsf, // bit scan forward + OPbsr, // bit scan reverse + OPbt, // bit test + OPbtc, // bit test and complement + OPbtr, // bit test and reset + OPbts, // bit test and set + OPbswap, // swap bytes + OProl, // rotate left + OPror, // rotate right +#endif + + OPstreq, /* structure assignment */ + + OPnegass, // x = -x + OPpostinc, /* x++ */ + OPpostdec, /* x-- */ + + OPeq, + OPaddass, + OPminass, + OPmulass, + OPdivass, + OPmodass, + OPshrass, + OPshlass, + OPandass, + OPxorass, + OPorass, + +/* Convert from token to assignment operator */ +#define asgtoktoop(tok) ((int) (tok) + ((int)OPeq - (int) TKeq)) + + OPashrass, + + /* relational operators (in same order as corresponding tokens) */ +#define RELOPMIN ((int)OPle) + OPle, + OPgt, + OPlt, + OPge, + OPeqeq, + OPne, + + OPunord, /* !<>= */ + OPlg, /* <> */ + OPleg, /* <>= */ + OPule, /* !> */ + OPul, /* !>= */ + OPuge, /* !< */ + OPug, /* !<= */ + OPue, /* !<> */ + OPngt, + OPnge, + OPnlt, + OPnle, + OPord, + OPnlg, + OPnleg, + OPnule, + OPnul, + OPnuge, + OPnug, + OPnue, + +#define rel_toktoop(tk) ((enum OPER)((int)tk - (int)TKle + (int)OPle)) + +/***************** End of relational operators ******************/ + +/* Convert from conversion operator to conversion index */ +// parallel array invconvtab[] in cgelem.c) + +#define CNVOPMIN (OPb_8) +#define CNVOPMAX (OPld_u64) +#define convidx(op) ((int)(op) - CNVOPMIN) + +/* 8,16,32,64 integral type of unspecified sign + s,u signed/unsigned + f,d,ld float/double/long double + np,fp,vp,f16p near pointer/far pointer/handle pointer/far16 pointer + cvp const handle pointer +*/ + + OPb_8, // convert bit to byte + OPd_s32, + OPs32_d, + OPd_s16, + OPs16_d, + OPd_u16, + OPu16_d, + OPd_u32, + OPu32_d, + OPd_s64, + OPs64_d, + OPd_u64, + OPu64_d, + OPd_f, + OPf_d, + OPs16_32, // short to long + OPu16_32, // unsigned short to long + OP32_16, // long to short + OPu8_16, // unsigned char to short + OPs8_16, // signed char to short + OP16_8, // short to 8 bits + OPu32_64, // unsigned long to long long + OPs32_64, // long to long long + OP64_32, // long long to long + OPu64_128, + OPs64_128, + OP128_64, +#if TARGET_SEGMENTED + OPvp_fp, + OPcvp_fp, // const handle * => far * + OPoffset, // get offset of far pointer + OPnp_fp, // convert near pointer to far + OPnp_f16p, // from 0:32 to 16:16 + OPf16p_np, // from 16:16 to 0:32 +#endif + OPld_d, + OPd_ld, + OPld_u64, + +/***************** End of conversion operators ******************/ + + OPc_r, // complex to real + OPc_i, // complex to imaginary + OPmsw, // top 32 bits of 64 bit word (32 bit code gen) + // top 16 bits of 32 bit word (16 bit code gen) + + OPparam, /* function parameter separator */ + OPcall, /* binary function call */ + OPucall, /* unary function call */ + OPcallns, // binary function call, no side effects + OPucallns, // unary function call, no side effects + + OPsizeof, /* for forward-ref'd structs */ + OPstrctor, /* call ctor on struct param */ + OPstrthis, // 'this' pointer for OPstrctor + OPstrpar, /* structure func param */ + OPconst, /* constant */ + OPrelconst, /* constant that contains an address */ + OPvar, /* variable */ + OPreg, // register (used in inline asm operand expressions) + OPcolon, /* : as in ?: */ + OPcolon2, // alternate version with different EH semantics + OPstring, /* address of string */ + OPnullptr, // null pointer + OPasm, /* in-line assembly code */ + OPinfo, // attach info (used to attach ctor/dtor + OPhalt, // insert HLT instruction + // info for exception handling) + OPctor, + OPdtor, + OPmark, + OPdctor, // D constructor + OPddtor, // D destructor + + OPpair, // build register pair, E1 is lsb, E2 = msb + OPrpair, // build reversed register pair, E1 is msb, E2 = lsb + OPframeptr, // load pointer to base of frame + OPgot, // load pointer to global offset table + OPvector, // SIMD vector operations + + // Jupiter operators + OParray, // access Jupiter array, left is handle, right is index + OParraylength, // evaluates array handle into array length + OPfield, // access Jupiter object field, left is handle, right is offset + OPnewarray, // allocate Jupiter array, left is dimension, right is type + OPmultinewarray, // allocate multidimensional Jupiter array + // left is dimensions, right is (numdims,type signature) + OPinstanceof, // left is class id, right is handle + OPfinalinstanceof, // left is class id, right is handle + OPcheckcast, // left is class id, right is handle + OPhstring, // handle to static string + OPnullcheck, // check if pointer is null + +#if TX86 + OPinp, /* input from I/O port */ + OPoutp, /* output to I/O port */ +#endif + /* C++ operators */ + OPnew, // operator new + OPanew, // operator new[] + OPdelete, // operator delete + OPadelete, // operator delete[] + OPbrack, /* [] subscript */ + OParrow, /* for -> overloading */ + OParrowstar, /* for ->* overloading */ + OPpreinc, /* ++x overloading */ + OPpredec, /* --x overloading */ + +#ifdef TARGET_INLINEFUNC_OPS + TARGET_INLINEFUNC_OPS +#endif + + OPMAX /* 1 past last operator */ +}; +typedef enum OPER OPER; /* needed for optabgen */ + +/************************************ + * Determine things about relational operators. + */ + +extern unsigned char rel_not[]; +extern unsigned char rel_swap[]; +extern unsigned char rel_integral[]; +extern unsigned char rel_exception[]; +extern unsigned char rel_unord[]; + +#define rel_not(op) rel_not[(int)(op) - RELOPMIN] +#define rel_swap(op) rel_swap[(int)(op) - RELOPMIN] +#define rel_integral(op) rel_integral[(int)(op) - RELOPMIN] +#define rel_exception(op) rel_exception[(int)(op) - RELOPMIN] +#define rel_unord(op) rel_unord[(int)(op) - RELOPMIN] + + +/********************************** + * Various types of operators: + * OTbinary binary + * OTunary unary + * OTleaf leaf + * OTcommut commutative (e1 op e2) == (e2 op e1) + * (assoc == !=) + * OTassoc associative (e1 op (e2 op e3)) == ((e1 op e2) op e3) + * (also commutative) + * OTassign assignment = op= i++ i-- i=-i str= + * OTpost post inc or post dec operator + * OTeop0e if (e op 0) => e + * OTeop00 if (e op 0) => 0 + * OTeop1e if (e op 1) => e + * OTsideff there are side effects to the operator (assign call + * post ?: && ||) + * OTconv type conversion operator that could appear on lhs of + * assignment operator + * OTlogical logical operator (result is 0 or 1) + * OTwid high order bits of operation are irrelevant + * OTopeq an op= operator + * OTop an operator that has a corresponding op= + * OTcall function call + * OTrtol operators that evaluate right subtree first then left + * OTrel == != < <= > >= operators + * OTrel2 < <= > >= operators + * OTdef definition operator (assign call post asm) + * OTae potential common subexpression operator + * OTexp expression elem + * OTboolnop operation is a nop if boolean result is desired + */ + +#if TX86 +extern const unsigned char optab1[OPMAX],optab2[OPMAX],optab3[OPMAX]; +extern const unsigned char opcost[OPMAX]; +#else +extern unsigned char optab1[OPMAX],optab2[OPMAX]; +#endif +/* optab1[] */ /* Use byte arrays to avoid index scaling */ +#define _OTbinary 1 +#define _OTunary 2 +#define _OTcommut 4 +#define _OTassoc 8 +#define _OTsideff 0x10 +#define _OTeop0e 0x20 +#define _OTeop00 0x40 +#define _OTeop1e 0x80 + +/* optab2[] */ +#define _OTlogical 1 +#define _OTwid 2 +#define _OTcall 4 +#define _OTrtol 8 +#define _OTassign 0x10 +#define _OTdef 0x20 +#define _OTae 0x40 +#define _OTexp 0x80 + +#if TX86 +// optab3[] +#define _OTboolnop 1 +#endif +#define OTbinary(op) (optab1[op]&_OTbinary) +#define OTunary(op) (optab1[op]&_OTunary) +#define OTleaf(op) (!(optab1[op]&(_OTunary|_OTbinary))) +#define OTcommut(op) (optab1[op]&_OTcommut) +#define OTassoc(op) (optab1[op]&_OTassoc) +#define OTassign(op) (optab2[op]&_OTassign) +#define OTpost(op) ((op) == OPpostinc || (op) == OPpostdec) +#define OTeop0e(op) (optab1[op]&_OTeop0e) +#define OTeop00(op) (optab1[op]&_OTeop00) +#define OTeop1e(op) (optab1[op]&_OTeop1e) +#define OTsideff(op) (optab1[op]&_OTsideff) +#define OTconv(op) ((op) >= CNVOPMIN && (op) <= CNVOPMAX) +#define OTlogical(op) (optab2[op]&_OTlogical) +#define OTwid(op) (optab2[op]&_OTwid) +#define OTopeq(op) ((op) >= OPaddass && (op) <= OPashrass) +#define OTop(op) ((op) >= OPadd && (op) <= OPor) +#define OTcall(op) (optab2[op]&_OTcall) +#define OTrtol(op) (optab2[op]&_OTrtol) +#define OTrel(op) ((op) >= OPle && (op) <= OPnue) +#define OTrel2(op) ((op) >= OPle && (op) <= OPge) +#define OTdef(op) (optab2[op]&_OTdef) +#define OTae(op) (optab2[op]&_OTae) +#define OTexp(op) (optab2[op]&_OTexp) +#if TX86 +#define OTboolnop(op) (optab3[op]&_OTboolnop) +#define OTcalldef(op) (OTcall(op) || (op) == OPstrcpy || (op) == OPstrcat || (op) == OPmemcpy) +#else +#define OTcalldef(op) (OTcall(op)) +#endif + +/* Convert op= to op */ +#define opeqtoop(opx) ((opx) - OPaddass + OPadd) + +/* Convert op to op= */ +#define optoopeq(opx) ((opx) - OPadd + OPaddass) + +/*************************** + * Determine properties of an elem. + * EBIN binary node? + * EUNA unary node? + * EOP operator node (unary or binary)? + * ERTOL right to left evaluation (left to right is default) + * Eunambig unambiguous definition elem? + */ + +#define EBIN(e) (OTbinary((e)->Eoper)) +#define EUNA(e) (OTunary((e)->Eoper)) + +/* ERTOL(e) is moved to el.c */ + +#if KEEPBITFIELDS +#define Elvalue(e) (((e)->E1->Eoper == OPbit) ? (e)->E1->E1 : (e)->E1) +#define Eunambig(e) (OTassign((e)->Eoper) && \ + ((e)->E1->Eoper == OPvar || \ + ((e)->E1->Eoper == OPbit && \ + (e)->E1->E1->Eoper == OPvar))) +#else +#define Elvalue(e) ((e)->E1) +#define Eunambig(e) (OTassign((e)->Eoper) && \ + (e)->E1->Eoper == OPvar) +#endif + +#define EOP(e) (!OTleaf((e)->Eoper)) + +#endif /* OPER_H */ + diff --git a/backend/optabgen.c b/backend/optabgen.c new file mode 100644 index 00000000..69e2ac6d --- /dev/null +++ b/backend/optabgen.c @@ -0,0 +1,1131 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +/* Generate op-code tables + * Creates optab.c,debtab.c,cdxxx.c,elxxx.c + */ + +#include +#include +#include +#include +#include "cc.h" +#include "oper.h" + +void doreltables(FILE *f); +void dotab(); +void dotytab(); +void dooptab(); +void fltables(); + +unsigned char xptab1[OPMAX],xptab2[OPMAX],xptab3[OPMAX]; + +int _binary[] = + {OPadd,OPmul,OPand,OPmin,OPcond,OPcomma,OPdiv,OPmod,OPxor, + OPor,OPoror,OPandand,OPshl,OPshr,OPashr,OPstreq,OPstrcpy,OPstrcat,OPstrcmp, + OPpostinc,OPpostdec,OPeq,OPaddass,OPminass,OPmulass,OPdivass, + OPmodass,OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass, + OPle,OPgt,OPlt,OPge,OPeqeq,OPne,OPparam,OPcall,OPcallns,OPcolon,OPcolon2, + OPbit,OPoutp,OPbrack,OParrowstar,OPmemcpy,OPmemcmp,OPmemset, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + OPinfo,OParray,OPfield,OPnewarray,OPmultinewarray,OPinstanceof,OPfinalinstanceof, + OPcheckcast,OPpair,OPrpair, + OPbt,OPbtc,OPbtr,OPbts,OPror,OProl, + OPscale,OPremquo,OPyl2x,OPyl2xp1, + }; +int _unary[] = + {OPnot,OPcom,OPind,OPaddr,OPneg,OPuadd, + OPabs,OPsqrt,OPrndtol,OPsin,OPcos,OPrint, + OPpreinc,OPpredec, + OPbool,OPstrlen,OPnullcheck, + OPb_8,OPs16_32,OPu16_32,OPd_s32,OPd_u32, + OPs32_d,OPu32_d,OPd_s16,OPs16_d,OP32_16, + OPd_f,OPf_d,OPu8_16,OPs8_16,OP16_8, + OPd_ld, OPld_d,OPc_r,OPc_i, + OPu32_64,OPs32_64,OP64_32,OPmsw, + OPd_s64,OPs64_d,OPd_u64,OPu64_d,OPld_u64, + OP128_64,OPs64_128,OPu64_128, + OPucall,OPucallns,OPstrpar,OPstrctor,OPu16_d,OPd_u16, + OPinp,OParrow,OPnegass, + OPctor,OPdtor,OPsetjmp,OPvoid,OParraylength, + OPbsf,OPbsr,OPbswap, + OPddtor, + OPvector, +#if TARGET_SEGMENTED + OPvp_fp,OPcvp_fp,OPnp_fp,OPnp_f16p,OPf16p_np,OPoffset, +#endif + }; +int _commut[] = {OPadd,OPand,OPor,OPxor,OPmul,OPeqeq,OPne,OPle,OPlt,OPge,OPgt, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + }; +int _assoc[] = {OPadd,OPand,OPor,OPxor,OPmul}; +int _assign[] = + {OPstreq,OPeq,OPaddass,OPminass,OPmulass,OPdivass,OPmodass, + OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass,OPpostinc,OPpostdec, + OPnegass, + /* OPbtc,OPbtr,OPbts,*/ + }; +int _wid[] = + {OPadd,OPmin,OPand,OPor,OPxor,OPcom,OPneg,OPmul,OPaddass,OPnegass, + OPminass,OPandass,OPorass,OPxorass,OPmulass,OPshlass,OPshl,OPshrass, + OPashrass, + }; +int _eop0e[] = + {OPadd,OPmin,OPxor,OPor,OPshl,OPshr,OPashr,OPpostinc,OPpostdec,OPaddass, + OPminass,OPshrass,OPashrass,OPshlass,OPxorass,OPorass, + OPror,OProl, + }; +int _eop00[] = {OPmul,OPand,OPmulass,OPandass}; +int _eop1e[] = {OPmul,OPdiv,OPmulass,OPdivass}; +int _call[] = {OPcall,OPucall,OPcallns,OPucallns}; +int _rel[] = {OPeqeq,OPne,OPle,OPlt,OPgt,OPge, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + }; +int _logical[] = {OPeqeq,OPne,OPle,OPlt,OPgt,OPge,OPandand,OPoror,OPnot,OPbool, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + }; +int _def[] = {OPstreq,OPeq,OPaddass,OPminass,OPmulass,OPdivass,OPmodass, + OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass, + OPpostinc,OPpostdec, + OPcall,OPucall,OPasm,OPstrcpy,OPmemcpy,OPmemset,OPstrcat, + OPnegass,OPnewarray,OPmultinewarray, + OPbtc,OPbtr,OPbts, + }; +int _sideff[] = {OPasm,OPucall,OPstrcpy,OPmemcpy,OPmemset,OPstrcat, + OPcall,OPeq,OPstreq,OPpostinc,OPpostdec, + OPaddass,OPminass,OPmulass,OPdivass,OPmodass,OPandass, + OPorass,OPxorass,OPshlass,OPshrass,OPashrass, + OPinp,OPoutp,OPnegass,OPctor,OPdtor,OPmark,OPvoid,OPnewarray, + OPmultinewarray,OPcheckcast,OPnullcheck, + OPbtc,OPbtr,OPbts, + OPhalt,OPdctor,OPddtor, + }; +int _rtol[] = {OPeq,OPstreq,OPstrcpy,OPmemcpy,OPpostinc,OPpostdec,OPaddass, + OPminass,OPmulass,OPdivass,OPmodass,OPandass, + OPorass,OPxorass,OPshlass,OPshrass,OPashrass, + OPcall,OPcallns,OPinfo,OPmemset, + }; +int _ae[] = {OPvar,OPconst,OPrelconst,OPneg, + OPabs,OPsqrt,OPrndtol,OPsin,OPcos,OPrint,OPscale, + OPstrlen,OPstrcmp,OPind,OPaddr, + OPnot,OPbool,OPcom,OPadd,OPmin,OPmul,OPand,OPor,OPmemcmp, + OPxor,OPdiv,OPmod,OPshl,OPshr,OPashr,OPeqeq,OPne,OPle,OPlt,OPge,OPgt, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + OPs16_32,OPu16_32,OPd_s32,OPd_u32,OPu16_d,OPd_u16, + OPs32_d,OPu32_d,OPd_s16,OPs16_d,OP32_16, + OPd_f,OPf_d,OPu8_16,OPs8_16,OP16_8, + OPd_ld,OPld_d,OPc_r,OPc_i, + OPu32_64,OPs32_64,OP64_32,OPmsw, + OPd_s64,OPs64_d,OPd_u64,OPu64_d,OPld_u64, + OP128_64,OPs64_128,OPu64_128, + OPsizeof,OParray,OPfield,OPinstanceof,OPfinalinstanceof,OPcheckcast,OParraylength, + OPcallns,OPucallns,OPnullcheck,OPpair,OPrpair, + OPbsf,OPbsr,OPbt,OPbswap,OPb_8, + OPgot,OPremquo, + OPnullptr, + OProl,OPror, +#if TARGET_SEGMENTED + OPvp_fp,OPcvp_fp,OPnp_fp,OPnp_f16p,OPf16p_np,OPoffset, +#endif + /*OPcomma,OPbit,OPoror,OPandand,OPcond,OPcolon,OPcolon2*/}; +int _exp[] = {OPvar,OPconst,OPrelconst,OPneg,OPabs,OPsqrt,OPrndtol,OPrint, + OPsin,OPcos,OPscale,OPyl2x,OPyl2xp1, + OPstrlen,OPstrcmp,OPind,OPaddr, + OPnot,OPbool,OPcom,OPadd,OPmin,OPmul,OPand,OPor,OPstring, + OPxor,OPdiv,OPmod,OPshl,OPshr,OPashr,OPeqeq,OPne,OPle,OPlt,OPge,OPgt, + OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge, + OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue, + OPcomma,OPasm,OPsizeof,OPmemcmp, + OPs16_32,OPu16_32,OPd_s32,OPd_u32,OPu16_d,OPd_u16, + OPs32_d,OPu32_d,OPd_s16,OPs16_d,OP32_16, + OPd_f,OPf_d,OPu8_16,OPs8_16,OP16_8, + OPd_ld, OPld_d,OPc_r,OPc_i, + OPu32_64,OPs32_64,OP64_32,OPmsw, + OPd_s64,OPs64_d,OPd_u64,OPu64_d,OPld_u64, + OP128_64,OPs64_128,OPu64_128, + OPbit,OPind,OPucall,OPucallns,OPnullcheck, + OParray,OPfield,OPinstanceof,OPfinalinstanceof,OPcheckcast,OParraylength,OPhstring, + OPcall,OPcallns,OPeq,OPstreq,OPpostinc,OPpostdec, + OPaddass,OPminass,OPmulass,OPdivass,OPmodass,OPandass, + OPorass,OPxorass,OPshlass,OPshrass,OPashrass,OPoror,OPandand,OPcond, + OPbsf,OPbsr,OPbt,OPbtc,OPbtr,OPbts,OPbswap, + OProl,OPror,OPvector, + OPpair,OPrpair,OPframeptr,OPgot,OPremquo, + OPcolon,OPcolon2,OPasm,OPstrcpy,OPmemcpy,OPmemset,OPstrcat,OPnegass, +#if TARGET_SEGMENTED + OPvp_fp,OPcvp_fp,OPoffset,OPnp_fp,OPnp_f16p,OPf16p_np, +#endif +}; +int _boolnop[] = {OPuadd,OPbool,OPs16_32,OPu16_32, + OPs16_d, + OPf_d,OPu8_16,OPs8_16, + OPd_ld, OPld_d, + OPu32_64,OPs32_64,/*OP64_32,OPmsw,*/ + OPs64_128,OPu64_128, + OPu16_d,OPb_8, + OPnullptr, +#if TARGET_SEGMENTED + OPnp_fp,OPvp_fp,OPcvp_fp, +#endif + }; +int _lvalue[] = {OPvar,OPind,OPcomma,OPbit, + OPfield,OParray}; + +FILE *fdeb; + +int main() +{ + printf("OPTABGEN... generating files\n"); + fdeb = fopen("debtab.c","w"); + dooptab(); + dotab(); + fltables(); + dotytab(); + fclose(fdeb); + return 0; +} + +int cost(unsigned op) +{ unsigned c; + + c = 0; /* default cost */ + if (xptab1[op] & _OTunary) + c += 2; + else if (xptab1[op] & _OTbinary) + c += 7; + if (xptab2[op] & _OTlogical) + c += 3; + switch (op) + { case OPvar: c += 1; break; + case OPmul: c += 3; break; + case OPdiv: + case OPmod: c += 4; break; + case OProl: + case OPror: + case OPshl: + case OPashr: + case OPshr: c += 2; break; + case OPnewarray: + case OPmultinewarray: + case OPcall: + case OPucall: + case OPcallns: + case OPucallns: + c += 10; break; // very high cost for function calls + case OParray: c = 5; break; + } + return c; +} + +void dooptab() +{ int i; + FILE *f; + + /* Load optab[] */ +#define X1(arr,mask) for(i=0;i= 0 && j < RELMAX); + rel_not [j] = reltables[i].inot; + rel_swap [j] = reltables[i].swap; + rel_integral [j] = reltables[i].integral; + rel_exception[j] = reltables[i].exception; + rel_unord [j] = reltables[i].unord; + } + + fprintf(f,"unsigned char rel_not[] =\n{ "); + for (i = 0; i < arraysize(rel_not); i++) + { fprintf(f,"0x%02x,",rel_not[i]); + if ((i & 7) == 7 && i < arraysize(rel_not) - 1) + fprintf(f,"\n "); + } + fprintf(f,"\n};\n"); + + fprintf(f,"unsigned char rel_swap[] =\n{ "); + for (i = 0; i < arraysize(rel_swap); i++) + { fprintf(f,"0x%02x,",rel_swap[i]); + if ((i & 7) == 7 && i < arraysize(rel_swap) - 1) + fprintf(f,"\n "); + } + fprintf(f,"\n};\n"); + + fprintf(f,"unsigned char rel_integral[] =\n{ "); + for (i = 0; i < arraysize(rel_integral); i++) + { fprintf(f,"0x%02x,",rel_integral[i]); + if ((i & 7) == 7 && i < arraysize(rel_integral) - 1) + fprintf(f,"\n "); + } + fprintf(f,"\n};\n"); + + fprintf(f,"unsigned char rel_exception[] =\n{ "); + for (i = 0; i < arraysize(rel_exception); i++) + { fprintf(f,"0x%02x,",rel_exception[i]); + if ((i & 7) == 7 && i < arraysize(rel_exception) - 1) + fprintf(f,"\n "); + } + fprintf(f,"\n};\n"); + + fprintf(f,"unsigned char rel_unord[] =\n{ "); + for (i = 0; i < arraysize(rel_unord); i++) + { fprintf(f,"0x%02x,",rel_unord[i]); + if ((i & 7) == 7 && i < arraysize(rel_unord) - 1) + fprintf(f,"\n "); + } + fprintf(f,"\n};\n"); +} + + +/******************************************************** + */ + +const char *debtab[OPMAX],*cdxxx[OPMAX],*elxxx[OPMAX]; + +void dotab() +{ int i; + FILE *f; + +#if BSDUNIX +#define X(d,e,c) debtab[i]=d;cdxxx[i]="c",elxxx[i]="e";break +#else +#define X(d,e,c) debtab[i]=d;cdxxx[i]=#c,elxxx[i]=#e;break +#endif + for (i = 0; i < OPMAX; i++) + { + switch (i) + { + case OPunde: X("unde", elerr, cderr); + case OPadd: X("+", eladd, cdorth); + case OPmul: X("*", elmul, cdmul); + case OPand: X("&", elbitwise,cdorth); + case OPmin: X("-", elmin, cdorth); + case OPnot: X("!", elnot, cdnot); + case OPcom: X("~", elcom, cdcom); + case OPcond: X("?", elcond, cdcond); + case OPcomma: X(",", elcomma,cdcomma); + case OPremquo: X("/%", elremquo, cdmul); + case OPdiv: X("/", eldiv, cdmul); + case OPmod: X("%", elmod, cdmul); + case OPxor: X("^", elxor, cdorth); + case OPstring: X("string", elstring,cderr); + case OPrelconst: X("relconst", elzot, cdrelconst); + case OPinp: X("inp", elzot, cdport); + case OPoutp: X("outp", elzot, cdport); + case OPasm: X("asm", elzot, cdasm); + case OPinfo: X("info", elinfo,cdinfo); + case OPdctor: X("dctor", elzot, cddctor); + case OPddtor: X("ddtor", elddtor, cdddtor); + case OPctor: X("ctor", elinfo,cdctor); + case OPdtor: X("dtor", elinfo,cddtor); + case OPmark: X("mark", elinfo,cdmark); + case OPvoid: X("void", elzot, cdvoid); + case OPhalt: X("halt", elzot, cdhalt); + case OPnullptr: X("nullptr", elerr, cderr); + case OPpair: X("pair", elpair, cdpair); + case OPrpair: X("rpair", elpair, cdpair); + + case OPnewarray: X("newarray", elnewarray,cderr); + case OPmultinewarray: X("mnewarray", elmultinewarray,cderr); + case OPinstanceof: X("instanceof", elinstanceof,cderr); + case OPfinalinstanceof: X("finalinstanceof", elfinalinstanceof,cderr); + case OPcheckcast: X("checkcast", elcheckcast,cderr); + case OParraylength: X("length", elarraylength,cderr); + case OParray: X("array", elarray,cderr); + case OPfield: X("field", elfield,cderr); + case OPhstring: X("hstring", elhstring,cderr); + case OPnullcheck: X("nullcheck", elnullcheck,cdnullcheck); + + case OPor: X("|", elor, cdorth); + case OPoror: X("||", eloror, cdloglog); + case OPandand: X("&&", elandand,cdloglog); + case OProl: X("<<|", elshl, cdshift); + case OPror: X(">>|", elshl, cdshift); + case OPshl: X("<<", elshl, cdshift); + case OPshr: X(">>>", elshr, cdshift); + case OPashr: X(">>", elshr, cdshift); + case OPbit: X("bit", elbit, cderr); + case OPind: X("*", elind, cdind); + case OPaddr: X("&", eladdr, cderr); + case OPneg: X("-", elneg, cdneg); + case OPuadd: X("+", elzot, cderr); + case OPabs: X("abs", evalu8, cdabs); + case OPsqrt: X("sqrt", evalu8, cdneg); + case OPsin: X("sin", evalu8, cdneg); + case OPcos: X("cos", evalu8, cdneg); + case OPrint: X("rint", evalu8, cdneg); + case OPrndtol: X("rndtol", evalu8, cdrndtol); + case OPscale: X("scale", elzot, cdscale); + case OPyl2x: X("yl2x", elzot, cdscale); + case OPyl2xp1: X("yl2xp1", elzot, cdscale); + case OPstrlen: X("strlen", elzot, cdstrlen); + case OPstrcpy: X("strcpy", elstrcpy,cdstrcpy); + case OPmemcpy: X("memcpy", elmemxxx,cdmemcpy); + case OPmemset: X("memset", elmemxxx,cdmemset); + case OPstrcat: X("strcat", elzot, cderr); + case OPstrcmp: X("strcmp", elstrcmp,cdstrcmp); + case OPmemcmp: X("memcmp", elmemxxx,cdmemcmp); + case OPsetjmp: X("setjmp", elzot, cdsetjmp); + case OPnegass: X("negass", elnegass, cdaddass); + case OPpreinc: X("U++", elzot, cderr); + case OPpredec: X("U--", elzot, cderr); + case OPstreq: X("streq", elstruct,cdstreq); + case OPpostinc: X("++", elpost, cdpost); + case OPpostdec: X("--", elpost, cdpost); + case OPeq: X("=", eleq, cdeq); + case OPaddass: X("+=", elopass,cdaddass); + case OPminass: X("-=", elopass,cdaddass); + case OPmulass: X("*=", elopass,cdmulass); + case OPdivass: X("/=", elopass,cdmulass); + case OPmodass: X("%=", elopass,cdmulass); + case OPshrass: X(">>>=", elopass,cdshass); + case OPashrass: X(">>=", elopass,cdshass); + case OPshlass: X("<<=", elopass,cdshass); + case OPandass: X("&=", elopass,cdaddass); + case OPxorass: X("^=", elopass,cdaddass); + case OPorass: X("|=", elopass,cdaddass); + + case OPle: X("<=", elcmp, cdcmp); + case OPgt: X(">", elcmp, cdcmp); + case OPlt: X("<", elcmp, cdcmp); + case OPge: X(">=", elcmp, cdcmp); + case OPeqeq: X("==", elcmp, cdcmp); + case OPne: X("!=", elcmp, cdcmp); + + case OPunord: X("!<>=", elcmp, cdcmp); + case OPlg: X("<>", elcmp, cdcmp); + case OPleg: X("<>=", elcmp, cdcmp); + case OPule: X("!>", elcmp, cdcmp); + case OPul: X("!>=", elcmp, cdcmp); + case OPuge: X("!<", elcmp, cdcmp); + case OPug: X("!<=", elcmp, cdcmp); + case OPue: X("!<>", elcmp, cdcmp); + case OPngt: X("~>", elcmp, cdcmp); + case OPnge: X("~>=", elcmp, cdcmp); + case OPnlt: X("~<", elcmp, cdcmp); + case OPnle: X("~<=", elcmp, cdcmp); + case OPord: X("~!<>=", elcmp, cdcmp); + case OPnlg: X("~<>", elcmp, cdcmp); + case OPnleg: X("~<>=", elcmp, cdcmp); + case OPnule: X("~!>", elcmp, cdcmp); + case OPnul: X("~!>=", elcmp, cdcmp); + case OPnuge: X("~!<", elcmp, cdcmp); + case OPnug: X("~!<=", elcmp, cdcmp); + case OPnue: X("~!<>", elcmp, cdcmp); + +#if TARGET_SEGMENTED + case OPvp_fp: X("vptrfptr", elvptrfptr,cdcnvt); + case OPcvp_fp: X("cvptrfptr", elvptrfptr,cdcnvt); + case OPoffset: X("offset", ellngsht,cdlngsht); + case OPnp_fp: X("ptrlptr", elptrlptr,cdshtlng); + case OPnp_f16p: X("tofar16", elzot, cdfar16); + case OPf16p_np: X("fromfar16", elzot, cdfar16); +#endif + case OPs16_32: X("s16_32", evalu8, cdshtlng); + case OPu16_32: X("u16_32", evalu8, cdshtlng); + case OPd_s32: X("d_s32", evalu8, cdcnvt); + case OPb_8: X("b_8", evalu8, cdcnvt); + case OPs32_d: X("s32_d", evalu8, cdcnvt); + case OPd_s16: X("d_s16", evalu8, cdcnvt); + case OPs16_d: X("s16_d", evalu8, cdcnvt); + case OPd_u16: X("d_u16", evalu8, cdcnvt); + case OPu16_d: X("u16_d", evalu8, cdcnvt); + case OPd_u32: X("d_u32", evalu8, cdcnvt); + case OPu32_d: X("u32_d", evalu8, cdcnvt); + case OP32_16: X("32_16", ellngsht,cdlngsht); + case OPd_f: X("d_f", evalu8, cdcnvt); + case OPf_d: X("f_d", evalu8, cdcnvt); + case OPd_ld: X("d_ld", evalu8, cdcnvt); + case OPld_d: X("ld_d", evalu8, cdcnvt); + case OPc_r: X("c_r", elc_r, cdconvt87); + case OPc_i: X("c_i", elc_i, cdconvt87); + case OPu8_16: X("u8_16", elbyteint, cdbyteint); + case OPs8_16: X("s8_16", elbyteint, cdbyteint); + case OP16_8: X("16_8", ellngsht,cdlngsht); + case OPu32_64: X("u32_64", evalu8, cdshtlng); + case OPs32_64: X("s32_64", evalu8, cdshtlng); + case OP64_32: X("64_32", el64_32, cdlngsht); + case OPu64_128: X("u64_128", evalu8, cdshtlng); + case OPs64_128: X("s64_128", evalu8, cdshtlng); + case OP128_64: X("128_64", el64_32, cdlngsht); + case OPmsw: X("msw", evalu8, cdmsw); + + case OPd_s64: X("d_s64", evalu8, cdcnvt); + case OPs64_d: X("s64_d", evalu8, cdcnvt); + case OPd_u64: X("d_u64", evalu8, cdcnvt); + case OPu64_d: X("u64_d", evalu8, cdcnvt); + case OPld_u64: X("ld_u64", evalu8, cdcnvt); + case OPparam: X("param", elparam, cderr); + case OPsizeof: X("sizeof", elzot, cderr); + case OParrow: X("->", elzot, cderr); + case OParrowstar: X("->*", elzot, cderr); + case OPcolon: X("colon", elzot, cderr); + case OPcolon2: X("colon2", elzot, cderr); + case OPbool: X("bool", elbool, cdnot); + case OPcall: X("call", elcall, cdfunc); + case OPucall: X("ucall", elcall, cdfunc); + case OPcallns: X("callns", elcall, cdfunc); + case OPucallns: X("ucallns", elcall, cdfunc); + case OPstrpar: X("strpar", elstruct, cderr); + case OPstrctor: X("strctor", elzot, cderr); + case OPstrthis: X("strthis", elzot, cdstrthis); + case OPconst: X("const", elerr, cderr); + case OPvar: X("var", elerr, loaddata); + case OPreg: X("reg", elerr, cderr); + case OPnew: X("new", elerr, cderr); + case OPanew: X("new[]", elerr, cderr); + case OPdelete: X("delete", elerr, cderr); + case OPadelete: X("delete[]", elerr, cderr); + case OPbrack: X("brack", elerr, cderr); + case OPframeptr: X("frameptr", elzot, cdframeptr); + case OPgot: X("got", elzot, cdgot); + + case OPbsf: X("bsf", elzot, cdbscan); + case OPbsr: X("bsr", elzot, cdbscan); + case OPbt: X("bt", elzot, cdbt); + case OPbtc: X("btc", elzot, cdbt); + case OPbtr: X("btr", elzot, cdbt); + case OPbts: X("bts", elzot, cdbt); + + case OPbswap: X("bswap", evalu8, cdbswap); + case OPvector: X("vector", elzot, cdvector); + + default: + printf("opcode hole x%x\n",i); + exit(EXIT_FAILURE); +#undef X + } + } + + fprintf(fdeb,"static const char *debtab[OPMAX] = \n\t{\n"); + for (i = 0; i < OPMAX - 1; i++) + fprintf(fdeb,"\t\"%s\",\n",debtab[i]); + fprintf(fdeb,"\t\"%s\"\n\t};\n",debtab[i]); + + f = fopen("cdxxx.c","w"); + fprintf(f,"code *(*cdxxx[OPMAX]) (elem *,regm_t *) = \n\t{\n"); + for (i = 0; i < OPMAX - 1; i++) + fprintf(f,"\t%s,\n",cdxxx[i]); + fprintf(f,"\t%s\n\t};\n",cdxxx[i]); + fclose(f); + + f = fopen("elxxx.c","w"); + fprintf(f,"static elem *(*elxxx[OPMAX]) (elem *) = \n\t{\n"); + for (i = 0; i < OPMAX - 1; i++) + fprintf(f,"\t%s,\n",elxxx[i]); + fprintf(f,"\t%s\n\t};\n",elxxx[i]); + fclose(f); +} + +void fltables() +{ FILE *f; + int i; + char segfl[FLMAX]; + char datafl[FLMAX]; + char stackfl[FLMAX]; + char flinsymtab[FLMAX]; + + static char indatafl[] = /* is FLxxxx a data type? */ + { FLdata,FLudata,FLreg,FLpseudo,FLauto,FLpara,FLextern,FLtmp, + FLcs,FLfltreg,FLallocatmp,FLdatseg,FLndp,FLtlsdata,FLbprel, + FLstack,FLregsave }; +#if TARGET_SEGMENTED + static char indatafl_s[] = { FLfardata, }; +#endif + + static char instackfl[] = /* is FLxxxx a stack data type? */ + { FLauto,FLpara,FLtmp,FLcs,FLfltreg,FLallocatmp,FLndp,FLbprel,FLstack,FLregsave }; + + static char inflinsymtab[] = /* is FLxxxx in the symbol table? */ + { FLdata,FLudata,FLreg,FLpseudo,FLauto,FLpara,FLextern,FLtmp,FLfunc, + FLtlsdata,FLbprel,FLstack }; +#if TARGET_SEGMENTED + static char inflinsymtab_s[] = { FLfardata,FLcsdata, }; +#endif + + for (i = 0; i < FLMAX; i++) + datafl[i] = stackfl[i] = flinsymtab[i] = 0; + + for (i = 0; i < sizeof(indatafl); i++) + datafl[indatafl[i]] = 1; + + for (i = 0; i < sizeof(instackfl); i++) + stackfl[instackfl[i]] = 1; + + for (i = 0; i < sizeof(inflinsymtab); i++) + flinsymtab[inflinsymtab[i]] = 1; + +#if TARGET_SEGMENTED + for (i = 0; i < sizeof(indatafl_s); i++) + datafl[indatafl_s[i]] = 1; + + for (i = 0; i < sizeof(inflinsymtab_s); i++) + flinsymtab[inflinsymtab_s[i]] = 1; +#endif + +/* Segment registers */ +#define ES 0 +#define CS 1 +#define SS 2 +#define DS 3 + + for (i = 0; i < FLMAX; i++) + { switch (i) + { + case 0: segfl[i] = -1; break; + case FLconst: segfl[i] = -1; break; + case FLoper: segfl[i] = -1; break; + case FLfunc: segfl[i] = CS; break; + case FLdata: segfl[i] = DS; break; + case FLudata: segfl[i] = DS; break; + case FLreg: segfl[i] = -1; break; + case FLpseudo: segfl[i] = -1; break; + case FLauto: segfl[i] = SS; break; + case FLstack: segfl[i] = SS; break; + case FLbprel: segfl[i] = SS; break; + case FLpara: segfl[i] = SS; break; + case FLextern: segfl[i] = DS; break; + case FLtmp: segfl[i] = SS; break; + case FLcode: segfl[i] = CS; break; + case FLblock: segfl[i] = CS; break; + case FLblockoff: segfl[i] = CS; break; + case FLcs: segfl[i] = SS; break; + case FLregsave: segfl[i] = SS; break; + case FLndp: segfl[i] = SS; break; + case FLswitch: segfl[i] = -1; break; + case FLfltreg: segfl[i] = SS; break; + case FLoffset: segfl[i] = -1; break; +#if TARGET_SEGMENTED + case FLfardata: segfl[i] = -1; break; + case FLcsdata: segfl[i] = CS; break; +#endif + case FLdatseg: segfl[i] = DS; break; + case FLctor: segfl[i] = -1; break; + case FLdtor: segfl[i] = -1; break; + case FLdsymbol: segfl[i] = -1; break; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case FLgot: segfl[i] = -1; break; + case FLgotoff: segfl[i] = -1; break; +#endif + case FLlocalsize: segfl[i] = -1; break; + case FLtlsdata: segfl[i] = -1; break; + case FLframehandler: segfl[i] = -1; break; + case FLasm: segfl[i] = -1; break; + case FLallocatmp: segfl[i] = SS; break; + default: + printf("error in segfl[%d]\n", i); + exit(1); + } + } + + f = fopen("fltables.c","w"); + + fprintf(f,"const char datafl[FLMAX] = \n\t{ "); + for (i = 0; i < FLMAX - 1; i++) + fprintf(f,"%d,",datafl[i]); + fprintf(f,"%d };\n",datafl[i]); + + fprintf(f,"const char stackfl[FLMAX] = \n\t{ "); + for (i = 0; i < FLMAX - 1; i++) + fprintf(f,"%d,",stackfl[i]); + fprintf(f,"%d };\n",stackfl[i]); + + fprintf(f,"const char segfl[FLMAX] = \n\t{ "); + for (i = 0; i < FLMAX - 1; i++) + fprintf(f,"%d,",segfl[i]); + fprintf(f,"%d };\n",segfl[i]); + + fprintf(f,"const char flinsymtab[FLMAX] = \n\t{ "); + for (i = 0; i < FLMAX - 1; i++) + fprintf(f,"%d,",flinsymtab[i]); + fprintf(f,"%d };\n",flinsymtab[i]); + + fclose(f); +} + +void dotytab() +{ + static tym_t _ptr[] = { TYjhandle,TYnptr }; +#if TARGET_SEGMENTED + static tym_t _ptr_nflat[]= { TYsptr,TYcptr,TYf16ptr,TYfptr,TYhptr,TYvptr }; +#endif + static tym_t _real[] = { TYfloat,TYdouble,TYdouble_alias,TYldouble, + TYfloat4,TYdouble2, + }; + static tym_t _imaginary[] = { + TYifloat,TYidouble,TYildouble, + }; + static tym_t _complex[] = { + TYcfloat,TYcdouble,TYcldouble, + }; + static tym_t _integral[] = { TYbool,TYchar,TYschar,TYuchar,TYshort, + TYwchar_t,TYushort,TYenum,TYint,TYuint, + TYlong,TYulong,TYllong,TYullong,TYdchar, + TYschar16,TYuchar16,TYshort8,TYushort8, + TYlong4,TYulong4,TYllong2,TYullong2, + TYchar16, TYcent, TYucent }; + static tym_t _ref[] = { TYnref,TYref }; + static tym_t _func[] = { TYnfunc,TYnpfunc,TYnsfunc,TYifunc,TYmfunc,TYjfunc,TYhfunc }; +#if TARGET_SEGMENTED + static tym_t _ref_nflat[] = { TYfref }; + static tym_t _func_nflat[]= { TYffunc,TYfpfunc,TYf16func,TYfsfunc,TYnsysfunc,TYfsysfunc, }; +#endif + static tym_t _uns[] = { TYuchar,TYushort,TYuint,TYulong, +#if MARS + TYwchar_t, +#endif + TYuchar16,TYushort8,TYulong4,TYullong2, + TYdchar,TYullong,TYucent,TYchar16 }; +#if !MARS + static tym_t _mptr[] = { TYmemptr }; +#endif + static tym_t _nullptr[] = { TYnullptr }; +#if TARGET_SEGMENTED +#if OMFOBJ + static tym_t _fv[] = { TYfptr, TYvptr }; +#endif +#if TARGET_WINDOS + static tym_t _farfunc[] = { TYffunc,TYfpfunc,TYfsfunc,TYfsysfunc }; +#endif +#endif + static tym_t _pasfunc[] = { TYnpfunc,TYnsfunc,TYmfunc,TYjfunc }; +#if TARGET_SEGMENTED + static tym_t _pasfunc_nf[] = { TYfpfunc,TYf16func,TYfsfunc, }; +#endif + static tym_t _revfunc[] = { TYnpfunc,TYjfunc }; +#if TARGET_SEGMENTED + static tym_t _revfunc_nf[] = { TYfpfunc,TYf16func, }; +#endif + static tym_t _short[] = { TYbool,TYchar,TYschar,TYuchar,TYshort, + TYwchar_t,TYushort,TYchar16 }; + static tym_t _aggregate[] = { TYstruct,TYarray }; +#if TX86 + static tym_t _xmmreg[] = { + TYfloat,TYdouble,TYifloat,TYidouble, + TYfloat4,TYdouble2, + TYschar16,TYuchar16,TYshort8,TYushort8, + TYlong4,TYulong4,TYllong2,TYullong2, + }; +#endif + + static struct + { + const char *string; /* name of type */ + tym_t ty; /* TYxxxx */ + tym_t unsty; /* conversion to unsigned type */ + tym_t relty; /* type for relaxed type checking */ + int size; + int debtyp; /* Codeview 1 type in debugger record */ + int debtyp4; /* Codeview 4 type in debugger record */ + } typetab[] = + { +/* Note that chars are signed, here */ +"bool", TYbool, TYbool, TYchar, 1, 0x80, 0x30, +"char", TYchar, TYuchar, TYchar, 1, 0x80, 0x70, +"signed char", TYschar, TYuchar, TYchar, 1, 0x80, 0x10, +"unsigned char",TYuchar, TYuchar, TYchar, 1, 0x84, 0x20, +"char16_t", TYchar16, TYchar16, TYint, 2, 0x85, 0x21, +"short", TYshort, TYushort, TYint, SHORTSIZE, 0x81,0x11, +"wchar_t", TYwchar_t, TYwchar_t, TYint, SHORTSIZE, 0x85,0x71, +"unsigned short",TYushort, TYushort, TYint, SHORTSIZE, 0x85,0x21, + +// These values are adjusted for 32 bit ints in cv_init() and util_set32() +"enum", TYenum, TYuint, TYint, -1, 0x81,0x72, +"int", TYint, TYuint, TYint, 2, 0x81,0x72, +"unsigned", TYuint, TYuint, TYint, 2, 0x85,0x73, + +"long", TYlong, TYulong, TYlong, LONGSIZE, 0x82,0x12, +"unsigned long",TYulong, TYulong, TYlong, LONGSIZE, 0x86,0x22, +"dchar", TYdchar, TYdchar, TYlong, 4, 0x86,0x78, +"long long", TYllong, TYullong, TYllong, LLONGSIZE, 0x82,0x13, +"uns long long",TYullong, TYullong, TYllong, LLONGSIZE, 0x86,0x23, +"cent", TYcent, TYucent, TYcent, 16, 0x82,0x13, +"ucent", TYucent, TYucent, TYcent, 16, 0x86,0x23, +"float", TYfloat, TYfloat, TYfloat, FLOATSIZE, 0x88,0x40, +"double", TYdouble, TYdouble, TYdouble, DOUBLESIZE,0x89,0x41, +"double alias", TYdouble_alias, TYdouble_alias, TYdouble_alias,8, 0x89,0x41, +"long double", TYldouble, TYldouble, TYldouble, LNGDBLSIZE, 0x89,0x42, + +"imaginary float", TYifloat, TYifloat, TYifloat, FLOATSIZE, 0x88,0x40, +"imaginary double", TYidouble, TYidouble, TYidouble, DOUBLESIZE,0x89,0x41, +"imaginary long double",TYildouble, TYildouble, TYildouble, LNGDBLSIZE,0x89,0x42, + +"complex float", TYcfloat, TYcfloat, TYcfloat, 2*FLOATSIZE, 0x88,0x50, +"complex double", TYcdouble, TYcdouble, TYcdouble, 2*DOUBLESIZE,0x89,0x51, +"complex long double", TYcldouble, TYcldouble, TYcldouble, 2*LNGDBLSIZE,0x89,0x52, + +"float[4]", TYfloat4, TYfloat4, TYfloat4, 16, 0, 0, +"double[2]", TYdouble2, TYdouble2, TYdouble2, 16, 0, 0, +"signed char[16]", TYschar16, TYuchar16, TYschar16, 16, 0, 0, +"unsigned char[16]", TYuchar16, TYuchar16, TYuchar16, 16, 0, 0, +"short[8]", TYshort8, TYushort8, TYshort8, 16, 0, 0, +"unsigned short[8]", TYushort8, TYushort8, TYushort8, 16, 0, 0, +"long[4]", TYlong4, TYulong4, TYlong4, 16, 0, 0, +"unsigned long[4]", TYulong4, TYulong4, TYulong4, 16, 0, 0, +"long long[2]", TYllong2, TYullong2, TYllong2, 16, 0, 0, +"unsigned long long[2]", TYullong2, TYullong2, TYullong2, 16, 0, 0, + +"__near *", TYjhandle, TYjhandle, TYjhandle, 2, 0x20, 0x100, +"nullptr_t", TYnullptr, TYnullptr, TYptr, 2, 0x20, 0x100, +"*", TYnptr, TYnptr, TYnptr, 2, 0x20, 0x100, +"&", TYref, TYref, TYref, -1, 0, 0, +"void", TYvoid, TYvoid, TYvoid, -1, 0x85, 3, +"struct", TYstruct, TYstruct, TYstruct, -1, 0, 0, +"array", TYarray, TYarray, TYarray, -1, 0x78, 0, +"C func", TYnfunc, TYnfunc, TYnfunc, -1, 0x63, 0, +"Pascal func", TYnpfunc, TYnpfunc, TYnpfunc, -1, 0x74, 0, +"std func", TYnsfunc, TYnsfunc, TYnsfunc, -1, 0x63, 0, +"*", TYptr, TYptr, TYptr, 2, 0x20, 0x100, +"member func", TYmfunc, TYmfunc, TYmfunc, -1, 0x64, 0, +"D func", TYjfunc, TYjfunc, TYjfunc, -1, 0x74, 0, +"C func", TYhfunc, TYhfunc, TYhfunc, -1, 0, 0, +"__near &", TYnref, TYnref, TYnref, 2, 0, 0, + +#if TARGET_SEGMENTED +"__ss *", TYsptr, TYsptr, TYsptr, 2, 0x20, 0x100, +"__cs *", TYcptr, TYcptr, TYcptr, 2, 0x20, 0x100, +"__far16 *", TYf16ptr, TYf16ptr, TYf16ptr, 4, 0x40, 0x200, +"__far *", TYfptr, TYfptr, TYfptr, 4, 0x40, 0x200, +"__huge *", TYhptr, TYhptr, TYhptr, 4, 0x40, 0x300, +"__handle *", TYvptr, TYvptr, TYvptr, 4, 0x40, 0x200, +"far C func", TYffunc, TYffunc, TYffunc, -1, 0x64, 0, +"far Pascal func", TYfpfunc, TYfpfunc, TYfpfunc, -1, 0x73, 0, +"far std func", TYfsfunc, TYfsfunc, TYfsfunc, -1, 0x64, 0, +"_far16 Pascal func", TYf16func, TYf16func, TYf16func, -1, 0x63, 0, +"sys func", TYnsysfunc, TYnsysfunc,TYnsysfunc, -1, 0x63, 0, +"far sys func", TYfsysfunc, TYfsysfunc,TYfsysfunc, -1, 0x64, 0, +"__far &", TYfref, TYfref, TYfref, 4, 0, 0, +#endif +#if !MARS +"interrupt func", TYifunc, TYifunc, TYifunc, -1, 0x64, 0, +"memptr", TYmemptr, TYmemptr, TYmemptr, -1, 0, 0, +"ident", TYident, TYident, TYident, -1, 0, 0, +"template", TYtemplate, TYtemplate, TYtemplate, -1, 0, 0, +"vtshape", TYvtshape, TYvtshape, TYvtshape, -1, 0, 0, +#endif + }; + + FILE *f; + static unsigned tytab[64 * 4]; + static tym_t tytouns[64 * 4]; + static tym_t _tyrelax[TYMAX]; + static tym_t _tyequiv[TYMAX]; + static signed char tysize[64 * 4]; + static const char *tystring[TYMAX]; + static unsigned char dttab[TYMAX]; + static unsigned short dttab4[TYMAX]; + int i; + +#define T1(arr,mask) for (i=0; i +#include +#include +#include + +#if DOS386 +#include +#include +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#include +#include +#include +#include +#define GetLastError() errno +#elif _WIN32 +#include +#include +#include +#endif + +#if __DMC__ || __GNUC__ +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" +#else +#include +#endif + +#if _WINDLL +extern void dll_printf(const char *format,...); +#define dbg_printf dll_printf +#else +#define dbg_printf printf +#endif + +int file_createdirs(char *name); + +/*********************************** + * Called when there is an error returned by the operating system. + * This function does not return. + */ + +void os_error(int line) +{ +#if _WIN32 + dbg_printf("System error: %ldL\n",GetLastError()); +#endif + local_assert(line); +} + +#if 1 +#undef dbg_printf +#define dbg_printf (void) +#endif + +#define os_error() os_error(__LINE__) +#pragma noreturn(os_error) + +#if _WIN32 +/********************************* + * Allocate a chunk of memory from the operating system. + * Bypass malloc and friends. + */ + +static HANDLE hHeap; + +void *globalrealloc(void *oldp,size_t newsize) +{ +#if 0 + void *p; + + // Initialize heap + if (!hHeap) + { hHeap = HeapCreate(0,0x10000,0); + if (!hHeap) + os_error(); + } + + newsize = (newsize + 3) & ~3L; // round up to dwords + if (newsize == 0) + { + if (oldp && HeapFree(hHeap,0,oldp) == FALSE) + os_error(); + p = NULL; + } + else if (!oldp) + { + p = newsize ? HeapAlloc(hHeap,0,newsize) : NULL; + } + else + p = HeapReAlloc(hHeap,0,oldp,newsize); +#elif 1 + MEMORY_BASIC_INFORMATION query; + void *p; + BOOL bSuccess; + + if (!oldp) + p = VirtualAlloc (NULL, newsize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + else + { + VirtualQuery (oldp, &query, sizeof(query)); + if (!newsize) + { + p = NULL; + goto L1; + } + else + { newsize = (newsize + 0xFFFF) & ~0xFFFFL; + + if (query.RegionSize >= newsize) + p = oldp; + else + { p = VirtualAlloc(NULL,newsize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE); + if (p) + memcpy(p,oldp,query.RegionSize); + L1: + bSuccess = VirtualFree(oldp,query.RegionSize,MEM_DECOMMIT); + if (bSuccess) + bSuccess = VirtualFree(oldp,0,MEM_RELEASE); + if (!bSuccess) + os_error(); + } + } + } +#else + void *p; + + if (!oldp) + p = (void *)GlobalAlloc (0, newsize); + else if (!newsize) + { GlobalFree(oldp); + p = NULL; + } + else + p = (void *)GlobalReAlloc(oldp,newsize,0); +#endif + dbg_printf("globalrealloc(oldp = %p, size = x%x) = %p\n",oldp,newsize,p); + return p; +} + +/***************************************** + * Functions to manage allocating a single virtual address space. + */ + +void *vmem_reserve(void *ptr,unsigned long size) +{ void *p; + +#if 1 + p = VirtualAlloc(ptr,size,MEM_RESERVE,PAGE_READWRITE); + dbg_printf("vmem_reserve(ptr = %p, size = x%lx) = %p\n",ptr,size,p); +#else + dbg_printf("vmem_reserve(ptr = %p, size = x%lx) = %p\n",ptr,size,p); + p = VirtualAlloc(ptr,size,MEM_RESERVE,PAGE_READWRITE); + if (!p) + os_error(); +#endif + return p; +} + +/***************************************** + * Commit memory. + * Returns: + * 0 failure + * !=0 success + */ + +int vmem_commit(void *ptr, unsigned long size) +{ int i; + + dbg_printf("vmem_commit(ptr = %p,size = x%lx)\n",ptr,size); + i = (int) VirtualAlloc(ptr,size,MEM_COMMIT,PAGE_READWRITE); + if (i == 0) + dbg_printf("failed to commit\n"); + return i; +} + +void vmem_decommit(void *ptr,unsigned long size) +{ + dbg_printf("vmem_decommit(ptr = %p, size = x%lx)\n",ptr,size); + if (ptr) + { if (!VirtualFree(ptr, size, MEM_DECOMMIT)) + os_error(); + } +} + +void vmem_release(void *ptr,unsigned long size) +{ + dbg_printf("vmem_release(ptr = %p, size = x%lx)\n",ptr,size); + if (ptr) + { + if (!VirtualFree(ptr, 0, MEM_RELEASE)) + os_error(); + } +} + +/******************************************** + * Map file for read, copy on write, into virtual address space. + * Input: + * ptr address to map file to, if NULL then pick an address + * size length of the file + * flag 0 read / write + * 1 read / copy on write + * 2 read only + * Returns: + * NULL failure + * ptr pointer to start of mapped file + */ + +static HANDLE hFile = INVALID_HANDLE_VALUE; +static HANDLE hFileMap = NULL; +static void *pview; +static void *preserve; +static size_t preserve_size; + +void *vmem_mapfile(const char *filename,void *ptr,unsigned long size,int flag) +{ + OSVERSIONINFO OsVerInfo; + + OsVerInfo.dwOSVersionInfoSize = sizeof(OsVerInfo); + GetVersionEx(&OsVerInfo); + + dbg_printf("vmem_mapfile(filename = '%s', ptr = %p, size = x%lx, flag = %d)\n",filename,ptr,size,flag); + + hFile = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) + goto L1; // failure + dbg_printf(" file created\n"); + + // Windows 95 does not implement PAGE_WRITECOPY (unfortunately treating + // it just like PAGE_READWRITE). + if (flag == 1 && OsVerInfo.dwPlatformId == 1) // Windows 95, 98, ME + hFileMap = NULL; + else + hFileMap = CreateFileMapping(hFile,NULL, + (flag == 1) ? PAGE_WRITECOPY : PAGE_READWRITE,0,size,NULL); + + if (hFileMap == NULL) // mapping failed + { +#if 1 + // Win32s seems to always fail here. + DWORD nbytes; + + dbg_printf(" mapping failed\n"); + // If it was NT failing, assert. + assert(OsVerInfo.dwPlatformId != VER_PLATFORM_WIN32_NT); + + // To work around, just read the file into memory. + assert(flag == 1); + preserve = vmem_reserve(ptr,size); + if (!preserve) + goto L2; + if (!vmem_commit(preserve,size)) + { + vmem_release(preserve,size); + preserve = NULL; + goto L2; + } + preserve_size = size; + if (!ReadFile(hFile,preserve,size,&nbytes,NULL)) + os_error(); + assert(nbytes == size); + if (CloseHandle(hFile) != TRUE) + os_error(); + hFile = INVALID_HANDLE_VALUE; + return preserve; +#else + // Instead of working around, we should find out why it failed. + os_error(); +#endif + } + else + { + dbg_printf(" mapping created\n"); + pview = MapViewOfFileEx(hFileMap,flag ? FILE_MAP_COPY : FILE_MAP_WRITE, + 0,0,size,ptr); + if (pview == NULL) // mapping view failed + { //os_error(); + goto L3; + } + } + dbg_printf(" pview = %p\n",pview); + + return pview; + +Terminate: + if (UnmapViewOfFile(pview) == FALSE) + os_error(); + pview = NULL; +L3: + if (CloseHandle(hFileMap) != TRUE) + os_error(); + hFileMap = NULL; +L2: + if (CloseHandle(hFile) != TRUE) + os_error(); + hFile = INVALID_HANDLE_VALUE; +L1: + return NULL; // failure +} + +/***************************** + * Set size of mapped file. + */ + +void vmem_setfilesize(unsigned long size) +{ + if (hFile != INVALID_HANDLE_VALUE) + { if (SetFilePointer(hFile,size,NULL,FILE_BEGIN) == 0xFFFFFFFF) + os_error(); + if (SetEndOfFile(hFile) == FALSE) + os_error(); + } +} + +/***************************** + * Unmap previous file mapping. + */ + +void vmem_unmapfile() +{ + dbg_printf("vmem_unmapfile()\n"); + + vmem_decommit(preserve,preserve_size); + vmem_release(preserve,preserve_size); + preserve = NULL; + preserve_size = 0; + +#if 0 + if (pview) + { int i; + + i = UnmapViewOfFile(pview); + dbg_printf("i = x%x\n",i); + if (i == FALSE) + os_error(); + } +#else + // Note that under Windows 95, UnmapViewOfFile() seems to return random + // values, not TRUE or FALSE. + if (pview && UnmapViewOfFile(pview) == FALSE) + os_error(); +#endif + pview = NULL; + + if (hFileMap != NULL && CloseHandle(hFileMap) != TRUE) + os_error(); + hFileMap = NULL; + + if (hFile != INVALID_HANDLE_VALUE && CloseHandle(hFile) != TRUE) + os_error(); + hFile = INVALID_HANDLE_VALUE; +} + +/**************************************** + * Determine a base address that we can use for mapping files to. + */ + +void *vmem_baseaddr() +{ + OSVERSIONINFO OsVerInfo; + void *p; + + OsVerInfo.dwOSVersionInfoSize = sizeof(OsVerInfo); + GetVersionEx(&OsVerInfo); + + // These values for the address were determined by trial and error. + switch (OsVerInfo.dwPlatformId) + { + case VER_PLATFORM_WIN32s: // Win32s + // The fact that this is a different address than other + // WIN32 implementations causes us a lot of grief. + p = (void *) 0xC0000000; + break; + + case 1: //VER_PLATFORM_WIN32_WINDOWS: // Windows 95 + // I've found 0x90000000..0xB work. All others fail. + default: // unknown + p = (void *) 0x90000000; + break; + + case VER_PLATFORM_WIN32_NT: // Windows NT + // Pick a value that is not coincident with the base address + // of any commonly used system DLLs. + p = (void *) 0x38000000; + break; + } + + return p; +} + +/******************************************** + * Calculate the amount of memory to reserve, adjusting + * *psize downwards. + */ + +void vmem_reservesize(unsigned long *psize) +{ + MEMORYSTATUS ms; + OSVERSIONINFO OsVerInfo; + + unsigned long size; + + ms.dwLength = sizeof(ms); + GlobalMemoryStatus(&ms); + dbg_printf("dwMemoryLoad x%lx\n",ms.dwMemoryLoad); + dbg_printf("dwTotalPhys x%lx\n",ms.dwTotalPhys); + dbg_printf("dwAvailPhys x%lx\n",ms.dwAvailPhys); + dbg_printf("dwTotalPageFile x%lx\n",ms.dwTotalPageFile); + dbg_printf("dwAvailPageFile x%lx\n",ms.dwAvailPageFile); + dbg_printf("dwTotalVirtual x%lx\n",ms.dwTotalVirtual); + dbg_printf("dwAvailVirtual x%lx\n",ms.dwAvailVirtual); + + + OsVerInfo.dwOSVersionInfoSize = sizeof(OsVerInfo); + GetVersionEx(&OsVerInfo); + + switch (OsVerInfo.dwPlatformId) + { + case VER_PLATFORM_WIN32s: // Win32s + case 1: //VER_PLATFORM_WIN32_WINDOWS: // Windows 95 + default: // unknown + size = (ms.dwAvailPageFile < ms.dwAvailVirtual) + ? ms.dwAvailPageFile + : ms.dwAvailVirtual; + size = (unsigned long long)size * 8 / 10; + size &= ~0xFFFFL; + if (size < *psize) + *psize = size; + break; + + case VER_PLATFORM_WIN32_NT: // Windows NT + // NT can expand the paging file + break; + } + +} + +/******************************************** + * Return amount of physical memory. + */ + +unsigned long vmem_physmem() +{ + MEMORYSTATUS ms; + + ms.dwLength = sizeof(ms); + GlobalMemoryStatus(&ms); + return ms.dwTotalPhys; +} + +////////////////////////////////////////////////////////////// + +/*************************************************** + * Load library. + */ + +static HINSTANCE hdll; + +void os_loadlibrary(const char *dllname) +{ + hdll = LoadLibrary((LPCTSTR) dllname); + if (!hdll) + os_error(); +} + +/************************************************* + */ + +void os_freelibrary() +{ + if (hdll) + { + if (FreeLibrary(hdll) != TRUE) + os_error(); + hdll = NULL; + } +} + +/************************************************* + */ + +void *os_getprocaddress(const char *funcname) +{ void *fp; + + //printf("getprocaddress('%s')\n",funcname); + assert(hdll); + fp = (void *)GetProcAddress(hdll,(LPCSTR)funcname); + if (!fp) + os_error(); + return fp; +} + +////////////////////////////////////////////////////////////// + + +/********************************* + */ + +void os_term() +{ + if (hHeap) + { if (HeapDestroy(hHeap) == FALSE) + { hHeap = NULL; + os_error(); + } + hHeap = NULL; + } + os_freelibrary(); +} + +/*************************************************** + * Do our own storage allocator (being suspicious of the library one). + */ + +#if 1 + +void os_heapinit() { } +void os_heapterm() { } + +#else + +static HANDLE hHeap; + +void os_heapinit() +{ + hHeap = HeapCreate(0,0x10000,0); + if (!hHeap) + os_error(); +} + +void os_heapterm() +{ + if (hHeap) + { if (HeapDestroy(hHeap) == FALSE) + os_error(); + } +} + +void * __cdecl calloc(size_t x,size_t y) +{ size_t size; + + size = x * y; + return size ? HeapAlloc(hHeap,HEAP_ZERO_MEMORY,size) : NULL; +} + +void __cdecl free(void *p) +{ + if (p && HeapFree(hHeap,0,p) == FALSE) + os_error(); +} + +void * __cdecl malloc(size_t size) +{ + return size ? HeapAlloc(hHeap,0,size) : NULL; +} + +void * __cdecl realloc(void *p,size_t newsize) +{ + if (newsize == 0) + free(p); + else if (!p) + p = malloc(newsize); + else + p = HeapReAlloc(hHeap,0,p,newsize); + return p; +} + +#endif + +////////////////////////////////////////// +// Return a value that will hopefully be unique every time +// we call it. + +unsigned long os_unique() +{ + unsigned long long x; + + QueryPerformanceCounter((LARGE_INTEGER *)&x); + return x; +} + +#elif DOS386 + +////////////////////////////////////////// +// Return a value that will hopefully be unique every time +// we call it. + +unsigned long os_unique() +{ + if (cputype() >= 5) // if cpuid instruction supported + { + __asm + { + mov EAX,1 + cpuid + test EDX,0x20 // is rdtsc supported? + jz L1 // no + rdtsc + } + } + else + { +L1: time(NULL); + } + return _EAX; +} + +#endif + +/******************************************* + * Return !=0 if file exists. + * 0: file doesn't exist + * 1: normal file + * 2: directory + */ + +int os_file_exists(const char *name) +{ +#if _WIN32 + DWORD dw; + int result; + + dw = GetFileAttributes(name); + if (dw == -1L) + result = 0; + else if (dw & FILE_ATTRIBUTE_DIRECTORY) + result = 2; + else + result = 1; + return result; +#elif DOS386 + struct FIND *find; + + find = findfirst(name,FA_DIREC | FA_SYSTEM | FA_HIDDEN); + if (!find) + return 0; + return (find->attribute & FA_DIREC) ? 2 : 1; +#elif linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + struct stat buf; + + return stat(name,&buf) == 0; /* file exists if stat succeeded */ + +#else + return filesize(name) != -1L; +#endif +} + +/************************************** + * Get file size of open file. Return -1L on error. + */ + +#if _WIN32 +extern "C" void * __cdecl _osfhnd[]; +#endif + +long os_file_size(int fd) +{ +#if _WIN32 + return GetFileSize(_osfhnd[fd],NULL); +#else + struct stat buf; + + return (fstat(fd,&buf)) ? -1L : buf.st_size; +#endif +} + +/************************************************** + * For 16 bit programs, we need the 16 bit filename. + * Returns: + * malloc'd string, NULL if none + */ + +#if _WIN32 + +char *file_8dot3name(const char *filename) +{ + HANDLE h; + WIN32_FIND_DATA fileinfo; + char *buf; + int i; + + h = FindFirstFile(filename,&fileinfo); + if (h == INVALID_HANDLE_VALUE) + return NULL; + if (fileinfo.cAlternateFileName[0]) + { + for (i = strlen(filename); i > 0; i--) + if (filename[i] == '\\' || filename[i] == ':') + { i++; + break; + } + buf = (char *) malloc(i + 14); + if (buf) + { + memcpy(buf,filename,i); + strcpy(buf + i,fileinfo.cAlternateFileName); + } + } + else + buf = strdup(filename); + FindClose(h); + return buf; +} + +#endif + +/********************************************** + * Write a file. + * Returns: + * 0 success + */ + +int file_write(char *name, void *buffer, unsigned len) +{ +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + int fd; + ssize_t numwritten; + + fd = open(name, O_CREAT | O_WRONLY | O_TRUNC, + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); + if (fd == -1) + goto err; + + numwritten = ::write(fd, buffer, len); + if (len != numwritten) + goto err2; + + if (close(fd) == -1) + goto err; + + return 0; + +err2: + close(fd); +err: + return 1; +#endif +#if _WIN32 + HANDLE h; + DWORD numwritten; + + h = CreateFile((LPTSTR)name,GENERIC_WRITE,0,NULL,CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL); + if (h == INVALID_HANDLE_VALUE) + { + if (GetLastError() == ERROR_PATH_NOT_FOUND) + { + if (!file_createdirs(name)) + { + h = CreateFile((LPTSTR)name,GENERIC_WRITE,0,NULL,CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL); + if (h != INVALID_HANDLE_VALUE) + goto Lok; + } + } + goto err; + } + +Lok: + if (WriteFile(h,buffer,len,&numwritten,NULL) != TRUE) + goto err2; + + if (len != numwritten) + goto err2; + + if (!CloseHandle(h)) + goto err; + return 0; + +err2: + CloseHandle(h); +err: + return 1; +#endif +#if _MSDOS + return 1; +#endif +} + +/******************************** + * Create directories up to filename. + * Input: + * name path/filename + * Returns: + * 0 success + * !=0 failure + */ + +int file_createdirs(char *name) +{ +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + return 1; +#endif +#if _WIN32 + int len = strlen(name); + char *path = (char *)alloca(len + 1); + char *p; + + memcpy(path, name, len + 1); + + for (p = path + len; ; p--) + { + if (p == path) + goto Lfail; + switch (*p) + { + case ':': + case '/': + case '\\': + *p = 0; + if (!CreateDirectory((LPTSTR)path, NULL)) + { // Failed + if (file_createdirs(path)) + goto Lfail; + if (!CreateDirectory((LPTSTR)path, NULL)) + goto Lfail; + } + return 0; + } + } + +Lfail: + return 1; +#endif +#if _MSDOS + return 1; +#endif +} + +/*********************************** + * Return size of OS critical section. + * NOTE: can't use the sizeof() calls directly since cross compiling is + * supported and would end up using the host sizes rather than the target + * sizes. + */ + +#if _WIN32 +int os_critsecsize32() +{ + return sizeof(CRITICAL_SECTION); +} + +int os_critsecsize64() +{ + assert(0); + return 0; +} +#endif + +#if linux +int os_critsecsize32() +{ + return 24; // sizeof(pthread_mutex_t) on 32 bit +} + +int os_critsecsize64() +{ + return 40; // sizeof(pthread_mutex_t) on 64 bit +} +#endif + +#if __FreeBSD__ +int os_critsecsize32() +{ + return 4; // sizeof(pthread_mutex_t) on 32 bit +} + +int os_critsecsize64() +{ + return 8; // sizeof(pthread_mutex_t) on 64 bit +} +#endif + +#if __OpenBSD__ +int os_critsecsize32() +{ + return 4; // sizeof(pthread_mutex_t) on 32 bit +} + +int os_critsecsize64() +{ + assert(0); + return 8; // sizeof(pthread_mutex_t) on 64 bit +} +#endif + +#if __APPLE__ +int os_critsecsize32() +{ +#if __LP64__ // check for bit rot + assert(sizeof(pthread_mutex_t) == 64); +#else + assert(sizeof(pthread_mutex_t) == 44); +#endif + return 44; +} + +int os_critsecsize64() +{ + return 64; +} +#endif + + +#if __sun&&__SVR4 +int os_critsecsize32() +{ + return sizeof(pthread_mutex_t); +} + +int os_critsecsize64() +{ + assert(0); + return 0; +} +#endif + +/* This is the magic program to get the size on Posix systems: */ + +#if 0 +#include +#include + +int main() +{ + printf("%d\n", (int)sizeof(pthread_mutex_t)); + return 0; +} +#endif + diff --git a/backend/out.c b/backend/out.c new file mode 100644 index 00000000..64c8ab3c --- /dev/null +++ b/backend/out.c @@ -0,0 +1,1534 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if !SPP + +#include +#include +#include + +#include "cc.h" +#include "oper.h" +#include "global.h" +#include "type.h" +#include "filespec.h" +#include "code.h" +#include "cgcv.h" +#include "go.h" +#include "dt.h" +#if SCPP +#include "parser.h" +#include "cpp.h" +#include "el.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +static int addrparam; /* see if any parameters get their address taken */ + +/********************************** + * We put out an external definition. + */ + +#if SCPP + +void out_extdef(symbol *s) +{ + pstate.STflags |= PFLextdef; + if (//config.flags2 & CFG2phgen || + (config.flags2 & (CFG2phauto | CFG2phautoy) && + !(pstate.STflags & (PFLhxwrote | PFLhxdone))) + ) + + synerr(EM_data_in_pch,prettyident(s)); // data or code in precompiled header +} + +#endif + +#if TX86 +#if SCPP +/******************************** + * Put out code segment name record. + */ + +void outcsegname(char *csegname) +{ + obj_codeseg(csegname,0); +} +#endif +#endif + +/*********************************** + * Output function thunk. + */ + +#if SCPP + +void outthunk(symbol *sthunk,symbol *sfunc,unsigned p,tym_t thisty, + targ_size_t d,int i,targ_size_t d2) +{ + cod3_thunk(sthunk,sfunc,p,thisty,d,i,d2); + sthunk->Sfunc->Fflags &= ~Fpending; + sthunk->Sfunc->Fflags |= Foutput; /* mark it as having been output */ +} + +#endif + +/*************************** + * Write out statically allocated data. + * Input: + * s symbol to be initialized + */ + +#if TX86 + +void outdata(symbol *s) +{ +#if HTOD + return; +#endif + dt_t *dtstart,*dt; + targ_size_t datasize,a; + int seg; + targ_size_t offset; + int flags; + tym_t ty; + + symbol_debug(s); +#ifdef DEBUG + debugy && dbg_printf("outdata('%s')\n",s->Sident); +#endif + //printf("outdata('%s', ty=x%x)\n",s->Sident,s->Stype->Tty); + //symbol_print(s); + + // Data segment variables are always live on exit from a function + s->Sflags |= SFLlivexit; + + dtstart = s->Sdt; + s->Sdt = NULL; // it will be free'd +#if OMFOBJ + int tls = 0; +#endif +#if SCPP && TARGET_WINDOS + if (eecontext.EEcompile) + { s->Sfl = (s->ty() & mTYfar) ? FLfardata : FLextern; + s->Sseg = UNKNOWN; + goto Lret; // don't output any data + } +#endif + datasize = 0; + ty = s->ty(); + if (ty & mTYexport && config.wflags & WFexpdef && s->Sclass != SCstatic) + obj_export(s,0); // export data definition + for (dt = dtstart; dt; dt = dt->DTnext) + { + //printf("dt = %p, dt = %d\n",dt,dt->dt); + switch (dt->dt) + { case DT_abytes: + { // Put out the data for the string, and + // reserve a spot for a pointer to that string + datasize += size(dt->Dty); // reserve spot for pointer to string +#if ELFOBJ || MACHOBJ + dt->DTabytes += elf_data_cdata(dt->DTpbytes,dt->DTnbytes,&dt->DTseg); +#else + int stringseg; + targ_size_t foffset; + targ_size_t *poffset; +#if TARGET_SEGMENTED + if (tybasic(dt->Dty) == TYcptr) + { stringseg = cseg; + poffset = &Coffset; + } + else if (tybasic(dt->Dty) == TYfptr && + dt->DTnbytes > config.threshold) + { + stringseg = obj_fardata(s->Sident,dt->DTnbytes,&foffset); + poffset = &foffset; + } + else +#endif + { stringseg = DATA; + poffset = &Doffset; + } + dt->DTseg = stringseg; + dt->DTabytes += *poffset; + obj_bytes(stringseg,*poffset,dt->DTnbytes,dt->DTpbytes); + *poffset += dt->DTnbytes; +#endif + break; + } + case DT_ibytes: + datasize += dt->DTn; + break; + case DT_nbytes: + //printf("DT_nbytes %d\n", dt->DTnbytes); + datasize += dt->DTnbytes; + break; + case DT_symsize: +#if MARS + assert(0); +#else + dt->DTazeros = type_size(s->Stype); +#endif + goto case_azeros; + case DT_azeros: + /* A block of zeros + */ + //printf("DT_azeros %d\n", dt->DTazeros); + case_azeros: + datasize += dt->DTazeros; + if (dt == dtstart && !dt->DTnext && s->Sclass != SCcomdat) + { /* first and only, so put in BSS segment + */ + switch (ty & mTYLINK) + { +#if TARGET_SEGMENTED + case mTYfar: // if far data + s->Sseg = obj_fardata(s->Sident,datasize,&s->Soffset); + s->Sfl = FLfardata; + break; + + case mTYcs: + s->Sseg = cseg; + Coffset = align(datasize,Coffset); + s->Soffset = Coffset; + Coffset += datasize; + s->Sfl = FLcsdata; + break; +#endif + case mTYthread: + { seg_data *pseg = obj_tlsseg_bss(); + s->Sseg = pseg->SDseg; +#if ELFOBJ || MACHOBJ + elf_data_start(s, datasize, pseg->SDseg); + obj_lidata(pseg->SDseg, pseg->SDoffset, datasize); +#else + targ_size_t TDoffset = pseg->SDoffset; + TDoffset = align(datasize,TDoffset); + s->Soffset = TDoffset; + TDoffset += datasize; + pseg->SDoffset = TDoffset; + tls = 1; +#endif + s->Sfl = FLtlsdata; + break; + } + default: +#if OMFOBJ + s->Sseg = UDATA; +#endif + elf_data_start(s,datasize,UDATA); + obj_lidata(s->Sseg,s->Soffset,datasize); + s->Sfl = FLudata; // uninitialized data + break; + } +#if ELFOBJ || MACHOBJ + assert(s->Sseg != UNKNOWN); + if (s->Sclass == SCglobal || s->Sclass == SCstatic) // if a pubdef to be done + objpubdefsize(s->Sseg,s,s->Soffset,datasize); // do the definition +#else + if (s->Sclass == SCglobal) /* if a pubdef to be done */ + objpubdef(s->Sseg,s,s->Soffset); /* do the definition */ +#endif + searchfixlist(s); + if (config.fulltypes && + !(s->Sclass == SCstatic && funcsym_p)) // not local static + cv_outsym(s); +#if SCPP + out_extdef(s); +#endif + goto Lret; + } + break; + case DT_common: + assert(!dt->DTnext); + outcommon(s,dt->DTazeros); + goto Lret; + + case DT_xoff: + { symbol *sb = dt->DTsym; + + if (tyfunc(sb->ty())) +#if SCPP + nwc_mustwrite(sb); +#else + ; +#endif + else if (sb->Sdt) // if initializer for symbol + outdata(sb); // write out data for symbol + } + case DT_coff: + datasize += size(dt->Dty); + break; + case DT_1byte: + datasize++; + break; + default: +#ifdef DEBUG + dbg_printf("dt = %p, dt = %d\n",dt,dt->dt); +#endif + assert(0); + } + } + + if (s->Sclass == SCcomdat) // if initialized common block + { +#if ELFOBJ + seg = obj_comdatsize(s, datasize); +#else + seg = obj_comdat(s); +#endif +#if ELFOBJ || OMFOBJ + s->Soffset = 0; +#endif + switch (ty & mTYLINK) + { +#if TARGET_SEGMENTED + case mTYfar: // if far data + s->Sfl = FLfardata; + break; + + case mTYcs: + s->Sfl = FLcsdata; + break; +#endif + case mTYnear: + case 0: + s->Sfl = FLdata; // initialized data + break; + case mTYthread: + s->Sfl = FLtlsdata; +#if OMFOBJ + tls = 1; +#endif + break; + + default: + assert(0); + } + } + else + { + switch (ty & mTYLINK) + { +#if TARGET_SEGMENTED + case mTYfar: // if far data + seg = obj_fardata(s->Sident,datasize,&s->Soffset); + s->Sfl = FLfardata; + break; + + case mTYcs: + assert(OMFOBJ); + seg = cseg; + Coffset = align(datasize,Coffset); + s->Soffset = Coffset; + s->Sfl = FLcsdata; + break; +#endif + case mTYthread: + { seg_data *pseg = obj_tlsseg(); +#if ELFOBJ || MACHOBJ + s->Sseg = pseg->SDseg; + elf_data_start(s, datasize, s->Sseg); +// s->Soffset = pseg->SDoffset; +#else + targ_size_t TDoffset = pseg->SDoffset; + TDoffset = align(datasize,TDoffset); + s->Soffset = TDoffset; + tls = 1; +#endif + seg = pseg->SDseg; + s->Sfl = FLtlsdata; + break; + } + case mTYnear: + case 0: +#if ELFOBJ || MACHOBJ + seg = elf_data_start(s,datasize,DATA); +#else + seg = DATA; + alignOffset(DATA, datasize); + s->Soffset = Doffset; +#endif + s->Sfl = FLdata; // initialized data + break; + default: + assert(0); + } + } +#if ELFOBJ || MACHOBJ + if (s->Sseg == UNKNOWN) + s->Sseg = seg; + else + seg = s->Sseg; + if (s->Sclass == SCglobal || s->Sclass == SCstatic) + { + objpubdefsize(s->Sseg,s,s->Soffset,datasize); // do the definition + } +#else + s->Sseg = seg; + if (s->Sclass == SCglobal) /* if a pubdef to be done */ + objpubdef(seg,s,s->Soffset); /* do the definition */ +#endif + assert(s->Sseg != UNKNOWN); + if (config.fulltypes && + !(s->Sclass == SCstatic && funcsym_p)) // not local static + cv_outsym(s); + searchfixlist(s); + + /* Go back through list, now that we know its size, and send out */ + /* the data. */ + + offset = s->Soffset; + + for (dt = dtstart; dt; dt = dt->DTnext) + { + switch (dt->dt) + { case DT_abytes: + if (tyreg(dt->Dty)) + flags = CFoff; + else + flags = CFoff | CFseg; + if (I64) + flags |= CFoffset64; +#if TARGET_SEGMENTED + if (tybasic(dt->Dty) == TYcptr) + reftocodseg(seg,offset,dt->DTabytes); + else +#endif +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + reftodatseg(seg,offset,dt->DTabytes,dt->DTseg,flags); +#else + /*else*/ if (dt->DTseg == DATA) + reftodatseg(seg,offset,dt->DTabytes,DATA,flags); + else + reftofarseg(seg,offset,dt->DTabytes,dt->DTseg,flags); +#endif + offset += size(dt->Dty); + break; + case DT_ibytes: + obj_bytes(seg,offset,dt->DTn,dt->DTdata); + offset += dt->DTn; + break; + case DT_nbytes: + obj_bytes(seg,offset,dt->DTnbytes,dt->DTpbytes); + offset += dt->DTnbytes; + break; + case DT_azeros: + //printf("obj_lidata(seg = %d, offset = %d, azeros = %d)\n", seg, offset, dt->DTazeros); + if (0 && seg == cseg) + { + obj_lidata(seg,offset,dt->DTazeros); + offset += dt->DTazeros; + } + else + { + SegData[seg]->SDoffset = offset; + obj_lidata(seg,offset,dt->DTazeros); + offset = SegData[seg]->SDoffset; + } + break; + case DT_xoff: + { + symbol *sb = dt->DTsym; // get external symbol pointer + a = dt->DToffset; // offset from it + if (tyreg(dt->Dty)) + flags = CFoff; + else + flags = CFoff | CFseg; + if (I64) + flags |= CFoffset64; + offset += reftoident(seg,offset,sb,a,flags); + break; + } + case DT_coff: + reftocodseg(seg,offset,dt->DToffset); + offset += intsize; + break; + case DT_1byte: + obj_byte(seg,offset++,dt->DTonebyte); + break; + default: +#ifdef DEBUG + dbg_printf("dt = %p, dt = %d\n",dt,dt->dt); +#endif + assert(0); + } + } + Offset(seg) = offset; +#if SCPP + out_extdef(s); +#endif +Lret: + dt_free(dtstart); +} + + + +/****************************** + * Output n bytes of a common block, n > 0. + */ + +void outcommon(symbol *s,targ_size_t n) +{ + //printf("outcommon('%s',%d)\n",s->Sident,n); + if (n != 0) + { + assert(s->Sclass == SCglobal); +#if TARGET_SEGMENTED + if (s->ty() & mTYcs) // if store in code segment + { + /* COMDEFs not supported in code segment + * so put them out as initialized 0s + */ + dtnzeros(&s->Sdt,n); + outdata(s); +#if SCPP + out_extdef(s); +#endif + } + else +#endif + if (s->ty() & mTYthread) // if store in thread local segment + { +#if ELFOBJ + s->Sclass = SCcomdef; + obj_comdef(s, 0, n, 1); +#else + /* COMDEFs not supported in tls segment + * so put them out as COMDATs with initialized 0s + */ + s->Sclass = SCcomdat; + dtnzeros(&s->Sdt,n); + outdata(s); +#if SCPP && OMFOBJ + out_extdef(s); +#endif +#endif + } + else + { +#if ELFOBJ || MACHOBJ + s->Sclass = SCcomdef; + obj_comdef(s, 0, n, 1); +#else + s->Sclass = SCcomdef; +#if TARGET_SEGMENTED + s->Sxtrnnum = obj_comdef(s,(s->ty() & mTYfar) == 0,n,1); +#else + s->Sxtrnnum = obj_comdef(s,true,n,1); +#endif + s->Sseg = UNKNOWN; +#if TARGET_SEGMENTED + if (s->ty() & mTYfar) + s->Sfl = FLfardata; + else +#endif + s->Sfl = FLextern; + pstate.STflags |= PFLcomdef; +#if SCPP + ph_comdef(s); // notify PH that a COMDEF went out +#endif +#endif + } + if (config.fulltypes) + cv_outsym(s); + } +} +#endif // TX86 + +/****************************** + * Walk expression tree, converting it from a PARSER tree to + * a code generator tree. + */ + +STATIC void outelem(elem *e) +{ + symbol *s; + tym_t tym; + elem *e1; +#if SCPP + type *t; +#endif + +again: + assert(e); + elem_debug(e); + +#ifdef DEBUG + if (EBIN(e)) + assert(e->E1 && e->E2); +// else if (EUNA(e)) +// assert(e->E1 && !e->E2); +#endif + +#if SCPP + t = e->ET; + assert(t); + type_debug(t); + tym = t->Tty; + switch (tybasic(tym)) + { case TYstruct: + t->Tcount++; + break; + + case TYarray: + t->Tcount++; + break; + + case TYbool: + case TYwchar_t: + case TYchar16: + case TYmemptr: + case TYvtshape: + case TYnullptr: + tym = tym_conv(t); + e->ET = NULL; + break; + + case TYenum: + tym = tym_conv(t->Tnext); + e->ET = NULL; + break; + + default: + e->ET = NULL; + break; + } + e->Nflags = 0; + e->Ety = tym; +#endif + + switch (e->Eoper) + { + default: + Lop: +#if DEBUG + //if (!EOP(e)) dbg_printf("e->Eoper = x%x\n",e->Eoper); +#endif + if (EBIN(e)) + { outelem(e->E1); + e = e->E2; + } + else if (EUNA(e)) + { + e = e->E1; + } + else + break; +#if SCPP + type_free(t); +#endif + goto again; /* iterate instead of recurse */ + case OPaddr: + e1 = e->E1; + if (e1->Eoper == OPvar) + { // Fold into an OPrelconst +#if SCPP + el_copy(e,e1); + e->ET = t; +#else + tym = e->Ety; + el_copy(e,e1); + e->Ety = tym; +#endif + e->Eoper = OPrelconst; + el_free(e1); + goto again; + } + goto Lop; + + case OPrelconst: + case OPvar: + L6: + s = e->EV.sp.Vsym; + assert(s); + symbol_debug(s); + switch (s->Sclass) + { + case SCregpar: + case SCparameter: + if (e->Eoper == OPrelconst) + addrparam = TRUE; // taking addr of param list + break; + + case SCstatic: + case SClocstat: + case SCextern: + case SCglobal: + case SCcomdat: + case SCcomdef: +#if PSEUDO_REGS + case SCpseudo: +#endif + case SCinline: + case SCsinline: + case SCeinline: + s->Sflags |= SFLlivexit; + /* FALL-THROUGH */ + case SCauto: + case SCregister: + case SCfastpar: + case SCbprel: + case SCtmp: + if (e->Eoper == OPrelconst) + { + s->Sflags &= ~(SFLunambig | GTregcand); + } +#if SCPP && TX86 && OMFOBJ + else if (s->ty() & mTYfar) + e->Ety |= mTYfar; +#endif + break; +#if SCPP + case SCmember: + err_noinstance(s->Sscope,s); + goto L5; + case SCstruct: + cpperr(EM_no_instance,s->Sident); // no instance of class + L5: + e->Eoper = OPconst; + e->Ety = TYint; + return; + + case SCfuncalias: + e->EV.sp.Vsym = s->Sfunc->Falias; + goto L6; + case SCstack: + break; + case SCfunctempl: + cpperr(EM_no_template_instance, s->Sident); + break; + default: +#ifdef DEBUG + symbol_print(s); + WRclass((enum SC) s->Sclass); +#endif + assert(0); +#endif + } +#if SCPP + if (tyfunc(s->ty())) + { +#if SCPP + nwc_mustwrite(s); /* must write out function */ +#else + ; +#endif + } + else if (s->Sdt) /* if initializer for symbol */ + outdata(s); // write out data for symbol +#if ELFOBJ || MACHOBJ + if (config.flags3 & CFG3pic) + { + elfobj_gotref(s); + } +#endif +#endif + break; + case OPstring: + case OPconst: + case OPstrthis: + break; + case OPsizeof: +#if SCPP + e->Eoper = OPconst; + e->EV.Vlong = type_size(e->EV.sp.Vsym->Stype); +#else + assert(0); +#endif + break; + +#if SCPP + case OPstreq: + case OPstrpar: + case OPstrctor: + type_size(e->E1->ET); + goto Lop; + + case OPasm: + break; + + case OPctor: + nwc_mustwrite(e->EV.eop.Edtor); + case OPdtor: + // Don't put 'this' pointers in registers if we need + // them for EH stack cleanup. + e1 = e->E1; + elem_debug(e1); + if (e1->Eoper == OPadd) + e1 = e1->E1; + if (e1->Eoper == OPvar) + e1->EV.sp.Vsym->Sflags &= ~GTregcand; + goto Lop; + case OPmark: + break; +#endif + } +#if SCPP + type_free(t); +#endif +} + +/************************************* + * Determine register candidates. + */ + +STATIC void out_regcand_walk(elem *e); + +void out_regcand(symtab_t *psymtab) +{ + block *b; + SYMIDX si; + int ifunc; + + //printf("out_regcand()\n"); + ifunc = (tybasic(funcsym_p->ty()) == TYifunc); + for (si = 0; si < psymtab->top; si++) + { symbol *s = psymtab->tab[si]; + + symbol_debug(s); + //assert(sytab[s->Sclass] & SCSS); // only stack variables + s->Ssymnum = si; // Ssymnum trashed by cpp_inlineexpand + if (!(s->ty() & mTYvolatile) && +#if TX86 + !(ifunc && (s->Sclass == SCparameter || s->Sclass == SCregpar)) && +#endif + s->Sclass != SCstatic) + s->Sflags |= (GTregcand | SFLunambig); // assume register candidate + else + s->Sflags &= ~(GTregcand | SFLunambig); + } + + addrparam = FALSE; // haven't taken addr of param yet + for (b = startblock; b; b = b->Bnext) + { + if (b->Belem) + out_regcand_walk(b->Belem); + + // Any assembler blocks make everything ambiguous + if (b->BC == BCasm) + for (si = 0; si < psymtab->top; si++) + psymtab->tab[si]->Sflags &= ~(SFLunambig | GTregcand); + } + + // If we took the address of one parameter, assume we took the + // address of all non-register parameters. + if (addrparam) // if took address of a parameter + { + for (si = 0; si < psymtab->top; si++) + if (psymtab->tab[si]->Sclass == SCparameter) + psymtab->tab[si]->Sflags &= ~(SFLunambig | GTregcand); + } + +} + +STATIC void out_regcand_walk(elem *e) +{ symbol *s; + + while (1) + { elem_debug(e); + + if (EBIN(e)) + { if (e->Eoper == OPstreq) + { if (e->E1->Eoper == OPvar) + { s = e->E1->EV.sp.Vsym; + s->Sflags &= ~(SFLunambig | GTregcand); + } + if (e->E2->Eoper == OPvar) + { s = e->E2->EV.sp.Vsym; + s->Sflags &= ~(SFLunambig | GTregcand); + } + } + out_regcand_walk(e->E1); + e = e->E2; + } + else if (EUNA(e)) + { + // Don't put 'this' pointers in registers if we need + // them for EH stack cleanup. + if (e->Eoper == OPctor) + { elem *e1 = e->E1; + + if (e1->Eoper == OPadd) + e1 = e1->E1; + if (e1->Eoper == OPvar) + e1->EV.sp.Vsym->Sflags &= ~GTregcand; + } + e = e->E1; + } + else + { if (e->Eoper == OPrelconst) + { + s = e->EV.sp.Vsym; + assert(s); + symbol_debug(s); + switch (s->Sclass) + { + case SCregpar: + case SCparameter: + addrparam = TRUE; // taking addr of param list + break; + case SCauto: + case SCregister: + case SCtmp: + case SCfastpar: + case SCbprel: + s->Sflags &= ~(SFLunambig | GTregcand); + break; + } + } + else if (e->Eoper == OPvar) + { + if (e->EV.sp.Voffset) + { if (!(e->EV.sp.Voffset == 1 && tybyte(e->Ety))) + e->EV.sp.Vsym->Sflags &= ~GTregcand; + } + } + break; + } + } +} + +/************************** + * Optimize function, + * generate code for it, + * and write it out. + */ + +STATIC void writefunc2(symbol *sfunc); + +void writefunc(symbol *sfunc) +{ +#if HTOD + return; +#elif SCPP + writefunc2(sfunc); +#else + cstate.CSpsymtab = &globsym; + writefunc2(sfunc); + cstate.CSpsymtab = NULL; +#endif +} + +STATIC void writefunc2(symbol *sfunc) +{ + block *b; + unsigned nsymbols; + SYMIDX si; + int anyasm; +#if OMFOBJ + int csegsave; + targ_size_t coffsetsave; +#endif + func_t *f = sfunc->Sfunc; + tym_t tyf; + + //printf("writefunc(%s)\n",sfunc->Sident); + debug(debugy && dbg_printf("writefunc(%s)\n",sfunc->Sident)); +#if SCPP + if (CPP) + { + + // If constructor or destructor, make sure it has been fixed. + if (f->Fflags & (Fctor | Fdtor)) + assert(errcnt || f->Fflags & Ffixed); + + // If this function is the 'trigger' to output the vtbl[], do so + if (f->Fflags3 & Fvtblgen && !eecontext.EEcompile) + { Classsym *stag; + + stag = (Classsym *) sfunc->Sscope; + { + enum SC scvtbl; + + scvtbl = (enum SC) ((config.flags2 & CFG2comdat) ? SCcomdat : SCglobal); + n2_genvtbl(stag,scvtbl,1); +#if VBTABLES + n2_genvbtbl(stag,scvtbl,1); +#endif +#if TX86 && OMFOBJ + if (config.fulltypes == CV4) + cv4_struct(stag,2); +#endif + } + } + } +#endif + + /* Signify that function has been output */ + /* (before inline_do() to prevent infinite recursion!) */ + f->Fflags &= ~Fpending; + f->Fflags |= Foutput; + + if ( +#if SCPP + errcnt || +#endif + (eecontext.EEcompile && eecontext.EEfunc != sfunc)) + return; + + /* Copy local symbol table onto main one, making sure */ + /* that the symbol numbers are adjusted accordingly */ + //dbg_printf("f->Flocsym.top = %d\n",f->Flocsym.top); + nsymbols = f->Flocsym.top; + if (nsymbols > globsym.symmax) + { /* Reallocate globsym.tab[] */ + globsym.symmax = nsymbols; + globsym.tab = symtab_realloc(globsym.tab, globsym.symmax); + } + debug(debugy && dbg_printf("appending symbols to symtab...\n")); + assert(globsym.top == 0); + memcpy(&globsym.tab[0],&f->Flocsym.tab[0],nsymbols * sizeof(symbol *)); + globsym.top = nsymbols; + + assert(startblock == NULL); + if (f->Fflags & Finline) // if keep function around + { // Generate copy of function + block *bf; + block **pb; + + pb = &startblock; + for (bf = f->Fstartblock; bf; bf = bf->Bnext) + { + b = block_calloc(); + *pb = b; + pb = &b->Bnext; + + *b = *bf; + assert(!b->Bsucc); + assert(!b->Bpred); + b->Belem = el_copytree(b->Belem); + } + } + else + { startblock = sfunc->Sfunc->Fstartblock; + sfunc->Sfunc->Fstartblock = NULL; + } + assert(startblock); + + /* Do any in-line expansion of function calls inside sfunc */ +#if SCPP + inline_do(sfunc); +#endif + +#if SCPP + /* If function is _STIxxxx, add in the auto destructors */ +#if NEWSTATICDTOR + if (cpp_stidtors && memcmp("__SI",sfunc->Sident,4) == 0) +#else + if (cpp_stidtors && memcmp("_STI",sfunc->Sident,4) == 0) +#endif + { list_t el; + + assert(startblock->Bnext == NULL); + el = cpp_stidtors; + do + { + startblock->Belem = el_combine(startblock->Belem,list_elem(el)); + el = list_next(el); + } while (el); + list_free(&cpp_stidtors,FPNULL); + } +#endif + assert(funcsym_p == NULL); + funcsym_p = sfunc; + tyf = tybasic(sfunc->ty()); + +#if SCPP + out_extdef(sfunc); +#endif + + // TX86 computes parameter offsets in stackoffsets() + //printf("globsym.top = %d\n", globsym.top); + for (si = 0; si < globsym.top; si++) + { symbol *s = globsym.tab[si]; + + symbol_debug(s); + //printf("symbol %d '%s'\n",si,s->Sident); + + type_size(s->Stype); // do any forward template instantiations + + s->Ssymnum = si; // Ssymnum trashed by cpp_inlineexpand + s->Sflags &= ~(SFLunambig | GTregcand); + switch (s->Sclass) + { +#if SCPP + case SCfastpar: + Lfp: + s->Spreg = (tyf == TYmfunc) ? CX : AX; + case SCauto: + case SCregister: + s->Sfl = FLauto; + goto L3; + case SCtmp: + s->Sfl = FLtmp; + goto L3; + case SCbprel: + s->Sfl = FLbprel; + goto L3; + case SCregpar: + case SCparameter: + if (tyf == TYjfunc && si == 0 && + type_jparam(s->Stype)) + { s->Sclass = SCfastpar; // put last parameter into register + goto Lfp; + } +#else + case SCfastpar: + case SCauto: + case SCregister: + s->Sfl = FLauto; + goto L3; + case SCtmp: + s->Sfl = FLtmp; + goto L3; + case SCbprel: + s->Sfl = FLbprel; + goto L3; + case SCregpar: + case SCparameter: +#endif + s->Sfl = FLpara; + if (tyf == TYifunc) + { s->Sflags |= SFLlivexit; + break; + } + L3: + if (!(s->ty() & mTYvolatile)) + s->Sflags |= GTregcand | SFLunambig; // assume register candidate */ + break; +#if PSEUDO_REGS + case SCpseudo: + s->Sfl = FLpseudo; + break; +#endif + case SCstatic: + break; // already taken care of by datadef() + case SCstack: + s->Sfl = FLstack; + break; + default: +#ifdef DEBUG + symbol_print(s); +#endif + assert(0); + } + } + + addrparam = FALSE; // haven't taken addr of param yet + anyasm = 0; + numblks = 0; + for (b = startblock; b; b = b->Bnext) + { + numblks++; // redo count + memset(&b->_BLU,0,sizeof(b->_BLU)); + if (b->Belem) + { outelem(b->Belem); +#if SCPP + if (el_noreturn(b->Belem) && !(config.flags3 & CFG3eh)) + { b->BC = BCexit; + list_free(&b->Bsucc,FPNULL); + } +#endif +#if MARS + if (b->Belem->Eoper == OPhalt) + { b->BC = BCexit; + list_free(&b->Bsucc,FPNULL); + } +#endif + } + if (b->BC == BCasm) + anyasm = 1; + if (sfunc->Sflags & SFLexit && (b->BC == BCret || b->BC == BCretexp)) + { b->BC = BCexit; + list_free(&b->Bsucc,FPNULL); + } + assert(b != b->Bnext); + } + PARSER = 0; + if (eecontext.EEelem) + { unsigned marksi = globsym.top; + + eecontext.EEin++; + outelem(eecontext.EEelem); + eecontext.EEelem = doptelem(eecontext.EEelem,TRUE); + eecontext.EEin--; + eecontext_convs(marksi); + } + maxblks = 3 * numblks; // allow for increase in # of blocks + // If we took the address of one parameter, assume we took the + // address of all non-register parameters. + if (addrparam | anyasm) // if took address of a parameter + { + for (si = 0; si < globsym.top; si++) + if (anyasm || globsym.tab[si]->Sclass == SCparameter) + globsym.tab[si]->Sflags &= ~(SFLunambig | GTregcand); + } + + block_pred(); // compute predecessors to blocks + block_compbcount(); // eliminate unreachable blocks + if (mfoptim) + { OPTIMIZER = 1; + optfunc(); /* optimize function */ + assert(dfo); + OPTIMIZER = 0; + } + else + { + //dbg_printf("blockopt()\n"); + blockopt(0); /* optimize */ + } + +#if SCPP + if (CPP) + { + // Look for any blocks that return nothing. + // Do it after optimization to eliminate any spurious + // messages like the implicit return on { while(1) { ... } } + if (tybasic(funcsym_p->Stype->Tnext->Tty) != TYvoid && + !(funcsym_p->Sfunc->Fflags & (Fctor | Fdtor | Finvariant)) +#if DEBUG_XSYMGEN + /* the internal dataview function is allowed to lie about its return value */ + && compile_state != kDataView +#endif + ) + { char err; + + err = 0; + for (b = startblock; b; b = b->Bnext) + { if (b->BC == BCasm) // no errors if any asm blocks + err |= 2; + else if (b->BC == BCret) + err |= 1; + } + if (err == 1) + func_noreturnvalue(); + } + } +#endif + assert(funcsym_p == sfunc); + if (eecontext.EEcompile != 1) + { +#if TX86 + if (symbol_iscomdat(sfunc)) + { +#if OMFOBJ + csegsave = cseg; + coffsetsave = Coffset; +#endif + obj_comdat(sfunc); + } + else + if (config.flags & CFGsegs) // if user set switch for this + { +#if SCPP || TARGET_WINDOS + obj_codeseg(cpp_mangle(funcsym_p),1); +#else + obj_codeseg(funcsym_p->Sident, 1); +#endif + // generate new code segment + } + cod3_align(); // align start of function +#if ELFOBJ || MACHOBJ + elf_func_start(sfunc); +#else + sfunc->Sseg = cseg; // current code seg +#endif +#endif + sfunc->Soffset = Coffset; // offset of start of function + searchfixlist(sfunc); // backpatch any refs to this function + } + + //dbg_printf("codgen()\n"); +#if SCPP + if (!errcnt) +#endif + codgen(); // generate code + //dbg_printf("after codgen for %s Coffset %x\n",sfunc->Sident,Coffset); + blocklist_free(&startblock); +#if SCPP + PARSER = 1; +#endif +#if ELFOBJ || MACHOBJ + elf_func_term(sfunc); +#endif +#if MARS + /* This is to make uplevel references to SCfastpar variables + * from nested functions work. + */ + for (si = 0; si < globsym.top; si++) + { + Symbol *s = globsym.tab[si]; + + switch (s->Sclass) + { case SCfastpar: + s->Sclass = SCauto; + break; + } + } +#endif + if (eecontext.EEcompile == 1) + goto Ldone; + if (sfunc->Sclass == SCglobal) + { +#if OMFOBJ + if (!(config.flags4 & CFG4allcomdat)) + objpubdef(cseg,sfunc,sfunc->Soffset); // make a public definition +#endif + +#if SCPP && _WIN32 + char *id; + // Determine which startup code to reference + if (!CPP || !isclassmember(sfunc)) // if not member function + { static char *startup[] = + { "__acrtused","__acrtused_winc","__acrtused_dll", + "__acrtused_con","__wacrtused","__wacrtused_con", + }; + int i; + + id = sfunc->Sident; + switch (id[0]) + { + case 'D': if (strcmp(id,"DllMain")) + break; + if (config.exe == EX_NT) + { i = 2; + goto L2; + } + break; + + case 'm': if (strcmp(id,"main")) + break; + if (config.exe == EX_NT) + i = 3; + else if (config.wflags & WFwindows) + i = 1; + else + i = 0; + goto L2; + + case 'w': if (strcmp(id,"wmain") == 0) + { + if (config.exe == EX_NT) + { i = 5; + goto L2; + } + break; + } + case 'W': if (stricmp(id,"WinMain") == 0) + { + i = 0; + goto L2; + } + if (stricmp(id,"wWinMain") == 0) + { + if (config.exe == EX_NT) + { i = 4; + goto L2; + } + } + break; + + case 'L': + case 'l': if (stricmp(id,"LibMain")) + break; + if (config.exe != EX_NT && config.wflags & WFwindows) + { i = 2; + goto L2; + } + break; + + L2: objextdef(startup[i]); // pull in startup code + break; + } + } +#endif + } + if (config.wflags & WFexpdef && + sfunc->Sclass != SCstatic && + sfunc->Sclass != SCsinline && + !(sfunc->Sclass == SCinline && !(config.flags2 & CFG2comdat)) && + sfunc->ty() & mTYexport) + obj_export(sfunc,Poffset); // export function definition + + if (config.fulltypes) + cv_func(sfunc); // debug info for function + +#if MARS + /* After codgen() and writing debug info for the locals, + * readjust the offsets of all stack variables so they + * are relative to the frame pointer. + * Necessary for nested function access to lexically enclosing frames. + */ + cod3_adjSymOffsets(); +#endif + +#if OMFOBJ + if (symbol_iscomdat(sfunc)) // if generated a COMDAT + obj_setcodeseg(csegsave,coffsetsave); // reset to real code seg +#endif + + /* Check if function is a constructor or destructor, by */ + /* seeing if the function name starts with _STI or _STD */ + { +#if _M_I86 + short *p; + + p = (short *) sfunc->Sident; + if (p[0] == 'S_' && (p[1] == 'IT' || p[1] == 'DT')) +#else + char *p; + + p = sfunc->Sident; + if (p[0] == '_' && p[1] == 'S' && p[2] == 'T' && + (p[3] == 'I' || p[3] == 'D')) +#endif + obj_funcptr(sfunc); + } + +Ldone: + funcsym_p = NULL; + +#if SCPP + // Free any added symbols + freesymtab(globsym.tab,nsymbols,globsym.top); +#endif + globsym.top = 0; + + //dbg_printf("done with writefunc()\n"); +#if TX86 + util_free(dfo); +#else + MEM_PARF_FREE(dfo); +#endif + dfo = NULL; +} + +/************************* + * Align segment offset. + * Input: + * seg segment to be aligned + * datasize size in bytes of object to be aligned + */ + +void alignOffset(int seg,targ_size_t datasize) +{ + targ_size_t alignbytes; + + alignbytes = align(datasize,Offset(seg)) - Offset(seg); + //dbg_printf("seg %d datasize = x%x, Offset(seg) = x%x, alignbytes = x%x\n", + //seg,datasize,Offset(seg),alignbytes); + if (alignbytes) + obj_lidata(seg,Offset(seg),alignbytes); +#if OMFOBJ + //Offset(seg) += alignbytes; /* offset of start of data */ +#endif +} + + +/*************************************** + * Write data into read-only data segment. + * Return symbol for it. + */ + +#define ROMAX 32 +struct Readonly +{ + symbol *sym; + size_t length; + unsigned char p[ROMAX]; +}; + +#define RMAX 16 +static Readonly readonly[RMAX]; +static size_t readonly_length; +static size_t readonly_i; + +void out_reset() +{ + readonly_length = 0; + readonly_i = 0; +} + +symbol *out_readonly_sym(tym_t ty, void *p, int len) +{ +#if 0 + printf("out_readonly_sym(ty = x%x)\n", ty); + for (int i = 0; i < len; i++) + printf(" [%d] = %02x\n", i, ((unsigned char*)p)[i]); +#endif + // Look for previous symbol we can reuse + for (int i = 0; i < readonly_length; i++) + { + Readonly *r = &readonly[i]; + if (r->length == len && memcmp(p, r->p, len) == 0) + return r->sym; + } + + symbol *s; + +#if ELFOBJ + /* MACHOBJ can't go here, because the const data segment goes into + * the _TEXT segment, and one cannot have a fixup from _TEXT to _TEXT. + */ + s = elf_sym_cdata(ty, (char *)p, len); +#else + unsigned sz = tysize(ty); + + alignOffset(DATA, sz); + s = symboldata(Doffset,ty | mTYconst); + obj_write_bytes(SegData[DATA], len, p); + //printf("s->Sseg = %d:x%x\n", s->Sseg, s->Soffset); +#endif + if (len <= ROMAX) + { Readonly *r; + + if (readonly_length < RMAX) + { + r = &readonly[readonly_length]; + readonly_length++; + } + else + { r = &readonly[readonly_i]; + readonly_i++; + if (readonly_i >= RMAX) + readonly_i = 0; + } + r->length = len; + r->sym = s; + memcpy(r->p, p, len); + } + return s; +} + +void Srcpos::print(const char *func) +{ + printf("%s(", func); +#if MARS + printf("Sfilename = %s", Sfilename ? Sfilename : "null"); +#else + Sfile *sf = Sfilptr ? *Sfilptr : NULL; + printf("Sfilptr = %p (filename = %s)", sf, sf ? sf->SFname : "null"); +#endif + printf(", Slinnum = %u", Slinnum); +#if SOURCE_OFFSETS + printf(", Sfiloff = %d", Sfiloff); +#endif + printf(")\n"); +} + + +#endif /* !SPP */ + diff --git a/backend/outbuf.c b/backend/outbuf.c new file mode 100644 index 00000000..a11e259e --- /dev/null +++ b/backend/outbuf.c @@ -0,0 +1,298 @@ +// Copyright (C) 1994-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Output buffer + +#include +#include +#include +#include + +#include "cc.h" + +#include "outbuf.h" +#include "mem.h" + +#if DEBUG +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" +#endif + +Outbuffer::Outbuffer() +{ + buf = NULL; + pend = NULL; + p = NULL; + len = 0; + inc = 0; +} + +Outbuffer::Outbuffer(unsigned bufinc) +{ + buf = NULL; + pend = NULL; + p = NULL; + len = 0; + inc = bufinc; +} + +Outbuffer::~Outbuffer() +{ +#if MEM_DEBUG + mem_free(buf); +#else + if (buf) + free(buf); +#endif +} + +void Outbuffer::reset() +{ + p = buf; +} + +// Reserve nbytes in buffer +void Outbuffer::reserve(unsigned nbytes) +{ + if (pend - p < nbytes) + { unsigned oldlen = len; + unsigned used = p - buf; + + if (inc > nbytes) + { + len = used + inc; + } + else + { + len = used + nbytes; + if (len < 2 * oldlen) + { len = 2 * oldlen; + if (len < 8) + len = 8; + } + } +#if MEM_DEBUG + buf = (unsigned char *)mem_realloc(buf, len); +#else + if (buf) + buf = (unsigned char *) realloc(buf,len); + else + buf = (unsigned char *) malloc(len); +#endif + if (!buf) + { + fprintf(stderr, "Fatal Error: Out of memory"); + exit(EXIT_FAILURE); + } + + pend = buf + len; + p = buf + used; + } +} + +// Position buffer for output at a specified location and size. +// If data will extend buffer size, reserve space +// If data will rewrite existing data +// position for write and return previous buffer size +// +// If data will append to buffer +// position for write and return new size +int Outbuffer::position(unsigned pos, unsigned nbytes) +{ + int current_sz = size(); + unsigned char *fend = buf+pos+nbytes; // future end of buffer + if (fend >= pend) + { + reserve (fend - pend); + } + setsize(pos); + return pos+nbytes > current_sz ? pos+nbytes : current_sz; +} + +// Write an array to the buffer. +void Outbuffer::write(const void *b, int len) +{ + if (pend - p < len) + reserve(len); + memcpy(p,b,len); + p += len; +} + +// Write n zeros to the buffer. +void *Outbuffer::writezeros(unsigned len) +{ + if (pend - p < len) + reserve(len); + void *pstart = memset(p,0,len); + p += len; + return pstart; +} + +/** + * Writes an 8 bit byte. + */ +void Outbuffer::writeByte(int v) +{ + if (pend == p) + reserve(1); + *p++ = v; +} + +/** + * Writes a 32 bit int. + */ +void Outbuffer::write32(int v) +{ + if (pend - p < 4) + reserve(4); + *(int *)p = v; + p += 4; +} + +/** + * Writes a 64 bit long. + */ + +#if __INTSIZE == 4 +void Outbuffer::write64(long long v) +{ + if (pend - p < 8) + reserve(8); + *(long long *)p = v; + p += 8; +} +#endif + +/** + * Writes a 32 bit float. + */ +void Outbuffer::writeFloat(float v) +{ + if (pend - p < sizeof(float)) + reserve(sizeof(float)); + *(float *)p = v; + p += sizeof(float); +} + +/** + * Writes a 64 bit double. + */ +void Outbuffer::writeDouble(double v) +{ + if (pend - p < sizeof(double)) + reserve(sizeof(double)); + *(double *)p = v; + p += sizeof(double); +} + +/** + * Writes a String as a sequence of bytes. + */ +void Outbuffer::write(const char *s) +{ + write(s,strlen(s)); +} + + +/** + * Writes a String as a sequence of bytes. + */ +void Outbuffer::write(const unsigned char *s) +{ + write(s,strlen((const char *)s)); +} + + +/** + * Writes a NULL terminated String + */ +void Outbuffer::writeString(const char *s) +{ + write(s,strlen(s)+1); +} + +/** + * Inserts string at beginning of buffer. + */ + +void Outbuffer::prependBytes(const char *s) +{ + size_t len = strlen(s); + + reserve(len); + memmove(buf + len,buf,p - buf); + memcpy(buf,s,len); + p += len; +} + +/** + */ + +void Outbuffer::bracket(char c1,char c2) +{ + reserve(2); + memmove(buf + 1,buf,p - buf); + buf[0] = c1; + p[1] = c2; + p += 2; +} + +/** + * Convert to a string. + */ + +char *Outbuffer::toString() +{ + if (pend == p) + reserve(1); + *p = 0; // terminate string + return (char *)buf; +} + +/** + * Set current size of buffer. + */ + +void Outbuffer::setsize(unsigned size) +{ + p = buf + size; +} + +void Outbuffer::writesLEB128(int value) +{ + while (1) + { + unsigned char b = value & 0x7F; + + value >>= 7; // arithmetic right shift + if (value == 0 && !(b & 0x40) || + value == -1 && (b & 0x40)) + { + writeByte(b); + break; + } + writeByte(b | 0x80); + } +} + +void Outbuffer::writeuLEB128(unsigned value) +{ + do + { unsigned char b = value & 0x7F; + + value >>= 7; + if (value) + b |= 0x80; + writeByte(b); + } while (value); +} + diff --git a/backend/outbuf.h b/backend/outbuf.h new file mode 100644 index 00000000..ebf2d16b --- /dev/null +++ b/backend/outbuf.h @@ -0,0 +1,179 @@ +// Copyright (C) 1994-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +//#pragma once + +#include + +// Output buffer + +// (This used to be called OutBuffer, we renamed it to avoid name conflicts with Mars.) + +struct Outbuffer +{ + unsigned char *buf; // the buffer itself + unsigned char *pend; // pointer past the end of the buffer + unsigned char *p; // current position in buffer + unsigned len; // size of buffer + unsigned inc; // default increment size + + Outbuffer(); + Outbuffer(unsigned inc); + ~Outbuffer(); + void reset(); + + // Reserve nbytes in buffer + void reserve(unsigned nbytes); + + // Write n zeros; return pointer to start of zeros + void *writezeros(unsigned n); + + // Position buffer to accept the specified number of bytes at offset + int position(unsigned offset, unsigned nbytes); + + // Write an array to the buffer, no reserve check + void writen(const void *b, int len) + { + memcpy(p,b,len); + p += len; + } + + // Clear bytes, no reserve check + void clearn(int len) + { + int i; + for (i=0; i< len; i++) + *p++ = 0; + } + + // Write an array to the buffer. + void write(const void *b, int len); + + void write(Outbuffer *b) { write(b->buf,b->p - b->buf); } + + /** + * Flushes the stream. This will write any buffered + * output bytes. + */ + void flush() { } + + /** + * Writes an 8 bit byte, no reserve check. + */ + void writeByten(char v) + { + *p++ = v; + } + + /** + * Writes an 8 bit byte. + */ + void writeByte(int v); + + /** + * Writes a 16 bit little-end short, no reserve check. + */ + void writeWordn(int v) + { +#if _WIN32 + *(unsigned short *)p = v; +#else + p[0] = v; + p[1] = v >> 8; +#endif + p += 2; + } + + + /** + * Writes a 16 bit little-end short. + */ + void writeWord(int v) + { + reserve(2); + writeWordn(v); + } + + + /** + * Writes a 16 bit big-end short. + */ + void writeShort(int v) + { + if (pend - p < 2) + reserve(2); +#if 0 + p[0] = ((unsigned char *)&v)[1]; + p[1] = v; +#else + unsigned char *q = p; + q[0] = v >> 8; + q[1] = v; +#endif + p += 2; + } + + /** + * Writes a 16 bit char. + */ + void writeChar(int v) + { + writeShort(v); + } + + /** + * Writes a 32 bit int. + */ + void write32(int v); + + /** + * Writes a 64 bit long. + */ +#if __INTSIZE == 4 + void write64(long long v); +#endif + + /** + * Writes a 32 bit float. + */ + void writeFloat(float v); + + /** + * Writes a 64 bit double. + */ + void writeDouble(double v); + + void write(const char *s); + + void write(const unsigned char *s); + + void writeString(const char *s); + + void prependBytes(const char *s); + + void bracket(char c1,char c2); + + /** + * Returns the number of bytes written. + */ + int size() + { + return p - buf; + } + + char *toString(); + void setsize(unsigned size); + + void writesLEB128(int value); + void writeuLEB128(unsigned value); + +}; diff --git a/backend/ptrntab.c b/backend/ptrntab.c new file mode 100644 index 00000000..99b6c9df --- /dev/null +++ b/backend/ptrntab.c @@ -0,0 +1,5736 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2012 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !DEMO && !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "code.h" +#include "iasm.h" +#include "global.h" +#include "xmm.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +// +// NOTE: For 0 operand instructions, the opcode is taken from +// the first entry and no subsequent entries are required. +// for instructions with operands, a NULL entry is required at the end +// as a terminator +// +// 0 Operand instructions +// + +#define OPTABLE0(str,op,mod) PTRNTAB0 aptb0##str[] = { { op, mod }, }; + +OPTABLE0(AAA, 0x37 ,_i64_bit | _modax); +OPTABLE0(AAD, 0xd50a,_i64_bit | _modax); +OPTABLE0(AAM, 0xd40a,_i64_bit | _modax); +OPTABLE0(AAS, 0x3f, _i64_bit | _modax); +OPTABLE0(CBW, 0x98,_16_bit | _modax); +OPTABLE0(CWDE, 0x98,_32_bit | _I386 | _modax); +OPTABLE0(CDQE, 0x98,_64_bit | _modax); +OPTABLE0(CLC, 0xf8,0); +OPTABLE0(CLD, 0xfc,0); +OPTABLE0(CLI, 0xfa,0); +OPTABLE0(CLTS, 0x0f06,0); +OPTABLE0(CMC, 0xf5,0); +OPTABLE0(CMPSB, 0xa6,_modsidi); +OPTABLE0(CMPSW, 0xa7,_16_bit | _modsidi); +//OPTABLE0(CMPSD, 0xa7,_32_bit | _I386 | _modsidi); +OPTABLE0(CMPSQ, 0xa7,_64_bit | _modsidi); +OPTABLE0(CWD, 0x99, _16_bit | _modaxdx); +OPTABLE0(CDQ, 0x99,_32_bit | _I386 | _modaxdx); +OPTABLE0(CQO, 0x99, _64_bit | _modaxdx); +OPTABLE0(DAA, 0x27,_i64_bit | _modax ); +OPTABLE0(DAS, 0x2f,_i64_bit | _modax ); +OPTABLE0(HLT, 0xf4,0); +OPTABLE0(INSB, 0x6c,_I386 | _modsi); +OPTABLE0(INSW, 0x6d,_16_bit | _I386 | _modsi); +OPTABLE0(INSD, 0x6d,_32_bit | _I386 | _modsi); +OPTABLE0(INTO, 0xce,_i64_bit); +OPTABLE0(INVD, 0x0f08,_I386); // Actually a 486 only instruction +OPTABLE0(IRET, 0xcf,_16_bit); +OPTABLE0(IRETD, 0xcf,_32_bit | _I386); +OPTABLE0(LAHF, 0x9f,_modax); +OPTABLE0(LEAVE, 0xc9,_I386); +OPTABLE0(LOCK, 0xf0,0); +OPTABLE0(LODSB, 0xac,_modsiax); +OPTABLE0(LODSW, 0xad,_16_bit | _modsiax); +OPTABLE0(LODSD, 0xad,_32_bit | _I386 | _modsiax); +OPTABLE0(LODSQ, 0xad,_64_bit | _modsiax); +OPTABLE0(MOVSB, 0xa4, _modsidi); +OPTABLE0(MOVSW, 0xa5, _16_bit | _modsidi); +OPTABLE0(MOVSQ, 0xa5, _64_bit | _modsidi); +OPTABLE0(NOP, 0x90, 0); +OPTABLE0(OUTSB, 0x6e, _I386 | _modsi); +OPTABLE0(OUTSW, 0x6f, _16_bit | _I386 | _modsi); +OPTABLE0(OUTSD, 0x6f, _32_bit | _I386 | _modsi); +OPTABLE0(POPA, 0x61,_i64_bit | _16_bit | _I386 | _modall); +OPTABLE0(POPAD, 0x61,_i64_bit | _32_bit | _I386 | _modall); +OPTABLE0(POPF, 0x9d, _16_bit); +OPTABLE0(POPFD, 0x9d,_i64_bit | _32_bit | _I386); +OPTABLE0(POPFQ, 0x9d, _64_bit); +OPTABLE0(PUSHA, 0x60,_i64_bit | _16_bit | _I386); +OPTABLE0(PUSHAD, 0x60,_i64_bit | _32_bit | _I386); +OPTABLE0(PUSHF, 0x9c, _16_bit); +OPTABLE0(PUSHFD, 0x9c,_i64_bit | _32_bit | _I386); +OPTABLE0(PUSHFQ, 0x9c, _64_bit); // TODO REX_W override is implicit +OPTABLE0(REP, 0xf3, _modcx); +OPTABLE0(REPNE, 0xf2, _modcx); +OPTABLE0(SAHF, 0x9e, 0); +OPTABLE0(SCASB, 0xAE, _moddi); +OPTABLE0(SCASW, 0xAF, _16_bit | _moddi); +OPTABLE0(SCASD, 0xAF, _32_bit | _I386 | _moddi); +OPTABLE0(SCASQ, 0xAF, _64_bit | _moddi); +OPTABLE0(STC, 0xf9, 0); +OPTABLE0(STD, 0xfd, 0); +OPTABLE0(STI, 0xfb, 0); +OPTABLE0(STOSB, 0xaa, _moddi); +OPTABLE0(STOSW, 0xAB, _16_bit | _moddi); +OPTABLE0(STOSD, 0xAB, _32_bit | _I386 | _moddi); +OPTABLE0(STOSQ, 0xAB, _64_bit | _moddi); +OPTABLE0(WAIT, 0x9B, 0); +OPTABLE0(WBINVD, 0x0f09, _I386); // Really a 486 opcode +OPTABLE0(XLATB, 0xd7, _modax); +OPTABLE0(CPUID, 0x0fa2, _I386 | _modall); +OPTABLE0(RDMSR, 0x0f32, _I386 | _modaxdx); +OPTABLE0(RDPMC, 0x0f33, _I386 | _modaxdx); +OPTABLE0(RDTSC, 0x0f31, _I386 | _modaxdx); +OPTABLE0(WRMSR, 0x0f30, _I386); +OPTABLE0(RSM, 0x0faa,_i64_bit | _I386); + +// +// Now come the one operand instructions +// These will prove to be a little more challenging than the 0 +// operand instructions +// +PTRNTAB1 aptb1BSWAP[] = /* BSWAP */ { + // Really is a 486 only instruction + { 0x0fc8, _I386, _plus_r | _r32 }, + { 0x0fc8, _64_bit, _plus_r | _r64 }, + { ASM_END } +}; + +PTRNTAB1 aptb1CALL[] = /* CALL */ { + { 0xe8, _cw| _i64_bit | _modall, _rel16 }, + { 0xff, _2 | _i64_bit | _16_bit | _modall, _r16 }, + { 0xff, _2 | _i64_bit | _modall, _m16 }, + { 0x9a, _cd| _i64_bit | _modall, _p1616 }, + { 0xff, _3 | _modall, _m1616 }, + { 0xe8, _cd| _modall, _rel32 }, + { 0xff, _2 | _i64_bit | _32_bit | _modall, _r32 }, + { 0xff, _2 | _32_bit | _modall, _r64 }, // REX_W override is implicit + { 0xff, _2 | _i64_bit | _modall, _m32 }, + { 0xff, _2 | _64_bit | _modall, _m64 }, // TODO REX_W override is implicit + { 0x9a, _cp| _i64_bit | _modall, _p1632 }, + { 0xff, _3 | _modall, _m1632 }, + { ASM_END } +}; + +PTRNTAB1 aptb1DEC[] = /* DEC */ { + { 0xfe, _1, _rm8 }, + { 0x48, _rw | _i64_bit | _16_bit, _r16 | _plus_r }, + { 0x48, _rd | _i64_bit | _32_bit, _r32 | _plus_r }, + { 0xff, _1 | _16_bit, _rm16 }, + { 0xff, _1 | _32_bit, _rm32 }, + { 0xff, _1 | _64_bit, _rm64 }, + { ASM_END } +}; + +PTRNTAB1 aptb1INC[] = /* INC */ { + { 0xfe, _0, _rm8 }, + { 0x40, _rw | _i64_bit | _16_bit, _r16 | _plus_r }, + { 0x40, _rd | _i64_bit | _32_bit, _r32 | _plus_r }, + { 0xff, _0 | _16_bit, _rm16 }, + { 0xff, _0 | _32_bit, _rm32 }, + { 0xff, _0 | _64_bit, _rm64 }, + { ASM_END } +}; +// INT and INT 3 +PTRNTAB1 aptb1INT[]= /* INT */ { + { 0xcc, 3, 0 }, // The ulFlags here are meant to + // be the value of the immediate + // operand + { 0xcd, 0, _imm8 }, + { ASM_END } +}; +PTRNTAB1 aptb1INVLPG[] = /* INVLPG */ { // 486 only instruction + { 0x0f01, _I386|_7, _m8 | _m16 | _m32 | _m48 }, + { ASM_END } +}; + +#define OPTABLE(str,op) \ +PTRNTAB1 aptb1##str[] = { \ + { 0x70|op, _cb, _rel8 }, \ + { 0x0f80|op, _cw|_i64_bit,_rel16 }, \ + { 0x0f80|op, _cd, _rel32 }, \ + { ASM_END } \ +} + +OPTABLE(JO,0); +OPTABLE(JNO,1); +OPTABLE(JB,2); +OPTABLE(JNB,3); +OPTABLE(JZ,4); +OPTABLE(JNZ,5); +OPTABLE(JBE,6); +OPTABLE(JNBE,7); +OPTABLE(JS,8); +OPTABLE(JNS,9); +OPTABLE(JP,0xA); +OPTABLE(JNP,0xB); +OPTABLE(JL,0xC); +OPTABLE(JNL,0xD); +OPTABLE(JLE,0xE); +OPTABLE(JNLE,0xF); + +#undef OPTABLE + +PTRNTAB1 aptb1JCXZ[] = /* JCXZ */ { + { 0xe3, _cb | _i64_bit | _16_bit_addr, _rel8 }, + { ASM_END } +}; +PTRNTAB1 aptb1JECXZ[] = /* JECXZ */ { + { 0xe3, _cb | _32_bit_addr | _I386,_rel8 }, + { ASM_END } +}; +PTRNTAB1 aptb1JMP[] = /* JMP */ { + { 0xe9, _cw| _i64_bit, _rel16 }, + { 0xe9, _cd, _rel32 }, + { 0xeb, _cb, _rel8 }, + { 0xff, _4 | _i64_bit | _16_bit, _rm16 }, + { 0xea, _cd| _i64_bit, _p1616 }, + { 0xff, _5, _m1616 }, + { 0xff, _4 | _i64_bit | _32_bit, _rm32 }, + { 0xff, _4 | _64_bit, _rm64 }, // TODO REX_W override is implicit + { 0xea, _cp| _i64_bit, _p1632 }, + { 0xff, _5, _m1632 }, + { ASM_END } +}; +PTRNTAB1 aptb1LGDT[] = /* LGDT */ { + { 0x0f01, _2, _m48 }, + { ASM_END } +}; +PTRNTAB1 aptb1LIDT[] = /* LIDT */ { + { 0x0f01, _3, _m48 }, + { ASM_END } +}; +PTRNTAB1 aptb1LLDT[] = /* LLDT */ { + { 0x0f00, _2|_modnot1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1LMSW[] = /* LMSW */ { + { 0x0f01, _6|_modnot1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1LODS[] = /* LODS */ { + { 0xac, _modax,_m8 }, + { 0xad, _16_bit | _modax,_m16 }, + { 0xad, _32_bit | _I386 | _modax,_m32 }, + { ASM_END } +}; +PTRNTAB1 aptb1LOOP[] = /* LOOP */ { + { 0xe2, _cb | _modcx,_rel8 }, + { ASM_END } +}; +PTRNTAB1 aptb1LOOPE[] = /* LOOPE/LOOPZ */ { + { 0xe1, _cb | _modcx,_rel8 }, + { ASM_END } +}; +PTRNTAB1 aptb1LOOPNE[] = /* LOOPNE/LOOPNZ */ { + { 0xe0, _cb | _modcx,_rel8 }, + { ASM_END } +}; +PTRNTAB1 aptb1LTR[] = /* LTR */ { + { 0x0f00, _3|_modnot1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1NEG[] = /* NEG */ { + { 0xf6, _3, _rm8 }, + { 0xf7, _3 | _16_bit, _rm16 }, + { 0xf7, _3 | _32_bit, _rm32 }, + { 0xf7, _3 | _64_bit, _rm64 }, + { ASM_END } +}; +PTRNTAB1 aptb1NOT[] = /* NOT */ { + { 0xf6, _2, _rm8 }, + { 0xf7, _2 | _16_bit, _rm16 }, + { 0xf7, _2 | _32_bit, _rm32 }, + { 0xf7, _2 | _64_bit, _rm64 }, + { ASM_END } +}; +PTRNTAB1 aptb1POP[] = /* POP */ { + { 0x8f, _0 | _16_bit, _m16 }, + { 0x8f, _0 | _i64_bit | _32_bit, _m32 }, + { 0x8f, _0 | _64_bit, _m64 }, // TODO REX_W override is implicit + { 0x58, _rw | _16_bit, _r16 | _plus_r }, + { 0x58, _rd | _i64_bit | _32_bit, _r32 | _plus_r }, + { 0x58, _r | _32_bit, _r64 | _plus_r }, // REX_W override is implicit + { 0x1f, _i64_bit, _ds | _seg }, + { 0x07, _i64_bit | _modes, _es | _seg }, + { 0x17, _i64_bit, _ss | _seg }, + { 0x0fa1, 0, _fs | _seg }, + { 0x0fa9, 0, _gs | _seg }, + { ASM_END } +}; +PTRNTAB1 aptb1PUSH[] = /* PUSH */ { + { 0xff, _6 | _16_bit, _m16 }, + { 0xff, _6 | _i64_bit | _32_bit, _m32 }, + { 0xff, _6 | _64_bit, _m64 }, // TODO REX_W override is implicit + { 0x50, _r | _16_bit, _r16 | _plus_r }, + { 0x50, _r | _i64_bit | _32_bit, _r32 | _plus_r }, + { 0x50, _r | _32_bit, _r64 | _plus_r }, // REX_W override is implicit + { 0x6a, 0,_imm8 }, + { 0x68, _16_bit,_imm16 }, + { 0x68, _16_bit,_rel16 }, + { 0x68, _32_bit,_imm32 }, + { 0x68, _32_bit,_rel32 }, + { 0x0e, _i64_bit,_cs | _seg }, + { 0x16, _i64_bit,_ss | _seg }, + { 0x1e, _i64_bit,_ds | _seg }, + { 0x06, _i64_bit,_es | _seg }, + { 0x0fa0, 0,_fs | _seg}, + { 0x0fa8, 0,_gs | _seg}, + { ASM_END } +}; +PTRNTAB1 aptb1RET[] = /* RET */ { + { 0xc3, 0, 0 }, + { 0xc2, _iw, _imm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1RETF[] = /* RETF */ { + { 0xcb, 0, 0 }, + { 0xca, _iw, _imm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1SCAS[] = /* SCAS */ { + { 0xae, _moddi, _m8 }, + { 0xaf, _16_bit | _moddi, _m16 }, + { 0xaf, _32_bit | _moddi, _m32 }, + { ASM_END } +}; + +#define OPTABLE(str,op) \ +PTRNTAB1 aptb1##str[] = { \ + { 0xf90|op, _cb, _rm8 }, \ + { ASM_END } \ +} + +OPTABLE(SETO,0); +OPTABLE(SETNO,1); +OPTABLE(SETB,2); +OPTABLE(SETNB,3); +OPTABLE(SETZ,4); +OPTABLE(SETNZ,5); +OPTABLE(SETBE,6); +OPTABLE(SETNBE,7); +OPTABLE(SETS,8); +OPTABLE(SETNS,9); +OPTABLE(SETP,0xA); +OPTABLE(SETNP,0xB); +OPTABLE(SETL,0xC); +OPTABLE(SETNL,0xD); +OPTABLE(SETLE,0xE); +OPTABLE(SETNLE,0xF); + +#undef OPTABLE + +PTRNTAB1 aptb1SGDT[]= /* SGDT */ { + { 0xf01, _0, _m48 }, + { ASM_END } +}; +PTRNTAB1 aptb1SIDT[] = /* SIDT */ { + { 0xf01, _1, _m48 }, + { ASM_END } +}; +PTRNTAB1 aptb1SLDT[] = /* SLDT */ { + { 0xf00, _0, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1SMSW[] = /* SMSW */ { + { 0xf01, _4, _rm16 }, + { 0xf01, _4, _r32 }, + { ASM_END } +}; +PTRNTAB1 aptb1STOS[] = /* STOS */ { + { 0xaa, _moddi, _m8 }, + { 0xab, _16_bit | _moddi, _m16 }, + { 0xab, _32_bit | _moddi, _m32 }, + { ASM_END } +}; +PTRNTAB1 aptb1STR[] = /* STR */ { + { 0xf00, _1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1VERR[] = /* VERR */ { + { 0xf00, _4|_modnot1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1VERW[] = /* VERW */ { + { 0xf00, _5|_modnot1, _rm16 }, + { ASM_END } +}; +PTRNTAB1 aptb1XLAT[] = /* XLAT */ { + { 0xd7, _modax, 0 }, + { 0xd7, _modax, _m8 }, + { ASM_END } +}; +PTRNTAB1 aptb1CMPXCH8B[] = /* CMPXCH8B */ { + { 0x0fc7, _1 | _modaxdx | _I386, _m64 }, + { ASM_END } +}; + +PTRNTAB1 aptb1CMPXCH16B[] = /* CMPXCH16B */ { + { 0x0fc7, _1 | _modaxdx | _64_bit, _m64 }, + { ASM_END } +}; + +#define OPTABLE(str,op,rr,m) \ +PTRNTAB2 aptb2##str[] = { \ + { op+4, _ib|m, _al, _imm8 }, \ + { 0x83, rr|_ib|_16_bit|m, _rm16, _imm8 }, \ + { op+5, _iw|_16_bit|m, _ax, _imm16 }, \ + { 0x83, rr|_ib|_32_bit|m, _rm32, _imm8 }, \ + { 0x83, rr|_ib|_64_bit|m, _rm64, _imm8 }, \ + { op+5, _id|_32_bit|m, _eax, _imm32 }, \ + { op+5, _id|_64_bit|m, _rax, _imm32 }, \ + { 0x80, rr|_ib|m, _rm8, _imm8 }, \ + { 0x81, rr|_iw|_16_bit|m, _rm16, _imm16 }, \ + { 0x81, rr|_id|_32_bit|m, _rm32, _imm32 }, \ + { 0x81, rr|_id|_64_bit|m, _rm64, _imm32 }, \ + { op+0, _r|m, _rm8, _r8 }, \ + { op+1, _r|_16_bit|m, _rm16, _r16 }, \ + { op+1, _r|_32_bit|m, _rm32, _r32 }, \ + { op+1, _r|_64_bit|m, _rm64, _r64 }, \ + { op+2, _r|m, _r8, _rm8 }, \ + { op+3, _r|_16_bit|m, _r16, _rm16 }, \ + { op+3, _r|_32_bit|m, _r32, _rm32 }, \ + { op+3, _r|_64_bit|m, _r64, _rm64 }, \ + { ASM_END } \ +} + +OPTABLE(ADD,0x00,_0,0); +OPTABLE(OR, 0x08,_1,0); +OPTABLE(ADC,0x10,_2,0); +OPTABLE(SBB,0x18,_3,0); +OPTABLE(AND,0x20,_4,0); +OPTABLE(SUB,0x28,_5,0); +OPTABLE(XOR,0x30,_6,0); +OPTABLE(CMP,0x38,_7,_modnot1); + +#undef OPTABLE + +PTRNTAB2 aptb2ARPL[] = /* ARPL */ { + { 0x63, _r|_i64_bit, _rm16, _r16 }, + { ASM_END } +}; +PTRNTAB2 aptb2BOUND[] = /* BOUND */ { + { 0x62, _r|_i64_bit|_16_bit|_modnot1,_r16,_m16 },// Should really b3 _m16_16 + { 0x62, _r|_i64_bit|_32_bit|_modnot1,_r32,_m32 },// Should really be _m32_32 + { ASM_END } +}; +PTRNTAB2 aptb2BSF[] = /* BSF */ { + { 0x0fbc, _cw | _16_bit, _r16, _rm16 }, + { 0x0fbc, _cd|_32_bit, _r32, _rm32 }, + { 0x0fbc, _cq|_64_bit, _r64, _rm64 }, + { ASM_END } +}; +PTRNTAB2 aptb2BSR[] = /* BSR */ { + { 0x0fbd, _cw|_16_bit, _r16, _rm16 }, + { 0x0fbd, _cd|_32_bit, _r32, _rm32 }, + { 0x0fbd, _cq|_64_bit, _r64, _rm64 }, + { ASM_END } +}; +PTRNTAB2 aptb2BT[] = /* BT */ { + { 0x0fa3, _cw|_16_bit|_modnot1, _rm16, _r16 }, + { 0x0fa3, _cd|_32_bit|_modnot1, _rm32, _r32 }, + { 0x0fa3, _cq|_64_bit|_modnot1, _rm64, _r64 }, + { 0x0fba, _4|_ib|_16_bit|_modnot1, _rm16, _imm8 }, + { 0x0fba, _4|_ib|_32_bit|_modnot1, _rm32, _imm8 }, + { 0x0fba, _4|_ib|_64_bit|_modnot1, _rm64, _imm8 }, + { ASM_END } +}; +PTRNTAB2 aptb2BTC[] = /* BTC */ { + { 0x0fbb, _cw|_16_bit, _rm16, _r16 }, + { 0x0fbb, _cd|_32_bit, _rm32, _r32 }, + { 0x0fbb, _cq|_64_bit, _rm64, _r64 }, + { 0x0fba, _7|_ib|_16_bit, _rm16, _imm8 }, + { 0x0fba, _7|_ib|_32_bit, _rm32, _imm8 }, + { 0x0fba, _7|_ib|_64_bit, _rm64, _imm8 }, + { ASM_END } +}; +PTRNTAB2 aptb2BTR[] = /* BTR */ { + { 0x0fb3, _cw|_16_bit, _rm16, _r16 }, + { 0x0fb3, _cd|_32_bit, _rm32, _r32 }, + { 0x0fb3, _cq|_64_bit, _rm64, _r64 }, + { 0x0fba, _6|_ib|_16_bit, _rm16, _imm8 }, + { 0x0fba, _6|_ib|_32_bit, _rm32, _imm8 }, + { 0x0fba, _6|_ib|_64_bit, _rm64, _imm8 }, + { ASM_END } +}; +PTRNTAB2 aptb2BTS[] = /* BTS */ { + { 0x0fab, _cw|_16_bit, _rm16, _r16 }, + { 0x0fab, _cd|_32_bit, _rm32, _r32 }, + { 0x0fab, _cq|_64_bit, _rm64, _r64 }, + { 0x0fba, _5|_ib|_16_bit, _rm16, _imm8 }, + { 0x0fba, _5|_ib|_32_bit, _rm32, _imm8 }, + { 0x0fba, _5|_ib|_64_bit, _rm64, _imm8 }, + { ASM_END } +}; +PTRNTAB2 aptb2CMPS[] = /* CMPS */ { + { 0xa6, _modsidi, _m8, _m8 }, + { 0xa7, _modsidi, _m16, _m16 }, + { 0xa7, _modsidi, _m32, _m32 }, + { ASM_END } +}; +PTRNTAB2 aptb2CMPXCHG[] = /* CMPXCHG */ { + { 0xfb0, _I386 | _cb|_mod2, _rm8, _r8 }, + // This is really a 486 only + // instruction + { 0xfb1, _I386 | _cw | _16_bit|_mod2, _rm16, _r16 }, + { 0xfb1, _I386 | _cd | _32_bit|_mod2, _rm32, _r32 }, + { 0xfb1, _I386 | _cq | _64_bit|_mod2, _rm64, _r64 }, + { ASM_END } +}; +PTRNTAB2 aptb2DIV[] = /* DIV */ { + { 0xf6, _6, _al, _rm8 }, + { 0xf7, _6 | _16_bit | _moddx, _ax, _rm16 }, + { 0xf7, _6 | _32_bit | _moddx, _eax, _rm32 }, + { 0xf7, _6 | _64_bit | _moddx, _rax, _rm64 }, + { 0xf6, _6 | _modax, _rm8, 0 }, + { 0xf7, _6 | _16_bit | _modaxdx, _rm16, 0 }, + { 0xf7, _6 | _32_bit | _modaxdx, _rm32, 0 }, + { 0xf7, _6 | _64_bit | _modaxdx, _rm64, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2ENTER[] = /* ENTER */ { + { 0xc8, _iw|_ib, _imm16, _imm8 }, + { ASM_END } +}; +PTRNTAB2 aptb2IDIV[] = /* IDIV */ { + { 0xf6, _7, _al, _rm8 }, + { 0xf7, _7|_16_bit|_moddx, _ax, _rm16 }, + { 0xf7, _7|_32_bit|_moddx, _eax, _rm32 }, + { 0xf7, _7|_64_bit|_moddx, _rax, _rm64 }, + { 0xf6, _7 | _modax, _rm8, 0 }, + { 0xf7, _7|_16_bit|_modaxdx, _rm16, 0 }, + { 0xf7, _7|_32_bit|_modaxdx, _rm32, 0 }, + { 0xf7, _7|_64_bit|_modaxdx, _rm64, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2IN[] = /* IN */ { + { 0xe4, _ib, _al, _imm8 }, + { 0xe5, _ib|_16_bit,_ax, _imm8 }, + { 0xe5, _ib|_32_bit,_eax, _imm8 }, + { 0xec, 0, _al, _dx }, + { 0xed, _16_bit, _ax, _dx }, + { 0xed, _32_bit, _eax, _dx }, + { ASM_END } +}; +PTRNTAB2 aptb2INS[] = /* INS */ { + { 0x6c, _modsi, _rm8, _dx }, + { 0x6d, _modsi|_16_bit, _rm16, _dx }, + { 0x6d, _32_bit|_modsi, _rm32, _dx }, + { ASM_END } +}; + +PTRNTAB2 aptb2LAR[] = /* LAR */ { + { 0x0f02, _r|_16_bit, _r16, _rm16 }, + { 0x0f02, _r|_32_bit, _r32, _rm32 }, + { ASM_END } +}; +PTRNTAB2 aptb2LDS[] = /* LDS */ { + { 0xc5, _r|_i64_bit|_16_bit, _r16, _m32 }, + { 0xc5, _r|_i64_bit|_32_bit, _r32, _m48 }, + { ASM_END } +}; + +PTRNTAB2 aptb2LEA[] = /* LEA */ { + { 0x8d, _r|_16_bit, _r16, _m8 | _m16 | _m32 | _m48 }, + { 0x8d, _r|_32_bit, _r32, _m8 | _m16 | _m32 | _m48 }, + { 0x8d, _r|_64_bit, _r64, _m8 | _m16 | _m32 | _m48 | _m64 }, + { 0x8d, _r|_16_bit, _r16, _rel16 }, + { 0x8d, _r|_32_bit, _r32, _rel32 }, + { 0x8d, _r|_64_bit, _r64, _rel32 }, + { ASM_END } +}; +PTRNTAB2 aptb2LES[] = /* LES */ { + { 0xc4, _r|_i64_bit|_16_bit|_modes, _r16, _m32 }, + { 0xc4, _r|_i64_bit|_32_bit|_modes, _r32, _m48 }, + { ASM_END } +}; +PTRNTAB2 aptb2LFS[] = /* LFS */ { + { 0x0fb4, _r|_16_bit, _r16, _m32 }, + { 0x0fb4, _r|_32_bit, _r32, _m48 }, + { ASM_END } +}; +PTRNTAB2 aptb2LGS[] = /* LGS */ { + { 0x0fb5, _r|_16_bit, _r16, _m32 }, + { 0x0fb5, _r|_32_bit, _r32, _m48 }, + { ASM_END } +}; +PTRNTAB2 aptb2LSS[] = /* LSS */ { + { 0x0fb2, _r|_16_bit, _r16, _m32 }, + { 0x0fb2, _r|_32_bit, _r32, _m48 }, + { ASM_END } +}; +PTRNTAB2 aptb2LSL[] = /* LSL */ { + { 0x0f03, _r|_16_bit, _r16, _rm16 }, + { 0x0f03, _r|_32_bit, _r32, _rm32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOV[] = /* MOV */ { +#if 0 // Let pinholeopt() do this + { 0xa0, 0, _al, _moffs8 }, + { 0xa1, _16_bit, _ax, _moffs16 }, + { 0xa1, _32_bit, _eax, _moffs32 }, + { 0xa2, 0, _moffs8, _al }, + { 0xa3, _16_bit, _moffs16, _ax }, + { 0xa3, _32_bit, _moffs32, _eax }, +#endif + { 0x88, _r, _rm8, _r8 }, + { 0x89, _r|_16_bit, _rm16, _r16 }, + { 0x89, _r|_32_bit, _rm32, _r32 }, + { 0x89, _r|_64_bit, _rm64, _r64 }, + { 0x8a, _r, _r8, _rm8 }, + { 0x8b, _r|_16_bit, _r16, _rm16 }, + { 0x8b, _r|_32_bit, _r32, _rm32 }, + { 0x8b, _r|_64_bit, _r64, _rm64 }, + { 0x8c, _r, _rm16, _seg|_ds|_es| _ss | _fs | _gs | _cs }, + { 0x8e, _r, _seg|_ds|_es|_ss|_fs|_gs|_cs, _rm16 }, + { 0xb0, _rb, _r8 | _plus_r, _imm8 }, + { 0xb8, _rw | _16_bit, _r16 | _plus_r, _imm16 }, + { 0xb8, _rd|_32_bit, _r32 | _plus_r, _imm32 }, + { 0xb8, _rd|_64_bit, _r64 | _plus_r, _imm64 }, + { 0xc6, _cb, _rm8, _imm8 }, + { 0xc7, _cw|_16_bit, _rm16, _imm16 }, + { 0xc7, _cd|_32_bit, _rm32, _imm32 }, +#if 0 // Let pinholeopt() do this + { 0xc6, _cb, _moffs8, _imm8 }, + { 0xc7, _cw|_16_bit, _moffs16, _imm16 }, + { 0xc7, _cd|_32_bit, _moffs32, _imm32 }, +#endif + { 0x0f20, _r, _r32, _special | _crn }, + { 0x0f22, _r, _special|_crn, _r32 }, + { 0x0f21, _r, _r32, _special | _drn }, + { 0x0f23, _r, _special|_drn, _r32 }, + { 0x0f24, _r, _r32, _special | _trn }, + { 0x0f26, _r, _special|_trn, _r32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVS[] = /* MOVS */ { + { 0xa4, _modsidi , _m8, _m8 }, + { 0xa5, _modsidi | _16_bit, _m16, _m16 }, + { 0xa5, _modsidi | _32_bit, _m32, _m32 }, + { ASM_END } +}; +PTRNTAB2 aptb2MOVSX[] = /* MOVSX */ { + { 0x0fbe, _r|_16_bit, _r16, _rm8 }, + { 0x0fbe, _r|_32_bit, _r32, _rm8 }, +#if 1 + { 0x0fbf, _r|_16_bit, _r16, _rm16 }, + { 0x0fbf, _r|_32_bit, _r32, _rm16 }, +#else + { 0x0fbf, _r, _r32, _rm16 }, +#endif + { ASM_END } +}; +PTRNTAB2 aptb2MOVZX[] = /* MOVZX */ { + { 0x0fb6, _r|_16_bit, _r16, _rm8 }, + { 0x0fb6, _r|_32_bit, _r32, _rm8 }, +#if 1 + { 0x0fb7, _r|_16_bit, _r16, _rm16 }, + { 0x0fb7, _r|_32_bit, _r32, _rm16 }, +#else + { 0x0fb7, _r, _r32, _rm16 }, +#endif + { ASM_END } +}; +PTRNTAB2 aptb2MUL[] = /* MUL */ { + { 0xf6, _4, _al, _rm8 }, + { 0xf7, _4|_16_bit|_moddx, _ax, _rm16 }, + { 0xf7, _4|_32_bit|_moddx, _eax, _rm32 }, + { 0xf7, _4|_64_bit|_moddx, _rax, _rm64 }, + { 0xf6, _4|_modax, _rm8, 0 }, + { 0xf7, _4|_16_bit|_modaxdx, _rm16, 0 }, + { 0xf7, _4|_32_bit|_modaxdx, _rm32, 0 }, + { 0xf7, _4|_64_bit|_modaxdx, _rm64, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2OUT[] = /* OUT */ { + { 0xe6, _ib, _imm8, _al }, + { 0xe7, _ib|_16_bit, _imm8, _ax }, + { 0xe7, _ib|_32_bit, _imm8, _eax }, + { 0xee, _modnot1, _dx, _al }, + { 0xef, _16_bit|_modnot1, _dx, _ax }, + { 0xef, _32_bit|_modnot1, _dx, _eax }, + { ASM_END } +}; +PTRNTAB2 aptb2OUTS[] = /* OUTS */ { + { 0x6e, _modsinot1, _dx, _rm8 }, + { 0x6f, _16_bit | _I386 |_modsinot1, _dx, _rm16 }, + { 0x6f, _32_bit | _I386| _modsinot1, _dx, _rm32 }, + { ASM_END } +}; + +#define OPTABLE(str,op) \ +PTRNTAB2 aptb2##str[] = { \ + { 0xd2, op, _rm8, _cl }, \ + { 0xc0, op|_ib, _rm8, _imm8 }, \ + { 0xd3, op|_16_bit, _rm16, _cl }, \ + { 0xc1, op|_ib|_16_bit, _rm16, _imm8 }, \ + { 0xd3, op|_32_bit, _rm32, _cl }, \ + { 0xc1, op|_ib|_32_bit, _rm32, _imm8, }, \ + { 0xd3, op|_64_bit, _rm64, _cl }, \ + { 0xc1, op|_ib|_64_bit, _rm64, _imm8, }, \ + { ASM_END } \ +} + +OPTABLE(ROL,_0); +OPTABLE(ROR,_1); +OPTABLE(RCL,_2); +OPTABLE(RCR,_3); +OPTABLE(SHL,_4); +OPTABLE(SHR,_5); +OPTABLE(SAR,_7); + +#undef OPTABLE + +PTRNTAB2 aptb2TEST[] = /* TEST */ { + { 0xa8, _ib|_modnot1, _al, _imm8 }, + { 0xa9, _iw|_16_bit|_modnot1, _ax, _imm16 }, + { 0xa9, _id|_32_bit|_modnot1, _eax, _imm32 }, + { 0xa9, _id|_64_bit|_modnot1, _rax, _imm32 }, + { 0xf6, _0|_modnot1, _rm8, _imm8 }, + { 0xf7, _0|_16_bit|_modnot1, _rm16, _imm16 }, + { 0xf7, _0|_32_bit|_modnot1, _rm32, _imm32 }, + { 0xf7, _0|_64_bit|_modnot1, _rm64, _imm32 }, + { 0x84, _r|_modnot1, _rm8, _r8 }, + { 0x85, _r|_16_bit|_modnot1, _rm16, _r16 }, + { 0x85, _r|_32_bit|_modnot1, _rm32, _r32 }, + { 0x85, _r|_64_bit|_modnot1, _rm64, _r64 }, + { ASM_END } +}; +PTRNTAB2 aptb2XADD[] = /* XADD */ { // 486 only instruction +// { 0x0fc0, _ib | _I386|_mod2, _rm8, _r8 }, +// { 0x0fc1, _iw | _I386|_16_bit|_mod2, _rm16, _r16 }, +// { 0x0fc1, _id | _I386|_32_bit|_mod2, _rm32, _r32 }, + { 0x0fc0, _r | _I386|_mod2, _rm8, _r8 }, + { 0x0fc1, _r | _I386|_16_bit|_mod2, _rm16, _r16 }, + { 0x0fc1, _r | _I386|_32_bit|_mod2, _rm32, _r32 }, + { 0x0fc1, _r | _64_bit|_mod2, _rm64, _r64 }, + { ASM_END } +}; +PTRNTAB2 aptb2XCHG[] = /* XCHG */ { + { 0x90, _r|_16_bit|_mod2, _ax , _r16 | _plus_r }, + { 0x90, _r|_16_bit|_mod2, _r16 | _plus_r, _ax }, + { 0x90, _r|_32_bit|_mod2, _eax, _r32 | _plus_r }, + { 0x90, _r|_32_bit|_mod2, _r32 | _plus_r, _eax }, + { 0x86, _r|_mod2, _rm8, _r8 }, + { 0x86, _r|_mod2, _r8, _rm8 }, + { 0x87, _r|_16_bit|_mod2, _rm16, _r16 }, + { 0x87, _r|_16_bit|_mod2, _r16, _rm16 }, + { 0x87, _r|_32_bit|_mod2, _rm32, _r32 }, + { 0x87, _r|_32_bit|_mod2, _r32, _rm32 }, + { 0x87, _r|_64_bit|_mod2, _rm64, _r64 }, + { 0x87, _r|_64_bit|_mod2, _r64, _rm64 }, + { ASM_END } +}; + +#define OPTABLE(str,op) \ +PTRNTAB2 aptb2##str[] = { \ + { 0x0F40|op, _r|_16_bit, _r16, _rm16 }, \ + { 0x0F40|op, _r|_32_bit, _r32, _rm32 }, \ + { 0x0F40|op, _r|_64_bit, _r64, _rm64 }, \ + { ASM_END } \ +} + +OPTABLE(CMOVO,0); +OPTABLE(CMOVNO,1); +OPTABLE(CMOVB,2); +OPTABLE(CMOVNB,3); +OPTABLE(CMOVZ,4); +OPTABLE(CMOVNZ,5); +OPTABLE(CMOVBE,6); +OPTABLE(CMOVNBE,7); +OPTABLE(CMOVS,8); +OPTABLE(CMOVNS,9); +OPTABLE(CMOVP,0xA); +OPTABLE(CMOVNP,0xB); +OPTABLE(CMOVL,0xC); +OPTABLE(CMOVNL,0xD); +OPTABLE(CMOVLE,0xE); +OPTABLE(CMOVNLE,0xF); + +#undef OPTABLE + +PTRNTAB3 aptb3IMUL[] = /* IMUL */ { + { 0x0faf, _r|_16_bit, _r16, _rm16, 0 }, + { 0x0faf, _r|_32_bit, _r32, _rm32, 0 }, + { 0x0faf, _r|_64_bit, _r64, _rm64, 0 }, + { 0xf6, _5|_modax, _rm8, 0, 0 }, + { 0xf7, _5|_16_bit|_modaxdx, _rm16, 0, 0 }, + { 0xf7, _5|_32_bit|_modaxdx, _rm32, 0, 0 }, + { 0xf7, _5|_64_bit|_modaxdx, _rm64, 0, 0 }, + { 0x6b, _r|_ib|_16_bit, _r16, _imm8, 0 }, + { 0x6b, _r|_ib|_32_bit, _r32, _imm8, 0 }, + { 0x69, _r|_iw|_16_bit, _r16, _imm16, 0 }, + { 0x69, _r|_id|_32_bit, _r32, _imm32, 0 }, + { 0x69, _r|_id|_64_bit, _r64, _imm32, 0 }, + { 0x6b, _r|_ib|_16_bit, _r16, _rm16, _imm8 }, + { 0x6b, _r|_ib|_32_bit, _r32, _rm32, _imm8 }, + { 0x6b, _r|_ib|_64_bit, _r64, _rm64, _imm8 }, + { 0x69, _r|_iw|_16_bit, _r16, _rm16, _imm16 }, + { 0x69, _r|_id|_32_bit, _r32, _rm32, _imm32 }, + { 0x69, _r|_id|_64_bit, _r64, _rm64, _imm32 }, + { ASM_END } +}; +PTRNTAB3 aptb3SHLD[] = /* SHLD */ { + { 0x0fa4, _cw|_16_bit, _rm16, _r16, _imm8 }, + { 0x0fa4, _cd|_32_bit, _rm32, _r32, _imm8 }, + { 0x0fa4, _cq|_64_bit, _rm64, _r64, _imm8 }, + { 0x0fa5, _cw|_16_bit, _rm16, _r16, _cl }, + { 0x0fa5, _cd|_32_bit, _rm32, _r32, _cl }, + { 0x0fa5, _cq|_64_bit, _rm64, _r64, _cl }, + { ASM_END } +}; +PTRNTAB3 aptb3SHRD[] = /* SHRD */ { + { 0x0fac, _cw|_16_bit, _rm16, _r16, _imm8 }, + { 0x0fac, _cd|_32_bit, _rm32, _r32, _imm8 }, + { 0x0fac, _cq|_64_bit, _rm64, _r64, _imm8 }, + { 0x0fad, _cw|_16_bit, _rm16, _r16, _cl }, + { 0x0fad, _cd|_32_bit, _rm32, _r32, _cl }, + { 0x0fad, _cq|_64_bit, _rm64, _r64, _cl }, + { ASM_END } +}; +// +// Floating point instructions which have entirely different flag +// interpretations +// + +OPTABLE0(F2XM1, 0xd9f0,0); +OPTABLE0(FABS, 0xd9e1,0); +OPTABLE0(FCHS, 0xd9e0,0); +OPTABLE0(FCLEX, 0xdbe2,_fwait); +OPTABLE0(FNCLEX, 0xdbe2, _nfwait); +OPTABLE0(FCOMPP, 0xded9, 0); +OPTABLE0(FCOS, 0xd9ff, 0); +OPTABLE0(FUCOMPP, 0xdae9, 0); +OPTABLE0(FDECSTP, 0xd9f6, 0); +OPTABLE0(FINCSTP, 0xd9f7, 0); +OPTABLE0(FINIT, 0xdbe3, _fwait); +OPTABLE0(FNINIT, 0xdbe3, _nfwait); +OPTABLE0(FENI, 0xdbe0, _fwait); +OPTABLE0(FNENI, 0xdbe0, _nfwait); +OPTABLE0(FDISI, 0xdbe1, _fwait); +OPTABLE0(FNDISI, 0xdbe1, _nfwait); +OPTABLE0(FLD1, 0xd9e8, 0); +OPTABLE0(FLDL2T, 0xd9e9, 0); +OPTABLE0(FLDL2E, 0xd9ea, 0); +OPTABLE0(FLDPI, 0xd9eb, 0); +OPTABLE0(FLDLG2, 0xd9ec, 0); +OPTABLE0(FLDLN2, 0xd9ed, 0); +OPTABLE0(FLDZ, 0xd9ee, 0); +OPTABLE0(FNOP, 0xd9d0, 0); +OPTABLE0(FPATAN, 0xd9f3, 0); +OPTABLE0(FPREM, 0xd9f8, 0); +OPTABLE0(FPREM1, 0xd9f5, 0); +OPTABLE0(FPTAN, 0xd9f2, 0); +OPTABLE0(FRNDINT, 0xd9fc, 0); +OPTABLE0(FSCALE, 0xd9fd, 0); +OPTABLE0(FSETPM, 0xdbe4, 0); +OPTABLE0(FSIN, 0xd9fe, 0); +OPTABLE0(FSINCOS, 0xd9fb, 0); +OPTABLE0(FSQRT, 0xd9fa, 0); +OPTABLE0(FTST, 0xd9e4, 0); +OPTABLE0(FWAIT, 0x9b, 0); +OPTABLE0(FXAM, 0xd9e5, 0); +OPTABLE0(FXTRACT, 0xd9f4, 0); +OPTABLE0(FYL2X, 0xd9f1, 0); +OPTABLE0(FYL2XP1, 0xd9f9, 0); +// +// Floating point instructions which have entirely different flag +// interpretations but they overlap, only asm_determine_operator +// flags needs to know the difference +// 1 operand floating point instructions follow +// +PTRNTAB1 aptb1FBLD[] = /* FBLD */ { + { 0xdf, _4, _fm80 }, + { ASM_END } +}; + +PTRNTAB1 aptb1FBSTP[] = /* FBSTP */ { + { 0xdf, _6, _fm80 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVB[] = /* FCMOVB */ { + { 0xdac0, 0, _st, _sti | _plus_r }, + { 0xdac1, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVE[] = /* FCMOVE */ { + { 0xdac8, 0, _st, _sti | _plus_r }, + { 0xdac9, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVBE[] = /* FCMOVBE */ { + { 0xdad0, 0, _st, _sti | _plus_r }, + { 0xdad1, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVU[] = /* FCMOVU */ { + { 0xdad8, 0, _st, _sti | _plus_r }, + { 0xdad9, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVNB[] = /* FCMOVNB */ { + { 0xdbc0, 0, _st, _sti | _plus_r }, + { 0xdbc1, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVNE[] = /* FCMOVNE */ { + { 0xdbc8, 0, _st, _sti | _plus_r }, + { 0xdbc9, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVNBE[] = /* FCMOVNBE */ { + { 0xdbd0, 0, _st, _sti | _plus_r }, + { 0xdbd1, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCMOVNU[] = /* FCMOVNU */ { + { 0xdbd8, 0, _st, _sti | _plus_r }, + { 0xdbd9, 0, 0 }, + { ASM_END } +}; +PTRNTAB1 aptb1FCOM[] = /* FCOM */ { + { 0xd8, _2, _m32 }, + { 0xdc, _2, _fm64 }, + { 0xd8d0, 0, _sti | _plus_r }, + { 0xd8d1, 0, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2FCOMI[] = /* FCOMI */ { + { 0xdbf0, 0, _st, _sti | _plus_r }, + { 0xdbf0, 0, _sti | _plus_r, 0 }, + { 0xdbf1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FCOMIP[] = /* FCOMIP */ { + { 0xdff0, 0, _st, _sti | _plus_r }, + { 0xdff0, 0, _sti | _plus_r, 0 }, + { 0xdff1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FUCOMI[] = /* FUCOMI */ { + { 0xdbe8, 0, _st, _sti | _plus_r }, + { 0xdbe8, 0, _sti | _plus_r, 0 }, + { 0xdbe9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FUCOMIP[] = /* FUCOMIP */ { + { 0xdfe8, 0, _st, _sti | _plus_r }, + { 0xdfe8, 0, _sti | _plus_r, 0 }, + { 0xdfe9, 0, 0, 0 }, + { ASM_END } +}; + +PTRNTAB1 aptb1FCOMP[] = /* FCOMP */ { + { 0xd8, _3, _m32 }, + { 0xdc, _3, _fm64 }, + { 0xd8d8, 0, _sti | _plus_r }, + { 0xd8d9, 0, 0 }, + { ASM_END } +}; +PTRNTAB1 aptb1FFREE[] = /* FFREE */ { + { 0xddc0, 0, _sti | _plus_r }, + { ASM_END } +}; +PTRNTAB1 aptb1FICOM[] = /* FICOM */ { + { 0xde, _2, _m16 }, + { 0xda, _2, _m32 }, + { ASM_END } +}; +PTRNTAB1 aptb1FICOMP[] = /* FICOMP */ { + { 0xde, _3, _m16 }, + { 0xda, _3, _m32 }, + { ASM_END } +}; +PTRNTAB1 aptb1FILD[] = /* FILD */ { + { 0xdf, _0, _m16 }, + { 0xdb, _0, _m32 }, + { 0xdf, _5, _fm64 }, + { ASM_END } +}; +PTRNTAB1 aptb1FIST[] = /* FIST */ { + { 0xdf, _2, _m16 }, + { 0xdb, _2, _m32 }, + { ASM_END } +}; +PTRNTAB1 aptb1FISTP[] = /* FISTP */ { + { 0xdf, _3, _m16 }, + { 0xdb, _3, _m32 }, + { 0xdf, _7, _fm64 }, + { ASM_END } +}; +PTRNTAB1 aptb1FLD[] = /* FLD */ { + { 0xd9, _0, _m32 }, + { 0xdd, _0, _fm64 }, + { 0xdb, _5, _fm80 }, + { 0xd9c0, 0, _sti | _plus_r }, + { ASM_END } +}; +PTRNTAB1 aptb1FLDCW[] = /* FLDCW */ { + { 0xd9, _5, _m16 }, + { ASM_END } +}; +PTRNTAB1 aptb1FLDENV[] = /* FLDENV */ { + { 0xd9, _4, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FRSTOR[] = /* FRSTOR */ { + { 0xdd, _4, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FSAVE[] = /* FSAVE */ { + { 0xdd, _6 | _fwait, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FNSAVE[] = /* FNSAVE */ { + { 0xdd, _6 | _nfwait, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FST[] = /* FST */ { + { 0xd9, _2, _m32 }, + { 0xdd, _2, _fm64 }, + { 0xddd0, 0, _sti | _plus_r }, + { ASM_END } +}; + +PTRNTAB1 aptb1FSTP[] = /* FSTP */ { + { 0xd9, _3, _m32 }, + { 0xdd, _3, _fm64 }, + { 0xdb, _7, _fm80 }, + { 0xddd8, 0, _sti | _plus_r }, + { ASM_END } +}; +PTRNTAB1 aptb1FSTCW[] = /* FSTCW */ { + { 0xd9, _7 | _fwait , _m16 }, + { ASM_END } +}; +PTRNTAB1 aptb1FNSTCW[] = /* FNSTCW */ { + { 0xd9, _7 | _nfwait , _m16 }, + { ASM_END } +}; +PTRNTAB1 aptb1FSTENV[] = /* FSTENV */ { + { 0xd9, _6 | _fwait, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FNSTENV[] = /* FNSTENV */ { + { 0xd9, _6 | _nfwait, _m112 | _m224 }, + { ASM_END } +}; +PTRNTAB1 aptb1FSTSW[] = /* FSTSW */ { + { 0xdd, _7 | _fwait, _m16 }, + { 0xdfe0, _fwait | _modax, _ax }, + { ASM_END } +}; +PTRNTAB1 aptb1FNSTSW[] = /* FNSTSW */ { + { 0xdd, _7 | _nfwait, _m16 }, + { 0xdfe0, _nfwait | _modax, _ax }, + { ASM_END } +}; +PTRNTAB1 aptb1FUCOM[] = /* FUCOM */ { + { 0xdde0, 0, _sti | _plus_r }, + { 0xdde1, 0, 0 }, + { ASM_END } +}; +PTRNTAB1 aptb1FUCOMP[] = /* FUCOMP */ { + { 0xdde8, 0, _sti | _plus_r }, + { 0xdde9, 0, 0 }, + { ASM_END } +}; +PTRNTAB1 aptb1FXCH[] = /* FXCH */ { + { 0xd9c8, 0, _sti | _plus_r }, + { 0xd9c9, 0, 0 }, + { ASM_END } +}; +// +// Floating point instructions which have entirely different flag +// interpretations but they overlap, only asm_determine_operator +// flags needs to know the difference +// 2 operand floating point instructions follow +// +PTRNTAB2 aptb2FADD[] = /* FADD */ { + { 0xd8, _0, _m32, 0 }, + { 0xdc, _0, _fm64, 0 }, + { 0xd8c0, 0, _st, _sti | _plus_r }, + { 0xdcc0, 0, _sti | _plus_r, _st }, + { 0xdec1, 0, 0, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2FADDP[] = /* FADDP */ { + { 0xdec0, 0, _sti | _plus_r, _st }, + { 0xdec1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FIADD[] = /* FIADD */ { + { 0xda, _0, _m32, 0 }, + { 0xde, _0, _m16, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FDIV[] = /* FDIV */ { + { 0xd8, _6, _m32, 0 }, + { 0xdc, _6, _fm64, 0 }, + { 0xd8f0, 0, _st, _sti | _plus_r }, + { 0xdcf8, 0, _sti | _plus_r, _st }, + { 0xdef9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FDIVP[] = /* FDIVP */ { + { 0xdef9, 0, 0, 0 }, + { 0xdef8, 0, _sti | _plus_r, _st }, + { ASM_END } +}; +PTRNTAB2 aptb2FIDIV[] = /* FIDIV */ { + { 0xda, _6, _m32, 0 }, + { 0xde, _6, _m16, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FDIVR[] = /* FDIVR */ { + { 0xd8, _7, _m32, 0 }, + { 0xdc, _7, _fm64, 0 }, + { 0xd8f8, 0, _st, _sti | _plus_r }, + { 0xdcf0, 0, _sti | _plus_r, _st }, + { 0xdef1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FDIVRP[] = /* FDIVRP */ { + { 0xdef1, 0, 0, 0 }, + { 0xdef0, 0, _sti | _plus_r, _st }, + { ASM_END } +}; +PTRNTAB2 aptb2FIDIVR[] = /* FIDIVR */ { + { 0xda, _7, _m32, 0 }, + { 0xde, _7, _m16, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FMUL[] = /* FMUL */ { + { 0xd8, _1, _m32, 0 }, + { 0xdc, _1, _fm64, 0 }, + { 0xd8c8, 0, _st, _sti | _plus_r }, + { 0xdcc8, 0, _sti | _plus_r, _st }, + { 0xdec9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FMULP[] = /* FMULP */ { + { 0xdec8, 0, _sti | _plus_r, _st }, + { 0xdec9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FIMUL[] = /* FIMUL */ { + { 0xda, _1, _m32, 0 }, + { 0xde, _1, _m16, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FSUB[] = /* FSUB */ { + { 0xd8, _4, _m32, 0 }, + { 0xdc, _4, _fm64, 0 }, + { 0xd8e0, 0, _st, _sti | _plus_r }, + { 0xdce8, 0, _sti | _plus_r, _st }, + { 0xdee9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FSUBP[] = /* FSUBP */ { + { 0xdee8, 0, _sti | _plus_r, _st }, + { 0xdee9, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FISUB[] = /* FISUB */ { + { 0xda, _4, _m32, 0 }, + { 0xde, _4, _m16, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FSUBR[] = /* FSUBR */ { + { 0xd8, _5, _m32, 0 }, + { 0xdc, _5, _fm64, 0 }, + { 0xd8e8, 0, _st, _sti | _plus_r }, + { 0xdce0, 0, _sti | _plus_r, _st }, + { 0xdee1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FSUBRP[] = /* FSUBRP */ { + { 0xdee0, 0, _sti | _plus_r, _st }, + { 0xdee1, 0, 0, 0 }, + { ASM_END } +}; +PTRNTAB2 aptb2FISUBR[] = /* FISUBR */ { + { 0xda, _5, _m32, 0 }, + { 0xde, _5, _m16, 0 }, + { ASM_END } +}; + +///////////////////////////// MMX Extensions ///////////////////////// + +PTRNTAB0 aptb0EMMS[] = /* EMMS */ { + { 0x0F77, 0 } +}; + +PTRNTAB2 aptb2MOVD[] = /* MOVD */ { + { 0x0F6E,_r,_mm,_rm32 }, + { 0x0F7E,_r,_rm32,_mm }, + { LODD,_r,_xmm,_rm32 }, + { STOD,_r,_rm32,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVD[] = /* VMOVD */ { + { VEX_128_WIG(LODD), _r, _xmm, _rm32 }, + { VEX_128_WIG(STOD), _r, _rm32, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVQ[] = /* MOVQ */ { + { 0x0F6F,_r,_mm,_mmm64 }, + { 0x0F7F,_r,_mmm64,_mm }, + { LODQ,_r,_xmm,_xmm_m64 }, + { STOQ,_r,_xmm_m64,_xmm }, + { 0x0F6E, _r|_64_bit,_mm, _rm64 }, + { 0x0F7E, _r|_64_bit,_rm64,_mm }, + { LODD,_r|_64_bit,_xmm, _rm64 }, + { STOD,_r|_64_bit,_rm64,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVQ[] = /* VMOVQ */ { + { VEX_128_W1(LODD), _r, _xmm, _rm64 }, + { VEX_128_W1(STOD), _r, _rm64, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2PACKSSDW[] = /* PACKSSDW */ { + { 0x0F6B, _r,_mm,_mmm64 }, + { PACKSSDW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPACKSSDW[] = /* VPACKSSDW */ { + { VEX_NDS_128_WIG(PACKSSDW), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PACKSSWB[] = /* PACKSSWB */ { + { 0x0F63, _r,_mm,_mmm64 }, + { PACKSSWB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPACKSSWB[] = /* VPACKSSWB */ { + { VEX_NDS_128_WIG(PACKSSWB), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PACKUSWB[] = /* PACKUSWB */ { + { 0x0F67, _r,_mm,_mmm64 }, + { PACKUSWB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPACKUSWB[] = /* VPACKUSWB */ { + { VEX_NDS_128_WIG(PACKUSWB), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDB[] = /* PADDB */ { + { 0x0FFC, _r,_mm,_mmm64 }, + { PADDB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDB[] = /* VPADDB */ { + { VEX_NDS_128_WIG(PADDB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDD[] = /* PADDD */ { + { 0x0FFE, _r,_mm,_mmm64 }, + { PADDD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDD[] = /* VPADDD */ { + { VEX_NDS_128_WIG(PADDD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDSB[] = /* PADDSB */ { + { 0x0FEC, _r,_mm,_mmm64 }, + { PADDSB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDSB[] = /* VPADDSB */ { + { VEX_NDS_128_WIG(PADDSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDSW[] = /* PADDSW */ { + { 0x0FED, _r,_mm,_mmm64 }, + { PADDSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDSW[] = /* VPADDSW */ { + { VEX_NDS_128_WIG(PADDSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDUSB[] = /* PADDUSB */ { + { 0x0FDC, _r,_mm,_mmm64 }, + { PADDUSB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDUSB[] = /* VPADDUSB */ { + { VEX_NDS_128_WIG(PADDUSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDUSW[] = /* PADDUSW */ { + { 0x0FDD, _r,_mm,_mmm64 }, + { PADDUSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDUSW[] = /* VPADDUSW */ { + { VEX_NDS_128_WIG(PADDUSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDW[] = /* PADDW */ { + { 0x0FFD, _r,_mm,_mmm64 }, + { PADDW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDW[] = /* VPADDW */ { + { VEX_NDS_128_WIG(PADDW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PAND[] = /* PAND */ { + { 0x0FDB, _r,_mm,_mmm64 }, + { PAND, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPAND[] = /* VPAND */ { + { VEX_NDS_128_WIG(PAND), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PANDN[] = /* PANDN */ { + { 0x0FDF, _r,_mm,_mmm64 }, + { PANDN, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPANDN[] = /* VPANDN */ { + { VEX_NDS_128_WIG(PANDN), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPEQB[] = /* PCMPEQB */ { + { 0x0F74, _r,_mm,_mmm64 }, + { PCMPEQB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPEQB[] = /* VPCMPEQB */ { + { VEX_NDS_128_WIG(PCMPEQB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPEQD[] = /* PCMPEQD */ { + { 0x0F76, _r,_mm,_mmm64 }, + { PCMPEQD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPEQD[] = /* VPCMPEQD */ { + { VEX_NDS_128_WIG(PCMPEQD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPEQW[] = /* PCMPEQW */ { + { 0x0F75, _r,_mm,_mmm64 }, + { PCMPEQW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPEQW[] = /* VPCMPEQW */ { + { VEX_NDS_128_WIG(PCMPEQW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPGTB[] = /* PCMPGTB */ { + { 0x0F64, _r,_mm,_mmm64 }, + { PCMPGTB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPGTB[] = /* VPCMPGTB */ { + { VEX_NDS_128_WIG(PCMPGTB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPGTD[] = /* PCMPGTD */ { + { 0x0F66, _r,_mm,_mmm64 }, + { PCMPGTD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPGTD[] = /* VPCMPGTD */ { + { VEX_NDS_128_WIG(PCMPGTD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPGTW[] = /* PCMPGTW */ { + { 0x0F65, _r,_mm,_mmm64 }, + { PCMPGTW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPGTW[] = /* VPCMPGTW */ { + { VEX_NDS_128_WIG(PCMPGTW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMADDWD[] = /* PMADDWD */ { + { 0x0FF5, _r,_mm,_mmm64 }, + { PMADDWD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMADDWD[] = /* VPMADDWD */ { + { VEX_NDS_128_WIG(PMADDWD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSLLW[] = /* PSLLW */ { + { 0x0FF1, _r,_mm,_mmm64 }, + { 0x0F71, _6,_mm,_imm8 }, + { PSLLW, _r,_xmm,_xmm_m128 }, + { 0x660F71, _6,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSLLW[] = /* VPSLLW */ { + { VEX_NDS_128_WIG(PSLLW), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F71), _6, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSLLD[] = /* PSLLD */ { + { 0x0FF2, _r,_mm,_mmm64 }, + { 0x0F72, _6,_mm,_imm8 }, + { PSLLD, _r,_xmm,_xmm_m128 }, + { 0x660F72, _6,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSLLD[] = /* VPSLLD */ { + { VEX_NDS_128_WIG(PSLLD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F72), _6, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSLLQ[] = /* PSLLQ */ { + { 0x0FF3, _r,_mm,_mmm64 }, + { 0x0F73, _6,_mm,_imm8 }, + { PSLLQ, _r,_xmm,_xmm_m128 }, + { PSLLDQ, _6,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSLLQ[] = /* VPSLLQ */ { + { VEX_NDS_128_WIG(PSLLQ), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(PSLLDQ), _6, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRAW[] = /* PSRAW */ { + { 0x0FE1, _r,_mm,_mmm64 }, + { 0x0F71, _4,_mm,_imm8 }, + { PSRAW, _r,_xmm,_xmm_m128 }, + { 0x660F71, _4,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRAW[] = /* VPSRAW */ { + { VEX_NDS_128_WIG(PSRAW), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F71), _4, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRAD[] = /* PSRAD */ { + { 0x0FE2, _r,_mm,_mmm64 }, + { 0x0F72, _4,_mm,_imm8 }, + { PSRAD, _r,_xmm,_xmm_m128 }, + { 0x660F72, _4,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRAD[] = /* VPSRAD */ { + { VEX_NDS_128_WIG(PSRAD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F72), _4, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRLW[] = /* PSRLW */ { + { 0x0FD1, _r,_mm,_mmm64 }, + { 0x0F71, _2,_mm,_imm8 }, + { PSRLW, _r,_xmm,_xmm_m128 }, + { 0x660F71, _2,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRLW[] = /* VPSRLW */ { + { VEX_NDS_128_WIG(PSRLW), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F71), _2, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRLD[] = /* PSRLD */ { + { 0x0FD2, _r,_mm,_mmm64 }, + { 0x0F72, _2,_mm,_imm8 }, + { PSRLD, _r,_xmm,_xmm_m128 }, + { 0x660F72, _2,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRLD[] = /* VPSRLD */ { + { VEX_NDS_128_WIG(PSRLD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(0x660F72), _2, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRLQ[] = /* PSRLQ */ { + { 0x0FD3, _r,_mm,_mmm64 }, + { 0x0F73, _2,_mm,_imm8 }, + { PSRLQ, _r,_xmm,_xmm_m128 }, + { PSLLDQ, _2,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRLQ[] = /* VPSRLQ */ { + { VEX_NDS_128_WIG(PSRLQ), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDD_128_WIG(PSLLDQ), _2, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBB[] = /* PSUBB */ { + { 0x0FF8, _r,_mm,_mmm64 }, + { PSUBB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBB[] = /* VPSUBB */ { + { VEX_NDS_128_WIG(PSUBB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBD[] = /* PSUBD */ { + { 0x0FFA, _r,_mm,_mmm64 }, + { PSUBD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBD[] = /* VPSUBD */ { + { VEX_NDS_128_WIG(PSUBD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBSB[] = /* PSUBSB */ { + { 0x0FE8, _r,_mm,_mmm64 }, + { PSUBSB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBSB [] = /* VPSUBSB */ { + { VEX_NDS_128_WIG(PSUBSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBSW[] = /* PSUBSW */ { + { 0x0FE9, _r,_mm,_mmm64 }, + { PSUBSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBSW[] = /* VPSUBSW */ { + { VEX_NDS_128_WIG(PSUBSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBUSB[] = /* PSUBUSB */ { + { 0x0FD8, _r,_mm,_mmm64 }, + { PSUBUSB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBUSB[] = /* VPSUBUSB */ { + { VEX_NDS_128_WIG(PSUBUSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBUSW[] = /* PSUBUSW */ { + { 0x0FD9, _r,_mm,_mmm64 }, + { PSUBUSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBUSW[] = /* VPSUBUSW */ { + { VEX_NDS_128_WIG(PSUBUSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + + +PTRNTAB2 aptb2PSUBW[] = /* PSUBW */ { + { 0x0FF9, _r,_mm,_mmm64 }, + { PSUBW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBW[] = /* VPSUBW */ { + { VEX_NDS_128_WIG(PSUBW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKHBW[] = /* PUNPCKHBW */ { + { 0x0F68, _r,_mm,_mmm64 }, + { PUNPCKHBW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKHBW[] = /* VPUNPCKHBW */ { + { VEX_NDS_128_WIG(PUNPCKHBW), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKHDQ[] = /* PUNPCKHDQ */ { + { 0x0F6A, _r,_mm,_mmm64 }, + { PUNPCKHDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKHDQ[] = /* VPUNPCKHDQ */ { + { VEX_NDS_128_WIG(PUNPCKHDQ), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKHWD[] = /* PUNPCKHWD */ { + { 0x0F69, _r,_mm,_mmm64 }, + { PUNPCKHWD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKHWD[] = /* VPUNPCKHWD */ { + { VEX_NDS_128_WIG(PUNPCKHWD), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKLBW[] = /* PUNPCKLBW */ { + { 0x0F60, _r,_mm,_mmm64 }, + { PUNPCKLBW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKLBW[] = /* VPUNPCKLBW */ { + { VEX_NDS_128_WIG(PUNPCKLBW), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKLDQ[] = /* PUNPCKLDQ */ { + { 0x0F62, _r,_mm,_mmm64 }, + { PUNPCKLDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKLDQ[] = /* VPUNPCKLDQ */ { + { VEX_NDS_128_WIG(PUNPCKLDQ), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKLWD[] = /* PUNPCKLWD */ { + { 0x0F61, _r,_mm,_mmm64 }, + { PUNPCKLWD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKLWD[] = /* VPUNPCKLWD */ { + { VEX_NDS_128_WIG(PUNPCKLWD), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PXOR[] = /* PXOR */ { + { 0x0FEF, _r,_mm,_mmm64 }, + { PXOR, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPXOR[] = /* VPXOR */ { + { VEX_NDS_128_WIG(PXOR), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +////////////////////// New Opcodes ///////////////////////////// + +#if 0 // Use REP NOP instead +PTRNTAB0 aptb0PAUSE[] = /* PAUSE */ { + { 0xf390, 0 } +}; +#endif + +PTRNTAB0 aptb0SYSCALL[] = /* SYSCALL */ { + { 0x0f05, _modcxr11 } +}; + +PTRNTAB0 aptb0SYSRET[] = /* SYSRET */ { + { 0x0f07, 0 } +}; + +PTRNTAB0 aptb0SYSENTER[] = /* SYSENTER */ { + { 0x0f34, 0 } +}; + +PTRNTAB0 aptb0SYSEXIT[] = /* SYSEXIT */ { + { 0x0f35, 0 } +}; + +PTRNTAB0 aptb0UD2[] = /* UD2 */ { + { 0x0f0b, 0 } +}; + +PTRNTAB0 aptb0LFENCE[] = /* LFENCE */ { + { 0x0FAEE8, 0 } +}; + +PTRNTAB0 aptb0MFENCE[] = /* MFENCE */ { + { 0x0FAEF0, 0 } +}; + +PTRNTAB0 aptb0SFENCE[] = /* SFENCE */ { + { 0x0FAEF8, 0 } +}; + +PTRNTAB1 aptb1FXSAVE[] = /* FXSAVE */ { + { 0x0FAE, _0, _m512 }, + { ASM_END } +}; + +PTRNTAB1 aptb1FXRSTOR[] = /* FXRSTOR */ { + { 0x0FAE, _1, _m512 }, + { ASM_END } +}; + +PTRNTAB1 aptb1LDMXCSR[] = /* LDMXCSR */ { + { 0x0FAE, _2, _m32 }, + { ASM_END } +}; + +PTRNTAB1 aptb1VLDMXCSR[] = /* VLDMXCSR */ { + { VEX_128_WIG(0x0FAE), _2, _m32 }, + { ASM_END } +}; + +PTRNTAB1 aptb1STMXCSR[] = /* STMXCSR */ { + { 0x0FAE, _3, _m32 }, + { ASM_END } +}; + +PTRNTAB1 aptb1VSTMXCSR[] = /* VSTMXCSR */ { + { VEX_128_WIG(0x0FAE), _3, _m32 }, + { ASM_END } +}; + +PTRNTAB1 aptb1CLFLUSH[] = /* CLFLUSH */ { + { 0x0FAE, _7, _m8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ADDPS[] = /* ADDPS */ { + { ADDPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VADDPS[] = /* VADDPS */ { + { VEX_NDS_128_WIG(ADDPS), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(ADDPS), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2ADDPD[] = /* ADDPD */ { + { ADDPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VADDPD[] = /* VADDPD */ { + { VEX_NDS_128_WIG(ADDPD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(ADDPD), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ADDSD[] = /* ADDSD */ { + { ADDSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VADDSD[] = /* VADDSD */ { + { VEX_NDS_128_WIG(ADDSD), _r, _xmm, _xmm, _xmm_m64, }, + { ASM_END } +}; + +PTRNTAB2 aptb2ADDSS[] = /* ADDSS */ { + { ADDSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VADDSS[] = /* VADDSS */ { + { VEX_NDS_128_WIG(ADDSS), _r, _xmm, _xmm, _xmm_m32, }, + { ASM_END } +}; + +PTRNTAB2 aptb2ANDPD[] = /* ANDPD */ { + { ANDPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VANDPD[] = /* VANDPD */ { + { VEX_NDS_128_WIG(ANDPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ANDPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ANDPS[] = /* ANDPS */ { + { ANDPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VANDPS[] = /* VANDPS */ { + { VEX_NDS_128_WIG(ANDPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ANDPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ANDNPD[] = /* ANDNPD */ { + { ANDNPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VANDNPD[] = /* VANDNPD */ { + { VEX_NDS_128_WIG(ANDNPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ANDNPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ANDNPS[] = /* ANDNPS */ { + { ANDNPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VANDNPS[] = /* VANDNPS */ { + { VEX_NDS_128_WIG(ANDNPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ANDNPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB3 aptb3CMPPS[] = /* CMPPS */ { + { CMPPS, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VCMPPS[] = /* VCMPPS */ { + { VEX_NDS_128_WIG(CMPPS), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(CMPPS), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3CMPPD[] = /* CMPPD */ { + { CMPPD, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VCMPPD[] = /* VCMPPD */ { + { VEX_NDS_128_WIG(CMPPD), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(CMPPD), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3CMPSD[] = /* CMPSD */ { + { 0xa7, _32_bit | _I386 | _modsidi }, + { CMPSD, _r,_xmm,_xmm_m64,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VCMPSD[] = /* VCMPSD */ { + { VEX_NDS_128_WIG(CMPSD), _r, _xmm, _xmm, _xmm_m64, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3CMPSS[] = /* CMPSS */ { + { CMPSS, _r,_xmm,_xmm_m32,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VCMPSS[] = /* VCMPSS */ { + { VEX_NDS_128_WIG(CMPSS), _r, _xmm, _xmm, _xmm_m32, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2COMISD[] = /* COMISD */ { + { COMISD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCOMISD[] = /* VCOMISD */ { + { VEX_128_WIG(COMISD), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2COMISS[] = /* COMISS */ { + { COMISS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCOMISS[] = /* VCOMISS */ { + { VEX_128_WIG(COMISS), _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTDQ2PD[] = /* CVTDQ2PD */ { + { CVTDQ2PD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTDQ2PD[] = /* VCVTDQ2PD */ { + { VEX_128_WIG(CVTDQ2PD), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTDQ2PD), _r, _ymm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTDQ2PS[] = /* CVTDQ2PS */ { + { CVTDQ2PS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTDQ2PS[] = /* VCVTDQ2PS */ { + { VEX_128_WIG(CVTDQ2PS), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTDQ2PS), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPD2DQ[] = /* CVTPD2DQ */ { + { CVTPD2DQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTPD2DQ[] = /* VCVTPD2DQ */ { + { VEX_128_WIG(CVTPD2DQ), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTPD2DQ), _r, _xmm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPD2PI[] = /* CVTPD2PI */ { + { CVTPD2PI, _r,_mm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPD2PS[] = /* CVTPD2PS */ { + { CVTPD2PS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTPD2PS[] = /* VCVTPD2PS */ { + { VEX_128_WIG(CVTPD2PS), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTPD2PS), _r, _xmm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPI2PD[] = /* CVTPI2PD */ { + { CVTPI2PD, _r,_xmm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPI2PS[] = /* CVTPI2PS */ { + { CVTPI2PS, _r,_xmm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPS2DQ[] = /* CVTPS2DQ */ { + { CVTPS2DQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTPS2DQ[] = /* VCVTPS2DQ */ { + { VEX_128_WIG(CVTPS2DQ), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTPS2DQ), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPS2PD[] = /* CVTPS2PD */ { + { CVTPS2PD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTPS2PD[] = /* VCVTPS2PD */ { + { VEX_128_WIG(CVTPS2PD), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTPS2PD), _r, _ymm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTPS2PI[] = /* CVTPS2PI */ { + { CVTPS2PI, _r,_mm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSD2SI[] = /* CVTSD2SI */ { + { CVTSD2SI, _r,_r32,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTSD2SI[] = /* VCVTSD2SI */ { + { VEX_128_WIG(CVTSD2SI), _r, _r32, _xmm_m64 }, + { VEX_128_W1(CVTSD2SI), _r, _r64, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSD2SS[] = /* CVTSD2SS */ { + { CVTSD2SS, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VCVTSD2SS[] = /* VCVTSD2SS */ { + { VEX_NDS_128_WIG(CVTSD2SS), _r, _xmm, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSI2SD[] = /* CVTSI2SD */ { + { CVTSI2SD, _r,_xmm,_rm32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VCVTSI2SD[] = /* VCVTSI2SD */ { + { VEX_NDS_128_WIG(CVTSI2SD), _r, _xmm, _xmm, _rm32 }, + { VEX_NDS_128_W1(CVTSI2SD), _r, _xmm, _xmm, _rm64 }, // implicit REX_W + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSI2SS[] = /* CVTSI2SS */ { + { CVTSI2SS, _r,_xmm,_rm32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VCVTSI2SS[] = /* VCVTSI2SS */ { + { VEX_NDS_128_WIG(CVTSI2SS), _r, _xmm, _xmm, _rm32 }, + { VEX_NDS_128_W1(CVTSI2SS), _r, _xmm, _xmm, _rm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSS2SD[] = /* CVTSS2SD */ { + { CVTSS2SD, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VCVTSS2SD[] = /* VCVTSS2SD */ { + { VEX_NDS_128_WIG(CVTSS2SD), _r, _xmm, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTSS2SI[] = /* CVTSS2SI */ { + { CVTSS2SI, _r,_r32,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTSS2SI[] = /* VCVTSS2SI */ { + { VEX_128_WIG(CVTSS2SI), _r, _r32, _xmm_m32 }, + { VEX_128_W1(CVTSS2SI), _r, _r64, _xmm_m32 }, // implicit REX_W + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTPD2PI[] = /* CVTTPD2PI */ { + { CVTTPD2PI, _r,_mm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTPD2DQ[] = /* CVTTPD2DQ */ { + { CVTTPD2DQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTTPD2DQ[] = /* VCVTTPD2DQ */ { + { VEX_128_WIG(CVTTPD2DQ), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTTPD2DQ), _r, _xmm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTPS2DQ[] = /* CVTTPS2DQ */ { + { CVTTPS2DQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTTPS2DQ[] = /* VCVTTPS2DQ */ { + { VEX_128_WIG(CVTTPS2DQ), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(CVTTPS2DQ), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTPS2PI[] = /* CVTTPS2PI */ { + { CVTTPS2PI, _r,_mm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTSD2SI[] = /* CVTTSD2SI */ { + { CVTTSD2SI, _r,_r32,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTTSD2SI[] = /* VCVTTSD2SI */ { + { VEX_128_WIG(CVTTSD2SI), _r, _r32, _xmm_m64 }, + { VEX_128_W1(CVTTSD2SI), _r, _r64, _xmm_m64 }, // implicit REX_W + { ASM_END } +}; + +PTRNTAB2 aptb2CVTTSS2SI[] = /* CVTTSS2SI */ { + { CVTTSS2SI, _r,_r32,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VCVTTSS2SI[] = /* VCVTTSS2SI */ { + { VEX_128_WIG(CVTTSS2SI), _r, _r32, _xmm_m64 }, + { VEX_128_W1(CVTTSS2SI), _r, _r64, _xmm_m64 }, // implicit REX_W + { ASM_END } +}; + +PTRNTAB2 aptb2DIVPD[] = /* DIVPD */ { + { DIVPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VDIVPD [] = /* VDIVPD */ { + { VEX_NDS_128_WIG(DIVPD), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(DIVPD), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2DIVPS[] = /* DIVPS */ { + { DIVPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VDIVPS [] = /* VDIVPS */ { + { VEX_NDS_128_WIG(DIVPS), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(DIVPS), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2DIVSD[] = /* DIVSD */ { + { DIVSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VDIVSD [] = /* VDIVSD */ { + { VEX_NDS_128_WIG(DIVSD), _r, _xmm, _xmm, _xmm_m64, }, + { ASM_END } +}; + +PTRNTAB2 aptb2DIVSS[] = /* DIVSS */ { + { DIVSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VDIVSS [] = /* VDIVSS */ { + { VEX_NDS_128_WIG(DIVSS), _r, _xmm, _xmm, _xmm_m32, }, + { ASM_END } +}; + +PTRNTAB2 aptb2MASKMOVDQU[] = /* MASKMOVDQU */ { + { MASKMOVDQU, _r,_xmm,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMASKMOVDQU[] = /* VMASKMOVDQU */ { + { VEX_128_WIG(MASKMOVDQU), _r, _xmm, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MASKMOVQ[] = /* MASKMOVQ */ { + { MASKMOVQ, _r,_mm,_mm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MAXPD[] = /* MAXPD */ { + { MAXPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMAXPD[] = /* VMAXPD */ { + { VEX_NDS_128_WIG(MAXPD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(MAXPD), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MAXPS[] = /* MAXPS */ { + { MAXPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMAXPS[] = /* VMAXPS */ { + { VEX_NDS_128_WIG(MAXPS), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(MAXPS), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MAXSD[] = /* MAXSD */ { + { MAXSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMAXSD[] = /* VMAXSD */ { + { VEX_NDS_128_WIG(MAXSD), _r, _xmm, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MAXSS[] = /* MAXSS */ { + { MAXSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMAXSS[] = /* VMAXSS */ { + { VEX_NDS_128_WIG(MAXSS), _r, _xmm, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MINPD[] = /* MINPD */ { + { MINPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMINPD[] = /* VMINPD */ { + { VEX_NDS_128_WIG(MINPD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(MINPD), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MINPS[] = /* MINPS */ { + { MINPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMINPS[] = /* VMINPS */ { + { VEX_NDS_128_WIG(MINPS), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(MINPS), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MINSD[] = /* MINSD */ { + { MINSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMINSD[] = /* VMINSD */ { + { VEX_NDS_128_WIG(MINSD), _r, _xmm, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MINSS[] = /* MINSS */ { + { MINSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMINSS[] = /* VMINSS */ { + { VEX_NDS_128_WIG(MINSS), _r, _xmm, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVAPD[] = /* MOVAPD */ { + { LODAPD, _r,_xmm,_xmm_m128 }, + { STOAPD, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVAPD[] = /* VMOVAPD */ { + { VEX_128_WIG(LODAPD), _r, _xmm, _xmm_m128 }, + { VEX_128_WIG(STOAPD), _r, _xmm_m128, _xmm }, + { VEX_256_WIG(LODAPD), _r, _ymm, _ymm_m256 }, + { VEX_256_WIG(STOAPD), _r, _ymm_m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVAPS[] = /* MOVAPS */ { + { LODAPS, _r,_xmm,_xmm_m128 }, + { STOAPS, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVAPS [] = /* VMOVAPS */ { + { VEX_128_WIG(LODAPS), _r, _xmm, _xmm_m128, }, + { VEX_128_WIG(STOAPS), _r, _xmm_m128, _xmm, }, + { VEX_256_WIG(LODAPS), _r, _ymm, _ymm_m256, }, + { VEX_256_WIG(STOAPS), _r, _ymm_m256, _ymm, }, + { ASM_END }, +}; + +PTRNTAB2 aptb2MOVDQA[] = /* MOVDQA */ { + { LODDQA, _r,_xmm,_xmm_m128 }, + { STODQA, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVDQA[] = /* VMOVDQA */ { + { VEX_128_WIG(LODDQA), _r, _xmm, _xmm_m128 }, + { VEX_128_WIG(STODQA), _r, _xmm_m128, _xmm }, + { VEX_256_WIG(LODDQA), _r, _ymm, _ymm_m256 }, + { VEX_256_WIG(STODQA), _r, _ymm_m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVDQU[] = /* MOVDQU */ { + { LODDQU, _r,_xmm,_xmm_m128 }, + { STODQU, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVDQU[] = /* VMOVDQU */ { + { VEX_128_WIG(LODDQU), _r, _xmm, _xmm_m128 }, + { VEX_128_WIG(STODQU), _r, _xmm_m128, _xmm }, + { VEX_256_WIG(LODDQU), _r, _ymm, _ymm_m256 }, + { VEX_256_WIG(STODQU), _r, _ymm_m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVDQ2Q[] = /* MOVDQ2Q */ { + { MOVDQ2Q, _r,_mm,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVHLPS[] = /* MOVHLPS */ { + { MOVHLPS, _r,_xmm,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVHLPS[] = /* VMOVHLPS */ { + { VEX_NDS_128_WIG(MOVHLPS), _r, _xmm, _xmm, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVHPD[] = /* MOVHPD */ { + { LODHPD, _r,_xmm,_xmm_m64 }, + { STOHPD, _r,_xmm_m64,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVHPD[] = /* VMOVHPD */ { + { VEX_NDS_128_WIG(LODHPD), _r, _xmm, _xmm, _m64 }, + { VEX_128_WIG(STOHPD), _r, _m64, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVHPS[] = /* MOVHPS */ { + { LODHPS, _r,_xmm,_xmm_m64 }, + { STOHPS, _r,_xmm_m64,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVHPS[] = /* VMOVHPS */ { + { VEX_NDS_128_WIG(LODHPS), _r, _xmm, _xmm, _m64 }, + { VEX_128_WIG(STOHPS), _r, _m64, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVLHPS[] = /* MOVLHPS */ { + { MOVLHPS, _r,_xmm,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVLHPS[] = /* VMOVLHPS */ { + { VEX_NDS_128_WIG(MOVLHPS), _r, _xmm, _xmm, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVLPD[] = /* MOVLPD */ { + { LODLPD, _r,_xmm,_xmm_m64 }, + { STOLPD, _r,_xmm_m64,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVLPD[] = /* VMOVLPD */ { + { VEX_NDS_128_WIG(LODLPD), _r, _xmm, _xmm, _m64 }, + { VEX_128_WIG(STOLPD), _r, _m64, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVLPS[] = /* MOVLPS */ { + { LODLPS, _r,_xmm,_xmm_m64 }, + { STOLPS, _r,_xmm_m64,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVLPS[] = /* VMOVLPS */ { + { VEX_NDS_128_WIG(LODLPS), _r, _xmm, _xmm, _m64 }, + { VEX_128_WIG(STOLPS), _r, _m64, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVMSKPD[] = /* MOVMSKPD */ { + { MOVMSKPD, _r,_r32,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVMSKPD [] = /* VMOVMSKPD */ { + { VEX_128_WIG(MOVMSKPD), _r, _r32, _xmm }, + { VEX_256_WIG(MOVMSKPD), _r, _r32, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVMSKPS[] = /* MOVMSKPS */ { + { MOVMSKPS, _r,_r32,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVMSKPS [] = /* VMOVMSKPS */ { + { VEX_128_WIG(MOVMSKPS), _r, _r32, _xmm }, + { VEX_256_WIG(MOVMSKPS), _r, _r32, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTDQ[] = /* MOVNTDQ */ { + { MOVNTDQ, _r,_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVNTDQ[] = /* VMOVNTDQ */ { + { VEX_128_WIG(MOVNTDQ), _r, _m128, _xmm }, + { VEX_256_WIG(MOVNTDQ), _r, _m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTI[] = /* MOVNTI */ { + { MOVNTI, _r,_m32,_r32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTPD[] = /* MOVNTPD */ { + { MOVNTPD, _r,_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVNTPD[] = /* VMOVNTPD */ { + { VEX_128_WIG(MOVNTPD), _r, _m128, _xmm }, + { VEX_256_WIG(MOVNTPD), _r, _m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTPS[] = /* MOVNTPS */ { + { MOVNTPS, _r,_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVNTPS[] = /* VMOVNTPS */ { + { VEX_128_WIG(MOVNTPS), _r, _m128, _xmm }, + { VEX_256_WIG(MOVNTPS), _r, _m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTQ[] = /* MOVNTQ */ { + { MOVNTQ, _r,_m64,_mm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVQ2DQ[] = /* MOVQ2DQ */ { + { MOVQ2DQ, _r,_xmm,_mm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVSD[] = /* MOVSD */ { + { 0xa5, _32_bit | _I386 | _modsidi }, + { LODSD, _r, _xmm, _xmm_m64 }, + { STOSD, _r, _xmm_m64, _xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVSD[] = /* VMOVSD */ { + { VEX_NDS_128_WIG(LODSD), _r, _xmm, _xmm, _xmm }, + { VEX_128_WIG(STOSD), _r, _m64, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVSS[] = /* MOVSS */ { + { LODSS, _r,_xmm,_xmm_m32 }, + { STOSS, _r,_xmm_m32,_xmm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMOVSS[] = /* VMOVSS */ { + { VEX_NDS_128_WIG(LODSS), _r, _xmm, _xmm, _xmm }, + { VEX_128_WIG(STOSS), _r, _m32, _xmm, 0 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVUPD[] = /* MOVUPD */ { + { LODUPD, _r,_xmm,_xmm_m128 }, + { STOUPD, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVUPD[] = /* VMOVUPD */ { + { VEX_128_WIG(LODUPD), _r, _xmm, _xmm_m128 }, + { VEX_128_WIG(STOUPD), _r, _xmm_m128, _xmm }, + { VEX_256_WIG(LODUPD), _r, _ymm, _ymm_m256 }, + { VEX_256_WIG(STOUPD), _r, _ymm_m256, _ymm }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVUPS[] = /* MOVUPS */ { + { LODUPS, _r,_xmm,_xmm_m128 }, + { STOUPS, _r,_xmm_m128,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVUPS [] = /* VMOVUPS */ { + { VEX_128_WIG(LODUPS), _r, _xmm, _xmm_m128, }, + { VEX_128_WIG(STOUPS), _r, _xmm_m128, _xmm, }, + { VEX_256_WIG(LODUPS), _r, _ymm, _ymm_m256, }, + { VEX_256_WIG(STOUPS), _r, _ymm_m256, _ymm, }, + { ASM_END } +}; + +PTRNTAB2 aptb2MULPD[] = /* MULPD */ { + { MULPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMULPD [] = /* VMULPD */ { + { VEX_NDS_128_WIG(MULPD), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(MULPD), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2MULPS[] = /* MULPS */ { + { MULPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMULPS [] = /* VMULPS */ { + { VEX_NDS_128_WIG(MULPS), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(MULPS), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2MULSD[] = /* MULSD */ { + { MULSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMULSD [] = /* VMULSD */ { + { VEX_NDS_128_WIG(MULSD), _r, _xmm, _xmm, _xmm_m64, }, + { ASM_END } +}; + +PTRNTAB2 aptb2MULSS[] = /* MULSS */ { + { MULSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMULSS [] = /* VMULSS */ { + { VEX_NDS_128_WIG(MULSS), _r, _xmm, _xmm, _xmm_m32, }, + { ASM_END } +}; + +PTRNTAB2 aptb2ORPD[] = /* ORPD */ { + { ORPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VORPD[] = /* VORPD */ { + { VEX_NDS_128_WIG(ORPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ORPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2ORPS[] = /* ORPS */ { + { ORPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VORPS[] = /* VORPS */ { + { VEX_NDS_128_WIG(ORPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(ORPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PADDQ[] = /* PADDQ */ { + { 0x0FD4, _r,_mm,_mmm64 }, + { PADDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPADDQ[] = /* VPADDQ */ { + { VEX_NDS_128_WIG(PADDQ), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PAVGB[] = /* PAVGB */ { + { 0x0FE0, _r,_mm,_mmm64 }, + { PAVGB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPAVGB[] = /* VPAVGB */ { + { VEX_NDS_128_WIG(PAVGB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PAVGW[] = /* PAVGW */ { + { 0x0FE3, _r,_mm,_mmm64 }, + { PAVGW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPAVGW[] = /* VPAVGW */ { + { VEX_NDS_128_WIG(PAVGW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PEXTRW[] = /* PEXTRW */ { + { 0x0FC5, _r,_r32,_mm,_imm8 }, + { 0x0FC5, _r,_r64,_mm,_imm8 }, + { 0x660FC5, _r,_r32,_xmm,_imm8 }, + { 0x660FC5, _r,_r64,_xmm,_imm8 }, + { 0x660F3A15, _r,_m16,_xmm,_imm8 }, // synonym for r32/r64 + { ASM_END } +}; + +PTRNTAB3 aptb3VPEXTRW[] = /* VPEXTRW */ { + { VEX_128_WIG(0x660FC5), _r,_r32,_xmm,_imm8 }, + { VEX_128_WIG(0x660FC5), _r,_r64,_xmm,_imm8 }, + { VEX_128_WIG(0x660F3A15), _r,_m16,_xmm,_imm8 }, // synonym for r32/r64 + { ASM_END } +}; + +PTRNTAB3 aptb3PINSRW[] = /* PINSRW */ { + { 0x0FC4, _r,_mm,_r32m16,_imm8 }, + { PINSRW, _r,_xmm,_r32m16,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPINSRW[] = /* VPINSRW */ { + { VEX_NDS_128_WIG(PINSRW), _r, _xmm, _xmm, _r32m16, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXSW[] = /* PMAXSW */ { + { 0x0FEE, _r,_mm,_mmm64 }, + { PMAXSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXSW[] = /* VPMAXSW */ { + { VEX_NDS_128_WIG(PMAXSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXUB[] = /* PMAXUB */ { + { 0x0FDE, _r,_mm,_mmm64 }, + { PMAXUB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXUB[] = /* VPMAXUB */ { + { VEX_NDS_128_WIG(PMAXUB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINSW[] = /* PMINSW */ { + { 0x0FEA, _r,_mm,_mmm64 }, + { PMINSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINSW[] = /* VPMINSW */ { + { VEX_NDS_128_WIG(PMINSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINUB[] = /* PMINUB */ { + { 0x0FDA, _r,_mm,_mmm64 }, + { PMINUB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINUB[] = /* VPMINUB */ { + { VEX_NDS_128_WIG(PMINUB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVMSKB[] = /* PMOVMSKB */ { + { 0x0FD7, _r,_r32,_mm }, + { PMOVMSKB, _r,_r32,_xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVMSKB[] = /* VPMOVMSKB */ { + { VEX_128_WIG(PMOVMSKB), _r, _r32, _xmm }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULHUW[] = /* PMULHUW */ { + { 0x0FE4, _r,_mm,_mmm64 }, + { PMULHUW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULHUW[] = /* VPMULHUW */ { + { VEX_NDS_128_WIG(PMULHUW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULHW[] = /* PMULHW */ { + { 0x0FE5, _r,_mm,_mmm64 }, + { PMULHW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULHW[] = /* VPMULHW */ { + { VEX_NDS_128_WIG(PMULHW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULLW[] = /* PMULLW */ { + { 0x0FD5, _r,_mm,_mmm64 }, + { PMULLW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULLW[] = /* VPMULLW */ { + { VEX_NDS_128_WIG(PMULLW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULUDQ[] = /* PMULUDQ */ { + { 0x0FF4, _r,_mm,_mmm64 }, + { PMULUDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULUDQ[] = /* VPMULUDQ */ { + { VEX_NDS_128_WIG(PMULUDQ), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2POR[] = /* POR */ { + { 0x0FEB, _r,_mm,_mmm64 }, + { POR, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPOR[] = /* VPOR */ { + { VEX_NDS_128_WIG(POR), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB1 aptb1PREFETCHNTA[] = /* PREFETCHNTA */ { + { PREFETCH, _0,_m8 }, + { ASM_END } +}; + +PTRNTAB1 aptb1PREFETCHT0[] = /* PREFETCHT0 */ { + { PREFETCH, _1,_m8 }, + { ASM_END } +}; + +PTRNTAB1 aptb1PREFETCHT1[] = /* PREFETCHT1 */ { + { PREFETCH, _2,_m8 }, + { ASM_END } +}; + +PTRNTAB1 aptb1PREFETCHT2[] = /* PREFETCHT2 */ { + { PREFETCH, _3,_m8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSADBW[] = /* PSADBW */ { + { 0x0FF6, _r,_mm,_mmm64 }, + { PSADBW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSADBW[] = /* VPSADBW */ { + { VEX_NDS_128_WIG(PSADBW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + + +PTRNTAB3 aptb3PSHUFD[] = /* PSHUFD */ { + { PSHUFD, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSHUFD[] = /* VPSHUFD */ { + { VEX_128_WIG(PSHUFD), _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PSHUFHW[] = /* PSHUFHW */ { + { PSHUFHW, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSHUFHW[] = /* VPSHUFHW */ { + { VEX_128_WIG(PSHUFHW), _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PSHUFLW[] = /* PSHUFLW */ { + { PSHUFLW, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSHUFLW[] = /* VPSHUFLW */ { + { VEX_128_WIG(PSHUFLW), _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PSHUFW[] = /* PSHUFW */ { + { PSHUFW, _r,_mm,_mmm64,_imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSLLDQ[] = /* PSLLDQ */ { + { PSLLDQ, _7,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSLLDQ[] = /* VPSLLDQ */ { + { VEX_NDD_128_WIG(PSLLDQ), _7, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSRLDQ[] = /* PSRLDQ */ { + { PSRLDQ, _3,_xmm,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSRLDQ[] = /* VPSRLDQ */ { + { VEX_NDD_128_WIG(PSRLDQ), _3, _xmm, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSUBQ[] = /* PSUBQ */ { + { 0x0FFB, _r,_mm,_mmm64 }, + { PSUBQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSUBQ[] = /* VPSUBQ */ { + { VEX_NDS_128_WIG(PSUBQ), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKHQDQ[] = /* PUNPCKHQDQ */ { + { PUNPCKHQDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKHQDQ[] = /* VPUNPCKHQDQ */ { + { VEX_NDS_128_WIG(PUNPCKHQDQ), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PUNPCKLQDQ[] = /* PUNPCKLQDQ */ { + { PUNPCKLQDQ, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPUNPCKLQDQ[] = /* VPUNPCKLQDQ */ { + { VEX_NDS_128_WIG(PUNPCKLQDQ), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2RCPPS[] = /* RCPPS */ { + { RCPPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VRCPPS[] = /* VRCPPS */ { + { VEX_128_WIG(RCPPS), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(RCPPS), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2RCPSS[] = /* RCPSS */ { + { RCPSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VRCPSS[] = /* VRCPSS */ { + { VEX_NDS_128_WIG(RCPSS), _r, _xmm, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2RSQRTPS[] = /* RSQRTPS */ { + { RSQRTPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2RSQRTSS[] = /* RSQRTSS */ { + { RSQRTSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3SHUFPD[] = /* SHUFPD */ { + { SHUFPD, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VSHUFPD[] = /* VSHUFPD */ { + { VEX_NDS_128_WIG(SHUFPD), _r,_xmm,_xmm,_xmm_m128,_imm8 }, + { VEX_NDS_256_WIG(SHUFPD), _r,_ymm,_ymm,_ymm_m256,_imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3SHUFPS[] = /* SHUFPS */ { + { SHUFPS, _r,_xmm,_xmm_m128,_imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VSHUFPS[] = /* VSHUFPS */ { + { VEX_NDS_128_WIG(SHUFPS), _r,_xmm,_xmm,_xmm_m128,_imm8 }, + { VEX_NDS_256_WIG(SHUFPS), _r,_ymm,_ymm,_ymm_m256,_imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2SQRTPD[] = /* SQRTPD */ { + { SQRTPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VSQRTPD[] = /* VSQRTPD */ { + { VEX_128_WIG(SQRTPD), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(SQRTPD), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2SQRTPS[] = /* SQRTPS */ { + { SQRTPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VSQRTPS[] = /* VSQRTPS */ { + { VEX_128_WIG(SQRTPS), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(SQRTPS), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2SQRTSD[] = /* SQRTSD */ { + { SQRTSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSQRTSD[] = /* VSQRTSD */ { + { VEX_NDS_128_WIG(SQRTSD), _r, _xmm, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2SQRTSS[] = /* SQRTSS */ { + { SQRTSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSQRTSS[] = /* VSQRTSS */ { + { VEX_NDS_128_WIG(SQRTSS), _r, _xmm, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2SUBPD[] = /* SUBPD */ { + { SUBPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSUBPD [] = /* VSUBPD */ { + { VEX_NDS_128_WIG(SUBPD), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(SUBPD), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2SUBPS[] = /* SUBPS */ { + { SUBPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSUBPS [] = /* VSUBPS */ { + { VEX_NDS_128_WIG(SUBPS), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(SUBPS), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2SUBSD[] = /* SUBSD */ { + { SUBSD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSUBSD[] = /* VSUBSD */ { + { VEX_NDS_128_WIG(SUBSD), _r, _xmm, _xmm, _xmm_m64, }, + { ASM_END } +}; + +PTRNTAB2 aptb2SUBSS[] = /* SUBSS */ { + { SUBSS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VSUBSS[] = /* VSUBSS */ { + { VEX_NDS_128_WIG(SUBSS), _r, _xmm, _xmm, _xmm_m32, }, + { ASM_END } +}; + +PTRNTAB2 aptb2UCOMISD[] = /* UCOMISD */ { + { UCOMISD, _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VUCOMISD[] = /* VUCOMISD */ { + { VEX_128_WIG(UCOMISD), _r,_xmm,_xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2UCOMISS[] = /* UCOMISS */ { + { UCOMISS, _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VUCOMISS[] = /* VUCOMISS */ { + { VEX_128_WIG(UCOMISS), _r,_xmm,_xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2UNPCKHPD[] = /* UNPCKHPD */ { + { UNPCKHPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VUNPCKHPD[] = /* VUNPCKHPD */ { + { VEX_NDS_128_WIG(UNPCKHPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(UNPCKHPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2UNPCKHPS[] = /* UNPCKHPS */ { + { UNPCKHPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VUNPCKHPS[] = /* VUNPCKHPS */ { + { VEX_NDS_128_WIG(UNPCKHPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(UNPCKHPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2UNPCKLPD[] = /* UNPCKLPD */ { + { UNPCKLPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VUNPCKLPD[] = /* VUNPCKLPD */ { + { VEX_NDS_128_WIG(UNPCKLPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(UNPCKLPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2UNPCKLPS[] = /* UNPCKLPS */ { + { UNPCKLPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VUNPCKLPS[] = /* VUNPCKLPS */ { + { VEX_NDS_128_WIG(UNPCKLPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(UNPCKLPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2XORPD[] = /* XORPD */ { + { XORPD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VXORPD[] = /* VXORPD */ { + { VEX_NDS_128_WIG(XORPD), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(XORPD), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2XORPS[] = /* XORPS */ { + { XORPS, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VXORPS[] = /* VXORPS */ { + { VEX_NDS_128_WIG(XORPS), _r,_xmm,_xmm,_xmm_m128 }, + { VEX_NDS_256_WIG(XORPS), _r,_ymm,_ymm,_ymm_m256 }, + { ASM_END } +}; + +/**** AMD only instructions ****/ + +/* + pavgusb + pf2id + pfacc + pfadd + pfcmpeq + pfcmpge + pfcmpgt + pfmax + pfmin + pfmul + pfnacc + pfpnacc + pfrcp + pfrcpit1 + pfrcpit2 + pfrsqit1 + pfrsqrt + pfsub + pfsubr + pi2fd + pmulhrw + pswapd +*/ + +PTRNTAB2 aptb2PAVGUSB[] = /* PAVGUSB */ { + { 0x0F0FBF, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PF2ID[] = /* PF2ID */ { + { 0x0F0F1D, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFACC[] = /* PFACC */ { + { 0x0F0FAE, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFADD[] = /* PFADD */ { + { 0x0F0F9E, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFCMPEQ[] = /* PFCMPEQ */ { + { 0x0F0FB0, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFCMPGE[] = /* PFCMPGE */ { + { 0x0F0F90, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFCMPGT[] = /* PFCMPGT */ { + { 0x0F0FA0, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFMAX[] = /* PFMAX */ { + { 0x0F0FA4, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFMIN[] = /* PFMIN */ { + { 0x0F0F94, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFMUL[] = /* PFMUL */ { + { 0x0F0FB4, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFNACC[] = /* PFNACC */ { + { 0x0F0F8A, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFPNACC[] = /* PFPNACC */ { + { 0x0F0F8E, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFRCP[] = /* PFRCP */ { + { 0x0F0F96, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFRCPIT1[] = /* PFRCPIT1 */ { + { 0x0F0FA6, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFRCPIT2[] = /* PFRCPIT2 */ { + { 0x0F0FB6, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFRSQIT1[] = /* PFRSQIT1 */ { + { 0x0F0FA7, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFRSQRT[] = /* PFRSQRT */ { + { 0x0F0F97, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFSUB[] = /* PFSUB */ { + { 0x0F0F9A, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PFSUBR[] = /* PFSUBR */ { + { 0x0F0FAA, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PI2FD[] = /* PI2FD */ { + { 0x0F0F0D, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULHRW[] = /* PMULHRW */ { + { 0x0F0FB7, _r,_mm,_mmm64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSWAPD[] = /* PSWAPD */ { + { 0x0F0FBB, _r,_mm,_mmm64 }, + { ASM_END } +}; + +/* ======================= Pentium 4 (Prescott) ======================= */ + +/* + ADDSUBPD + ADDSUBPS + FISTTP + HADDPD + HADDPS + HSUBPD + HSUBPS + LDDQU + MONITOR + MOVDDUP + MOVSHDUP + MOVSLDUP + MWAIT + */ + +PTRNTAB1 aptb1FISTTP[] = /* FISTTP */ { + { 0xdf, _1, _m16 }, + { 0xdb, _1, _m32 }, + { 0xdd, _1, _fm64 }, + { ASM_END } +}; + +PTRNTAB0 aptb0MONITOR[] = /* MONITOR */ { + { MONITOR, 0 } +}; + +PTRNTAB0 aptb0MWAIT[] = /* MWAIT */ { + { MWAIT, 0 } +}; + +PTRNTAB2 aptb2ADDSUBPD[] = /* ADDSUBPD */ { + { ADDSUBPD, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB3 aptb3VADDSUBPD[] = /* VADDSUBPD */ { + { VEX_NDS_128_WIG(ADDSUBPD), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(ADDSUBPD), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2ADDSUBPS[] = /* ADDSUBPS */ { + { ADDSUBPS, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB3 aptb3VADDSUBPS[] = /* VADDSUBPS */ { + { VEX_NDS_128_WIG(ADDSUBPS), _r, _xmm, _xmm, _xmm_m128, }, + { VEX_NDS_256_WIG(ADDSUBPS), _r, _ymm, _ymm, _ymm_m256, }, + { ASM_END } +}; + +PTRNTAB2 aptb2HADDPD[] = /* HADDPD */ { + { HADDPD, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB3 aptb3VHADDPD[] = /* VHADDPD */ { + { VEX_NDS_128_WIG(HADDPD), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(HADDPD), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2HADDPS[] = /* HADDPS */ { + { HADDPS, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB3 aptb3VHADDPS[] = /* VHADDPS */ { + { VEX_NDS_128_WIG(HADDPS), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(HADDPS), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2HSUBPD[] = /* HSUBPD */ { + { HSUBPD, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB2 aptb2HSUBPS[] = /* HSUBPS */ { + { HSUBPS, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB2 aptb2LDDQU[] = /* LDDQU */ { + { LDDQU, _r,_xmm,_m128 }, // xmm1,mem + { ASM_END } +}; + +PTRNTAB2 aptb2VLDDQU[] = /* VLDDQU */ { + { VEX_128_WIG(LDDQU), _r, _xmm, _m128 }, + { VEX_256_WIG(LDDQU), _r, _ymm, _m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVDDUP[] = /* MOVDDUP */ { + { MOVDDUP, _r,_xmm,_xmm_m64 }, // xmm1,xmm2/m64 + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVDDUP[] = /* VMOVDDUP */ { + { VEX_128_WIG(MOVDDUP), _r,_xmm,_xmm_m64 }, + { VEX_256_WIG(MOVDDUP), _r,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVSHDUP[] = /* MOVSHDUP */ { + { MOVSHDUP, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVSHDUP[] = /* VMOVSHDUP */ { + { VEX_128_WIG(MOVSHDUP), _r,_xmm,_xmm_m128 }, + { VEX_256_WIG(MOVSHDUP), _r,_ymm,_ymm_m256 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVSLDUP[] = /* MOVSLDUP */ { + { MOVSLDUP, _r,_xmm,_xmm_m128 }, // xmm1,xmm2/m128 + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVSLDUP[] = /* VMOVSLDUP */ { + { VEX_128_WIG(MOVSLDUP), _r,_xmm,_xmm_m128 }, + { VEX_256_WIG(MOVSLDUP), _r,_ymm,_ymm_m256 }, + { ASM_END } +}; + +/* ======================= SSSE3 ======================= */ + +/* +palignr +phaddd +phaddw +phaddsw +phsubd +phsubw +phsubsw +pmaddubsw +pmulhrsw +pshufb +pabsb +pabsd +pabsw +psignb +psignd +psignw +*/ + +PTRNTAB3 aptb3PALIGNR[] = /* PALIGNR */ { + { 0x0F3A0F, _r,_mm,_mmm64, _imm8 }, + { PALIGNR, _r,_xmm,_xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPALIGNR[] = /* VPALIGNR */ { + { VEX_NDS_128_WIG(PALIGNR), _r,_xmm,_xmm,_xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHADDD[] = /* PHADDD */ { + { 0x0F3802, _r,_mm,_mmm64 }, + { PHADDD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHADDD[] = /* VPHADDD */ { + { VEX_NDS_128_WIG(PHADDD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHADDW[] = /* PHADDW */ { + { 0x0F3801, _r,_mm,_mmm64 }, + { PHADDW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHADDW[] = /* VPHADDW */ { + { VEX_NDS_128_WIG(PHADDW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHADDSW[] = /* PHADDSW */ { + { 0x0F3803, _r,_mm,_mmm64 }, + { PHADDSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHADDSW[] = /* VPHADDSW */ { + { VEX_NDS_128_WIG(PHADDSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHSUBD[] = /* PHSUBD */ { + { 0x0F3806, _r,_mm,_mmm64 }, + { PHSUBD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHSUBD[] = /* VPHSUBD */ { + { VEX_NDS_128_WIG(PHSUBD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHSUBW[] = /* PHSUBW */ { + { 0x0F3805, _r,_mm,_mmm64 }, + { PHSUBW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHSUBW[] = /* VPHSUBW */ { + { VEX_NDS_128_WIG(PHSUBW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHSUBSW[] = /* PHSUBSW */ { + { 0x0F3807, _r,_mm,_mmm64 }, + { PHSUBSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPHSUBSW[] = /* VPHSUBSW */ { + { VEX_NDS_128_WIG(PHSUBSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMADDUBSW[] = /* PMADDUBSW */ { + { 0x0F3804, _r,_mm,_mmm64 }, + { PMADDUBSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMADDUBSW[] = /* VPMADDUBSW */ { + { VEX_NDS_128_WIG(PMADDUBSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULHRSW[] = /* PMULHRSW */ { + { 0x0F380B, _r,_mm,_mmm64 }, + { PMULHRSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULHRSW[] = /* VPMULHRSW */ { + { VEX_NDS_128_WIG(PMULHRSW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSHUFB[] = /* PSHUFB */ { + { 0x0F3800, _r,_mm,_mmm64 }, + { PSHUFB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSHUFB[] = /* VPSHUFB */ { + { VEX_NDS_128_WIG(PSHUFB), _r,_xmm,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PABSB[] = /* PABSB */ { + { 0x0F381C, _r,_mm,_mmm64 }, + { PABSB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPABSB [] = /* VPABSB */ { + { VEX_128_WIG(PABSB), _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + + +PTRNTAB2 aptb2PABSD[] = /* PABSD */ { + { 0x0F381E, _r,_mm,_mmm64 }, + { PABSD, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPABSD [] = /* VPABSD */ { + { VEX_128_WIG(PABSD), _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PABSW[] = /* PABSW */ { + { 0x0F381D, _r,_mm,_mmm64 }, + { PABSW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPABSW [] = /* VPABSW */ { + { VEX_128_WIG(PABSW), _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSIGNB[] = /* PSIGNB */ { + { 0x0F3808, _r,_mm,_mmm64 }, + { PSIGNB, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSIGNB[] = /* VPSIGNB */ { + { VEX_NDS_128_WIG(PSIGNB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSIGND[] = /* PSIGND */ { + { 0x0F380A, _r,_mm,_mmm64 }, + { PSIGND, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSIGND[] = /* VPSIGND */ { + { VEX_NDS_128_WIG(PSIGND), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PSIGNW[] = /* PSIGNW */ { + { 0x0F3809, _r,_mm,_mmm64 }, + { PSIGNW, _r,_xmm,_xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPSIGNW[] = /* VPSIGNW */ { + { VEX_NDS_128_WIG(PSIGNW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +/* ======================= SSE4.1 ======================= */ + +/* +blendpd +blendps +blendvpd +blendvps +dppd +dpps +extractps +insertps +movntdqa +mpsadbw +packusdw +pblendvb +pblendw +pcmpeqq +pextrb +pextrd +pextrq +pextrw +phminposuw +pinsrb +pinsrd +pinsrq +pmaxsb +pmaxsd +pmaxud +pmaxuw +pminsb +pminsd +pminud +pminuw +pmovsxbd +pmovsxbq +pmovsxbw +pmovsxwd +pmovsxwq +pmovsxdq +pmovzxbd +pmovzxbq +pmovzxbw +pmovzxwd +pmovzxwq +pmovzxdq +pmuldq +pmulld +ptest +roundpd +roundps +roundsd +roundss + */ + +PTRNTAB3 aptb3BLENDPD[] = /* BLENDPD */ { + { BLENDPD, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VBLENDPD[] = /* VBLENDPD */ { + { VEX_NDS_128_WIG(BLENDPD), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(BLENDPD), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3BLENDPS[] = /* BLENDPS */ { + { BLENDPS, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VBLENDPS[] = /* VBLENDPS */ { + { VEX_NDS_128_WIG(BLENDPS), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(BLENDPS), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3BLENDVPD[] = /* BLENDVPD */ { + { BLENDVPD, _r, _xmm, _xmm_m128, _xmm0 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VBLENDVPD[] = /* VBLENDVPD */ { + { VEX_NDS_128_WIG(0x660F3A4B), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(0x660F3A4B), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3BLENDVPS[] = /* BLENDVPS */ { + { BLENDVPS, _r, _xmm, _xmm_m128, _xmm0 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VBLENDVPS[] = /* VBLENDVPS */ { + { VEX_NDS_128_WIG(0x660F3A4A), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(0x660F3A4A), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3DPPD[] = /* DPPD */ { + { DPPD, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VDPPD[] = /* VDPPD */ { + { VEX_NDS_128_WIG(DPPD), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3DPPS[] = /* DPPS */ { + { DPPS, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VDPPS[] = /* VDPPS */ { + { VEX_NDS_128_WIG(DPPS), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { VEX_NDS_256_WIG(DPPS), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3EXTRACTPS[] = /* EXTRACTPS */ { + { EXTRACTPS, _r, _rm32, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VEXTRACTPS[] = /* VEXTRACTPS */ { + { VEX_128_WIG(EXTRACTPS), _r, _rm32, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3INSERTPS[] = /* INSERTPS */ { + { INSERTPS, _r, _xmm, _xmm_m32, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VINSERTPS[] = /* VINSERTPS */ { + { VEX_NDS_128_WIG(INSERTPS), _r, _xmm, _xmm, _xmm_m32, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2MOVNTDQA[] = /* MOVNTDQA */ { + { MOVNTDQA, _r, _xmm, _m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VMOVNTDQA[] = /* VMOVNTDQA */ { + { VEX_128_WIG(MOVNTDQA), _r, _xmm, _m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3MPSADBW[] = /* MPSADBW */ { + { MPSADBW, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VMPSADBW [] = /* VMPSADBW */ { + { VEX_NDS_128_WIG(MPSADBW), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PACKUSDW[] = /* PACKUSDW */ { + { PACKUSDW, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPACKUSDW[] = /* VPACKUSDW */ { + { VEX_NDS_128_WIG(PACKUSDW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PBLENDVB[] = /* PBLENDVB */ { + { PBLENDVB, _r, _xmm, _xmm_m128, _xmm0 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPBLENDVB[] = /* VPBLENDVB */ { + { VEX_NDS_128_WIG(0x660F3A4C), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PBLENDW[] = /* PBLENDW */ { + { PBLENDW, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPBLENDW[] = /* VPBLENDW */ { + { VEX_NDS_128_WIG(PBLENDW), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPEQQ[] = /* PCMPEQQ */ { + { PCMPEQQ, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPEQQ[] = /* VPCMPEQQ */ { + { VEX_NDS_128_WIG(PCMPEQQ), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PEXTRB[] = /* PEXTRB */ { + { PEXTRB, _r, _regm8, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPEXTRB[] = /* VPEXTRB */ { + { VEX_128_WIG(PEXTRB), _r, _regm8, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PEXTRD[] = /* PEXTRD */ { + { PEXTRD, _r, _rm32, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPEXTRD[] = /* VPEXTRD */ { + { VEX_128_WIG(PEXTRD), _r, _rm32, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PEXTRQ[] = /* PEXTRQ */ { + { PEXTRQ, _r|_64_bit, _rm64, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPEXTRQ[] = /* VPEXTRQ */ { + { VEX_128_W1(PEXTRD), _r, _rm64, _xmm, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PHMINPOSUW[] = /* PHMINPOSUW */ { + { PHMINPOSUW, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPHMINPOSUW[] = /* VPHMINPOSUW */ { + { VEX_128_WIG(PHMINPOSUW), _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PINSRB[] = /* PINSRB */ { + { PINSRB, _r, _xmm, _r32, _imm8 }, + { PINSRB, _r, _xmm, _rm8, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPINSRB[] = /* VPINSRB */ { + { VEX_NDS_128_WIG(PINSRB), _r, _xmm, _xmm, _r32m8, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PINSRD[] = /* PINSRD */ { + { PINSRD, _r, _xmm, _rm32, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPINSRD[] = /* VPINSRD */ { + { VEX_NDS_128_WIG(PINSRD), _r, _xmm, _xmm, _rm32, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PINSRQ[] = /* PINSRQ */ { + { PINSRQ, _r|_64_bit, _xmm, _rm64, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPINSRQ[] = /* VPINSRQ */ { + { VEX_NDS_128_W1(PINSRD), _r, _xmm, _xmm, _rm64, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXSB[] = /* PMAXSB */ { + { PMAXSB, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXSB[] = /* VPMAXSB */ { + { VEX_NDS_128_WIG(PMAXSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXSD[] = /* PMAXSD */ { + { PMAXSD, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXSD[] = /* VPMAXSD */ { + { VEX_NDS_128_WIG(PMAXSD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXUD[] = /* PMAXUD */ { + { PMAXUD, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXUD[] = /* VPMAXUD */ { + { VEX_NDS_128_WIG(PMAXUD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMAXUW[] = /* PMAXUW */ { + { PMAXUW, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMAXUW[] = /* VPMAXUW */ { + { VEX_NDS_128_WIG(PMAXUW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINSB[] = /* PMINSB */ { + { PMINSB, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINSB[] = /* VPMINSB */ { + { VEX_NDS_128_WIG(PMINSB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINSD[] = /* PMINSD */ { + { PMINSD, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINSD[] = /* VPMINSD */ { + { VEX_NDS_128_WIG(PMINSD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINUD[] = /* PMINUD */ { + { PMINUD, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINUD[] = /* VPMINUD */ { + { VEX_NDS_128_WIG(PMINUD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMINUW[] = /* PMINUW */ { + { PMINUW, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMINUW[] = /* VPMINUW */ { + { VEX_NDS_128_WIG(PMINUW), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXBW[] = /* PMOVSXBW */ { + { PMOVSXBW, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXBW[] = /* VPMOVSXBW */ { + { VEX_128_WIG(PMOVSXBW), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXBD[] = /* PMOVSXBD */ { + { PMOVSXBD, _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXBD[] = /* VPMOVSXBD */ { + { VEX_128_WIG(PMOVSXBD), _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXBQ[] = /* PMOVSXBQ */ { + { PMOVSXBQ, _r, _xmm, _xmm_m16 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXBQ[] = /* VPMOVSXBQ */ { + { VEX_128_WIG(PMOVSXBQ), _r, _xmm, _xmm_m16 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXWD[] = /* PMOVSXWD */ { + { PMOVSXWD, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXWD[] = /* VPMOVSXWD */ { + { VEX_128_WIG(PMOVSXWD), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXWQ[] = /* PMOVSXWQ */ { + { PMOVSXWQ, _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXWQ[] = /* VPMOVSXWQ */ { + { VEX_128_WIG(PMOVSXWQ), _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVSXDQ[] = /* PMOVSXDQ */ { + { PMOVSXDQ, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVSXDQ[] = /* VPMOVSXDQ */ { + { VEX_128_WIG(PMOVSXDQ), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXBW[] = /* PMOVZXBW */ { + { PMOVZXBW, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXBW[] = /* VPMOVZXBW */ { + { VEX_128_WIG(PMOVZXBW), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXBD[] = /* PMOVZXBD */ { + { PMOVZXBD, _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXBD[] = /* VPMOVZXBD */ { + { VEX_128_WIG(PMOVZXBD), _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXBQ[] = /* PMOVZXBQ */ { + { PMOVZXBQ, _r, _xmm, _xmm_m16 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXBQ[] = /* VPMOVZXBQ */ { + { VEX_128_WIG(PMOVZXBQ), _r, _xmm, _xmm_m16 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXWD[] = /* PMOVZXWD */ { + { PMOVZXWD, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXWD[] = /* VPMOVZXWD */ { + { VEX_128_WIG(PMOVZXWD), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXWQ[] = /* PMOVZXWQ */ { + { PMOVZXWQ, _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXWQ[] = /* VPMOVZXWQ */ { + { VEX_128_WIG(PMOVZXWQ), _r, _xmm, _xmm_m32 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMOVZXDQ[] = /* PMOVZXDQ */ { + { PMOVZXDQ, _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPMOVZXDQ[] = /* VPMOVZXDQ */ { + { VEX_128_WIG(PMOVZXDQ), _r, _xmm, _xmm_m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULDQ[] = /* PMULDQ */ { + { PMULDQ, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PMULLD[] = /* PMULLD */ { + { PMULLD, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPMULLD[] = /* VPMULLD */ { + { VEX_NDS_128_WIG(PMULLD), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PTEST[] = /* PTEST */ { + { PTEST, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VPTEST[] = /* VPTEST */ { + { VEX_128_WIG(PTEST), _r, _xmm, _xmm_m128 }, + { VEX_256_WIG(PTEST), _r, _ymm, _ymm_m256 }, + { ASM_END } +}; + +PTRNTAB3 aptb3ROUNDPD[] = /* ROUNDPD */ { + { ROUNDPD, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VROUNDPD[] = /* VROUNDPD */ { + { VEX_128_WIG(ROUNDPD), _r, _xmm, _xmm_m128, _imm8 }, + { VEX_256_WIG(ROUNDPD), _r, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3ROUNDPS[] = /* ROUNDPS */ { + { ROUNDPS, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VROUNDPS[] = /* VROUNDPS */ { + { VEX_128_WIG(ROUNDPS), _r, _xmm, _xmm_m128, _imm8 }, + { VEX_256_WIG(ROUNDPS), _r, _ymm, _ymm_m256, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3ROUNDSD[] = /* ROUNDSD */ { + { ROUNDSD, _r, _xmm, _xmm_m64, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VROUNDSD[] = /* VROUNDSD */ { + { VEX_NDS_128_WIG(ROUNDSD), _r, _xmm, _xmm, _xmm_m64, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3ROUNDSS[] = /* ROUNDSS */ { + { ROUNDSS, _r, _xmm, _xmm_m32, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VROUNDSS[] = /* VROUNDSS */ { + { VEX_NDS_128_WIG(ROUNDSS), _r, _xmm, _xmm, _xmm_m32, _imm8 }, + { ASM_END } +}; + +/* ======================= SSE4.2 ======================= */ + +/* +crc32 +pcmpestri +pcmpestrm +pcmpistri +pcmpistrm +pcmpgtq +popcnt + */ + +PTRNTAB2 aptb2CRC32[] = /* CRC32 */ { + { 0xF20F38F0, _r , _r32, _rm8 }, + { 0xF20F38F0, _r|_64_bit, _r64, _rm8 }, + { 0xF20F38F1, _r|_16_bit, _r32, _rm16 }, + { 0xF20F38F1, _r|_32_bit, _r32, _rm32 }, + { 0xF20F38F1, _r|_64_bit, _r64, _rm64 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PCMPESTRI [] = /* PCMPESTRI */ { + { PCMPESTRI, _r|_modcx , _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPESTRI[] = /* VPCMPESTRI */ { + { VEX_128_WIG(PCMPESTRI), _r|_modcx, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PCMPESTRM[] = /* PCMPESTRM */ { + { PCMPESTRM, _r|_modxmm0, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPESTRM[] = /* VPCMPESTRM */ { + { VEX_128_WIG(PCMPESTRM), _r|_modxmm0, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PCMPISTRI [] = /* PCMPISTRI */ { + { PCMPISTRI, _r|_modcx , _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPISTRI[] = /* VPCMPISTRI */ { + { VEX_128_WIG(PCMPISTRI), _r|_modcx, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3PCMPISTRM [] = /* PCMPISTRM */ { + { PCMPISTRM, _r|_modxmm0, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPISTRM[] = /* VPCMPISTRM */ { + { VEX_128_WIG(PCMPISTRM), _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB2 aptb2PCMPGTQ [] = /* PCMPGTQ */ { + { PCMPGTQ, _r, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VPCMPGTQ[] = /* VPCMPGTQ */ { + { VEX_NDS_128_WIG(PCMPGTQ), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2POPCNT [] = /* POPCNT */ { + { POPCNT, _r|_16_bit, _r16, _rm16 }, + { POPCNT, _r|_32_bit, _r32, _rm32 }, + { POPCNT, _r|_64_bit, _r64, _rm64 }, + { ASM_END } +}; + +/* ======================= VMS ======================= */ + +/* +invept +invvpid +vmcall +vmclear +vmlaunch +vmresume +vmptrld +vmptrst +vmread +vmwrite +vmxoff +vmxon + */ + +/* ======================= SMX ======================= */ + +/* +getsec + */ + +/* ======================= CLMUL ======================= */ + +PTRNTAB3 aptb3PCLMULQDQ[] = /* PCLMULQDQ */ { + { 0x660F3A44, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VPCLMULQDQ[] = /* VPCLMULQDQ */ { + { VEX_NDS_128_WIG(0x660F3A44), _r, _xmm, _xmm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +/* ======================= AVX ======================= */ + +PTRNTAB2 aptb2VBROADCASTF128[] = /* VBROADCASTF128 */ { + { VEX_256_WIG(0x660F381A), _r, _ymm, _m128 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VBROADCASTSD[] = /* VBROADCASTSD */ { + { VEX_256_WIG(0x660F3819), _r, _ymm, _m64 }, + { ASM_END } +}; + +PTRNTAB2 aptb2VBROADCASTSS[] = /* VBROADCASTSS */ { + { VEX_128_WIG(0x660F3818), _r, _xmm, _m32 }, + { VEX_256_WIG(0x660F3818), _r, _ymm, _m32 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VEXTRACTF128[] = /* VEXTRACTF128 */ { + { VEX_256_WIG(0x660F3A19), _r, _xmm_m128, _ymm, _imm8 }, + { ASM_END } +}; + +PTRNTAB4 aptb4VINSERTF128[] = /* VINSERTF128 */ { + { VEX_NDS_256_WIG(0x660F3A18), _r, _ymm, _ymm, _xmm_m128, _imm8 }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMASKMOVPS[] = /* VMASKMOVPS */ { + { VEX_NDS_128_WIG(0x660F382C), _r, _xmm, _xmm, _m128 }, + { VEX_NDS_256_WIG(0x660F382C), _r, _ymm, _ymm, _m256 }, + { VEX_NDS_128_WIG(0x660F382E), _r, _m128, _xmm, _xmm }, + { VEX_NDS_256_WIG(0x660F382E), _r, _m256, _ymm, _ymm }, + { ASM_END } +}; + +PTRNTAB3 aptb3VMASKMOVPD[] = /* VMASKMOVPD */ { + { VEX_NDS_128_WIG(0x660F382D), _r, _xmm, _xmm, _m128 }, + { VEX_NDS_256_WIG(0x660F382D), _r, _ymm, _ymm, _m256 }, + { VEX_NDS_128_WIG(0x660F382F), _r, _m128, _xmm, _xmm }, + { VEX_NDS_256_WIG(0x660F382F), _r, _m256, _ymm, _ymm }, + { ASM_END } +}; + +PTRNTAB0 aptb0VZEROALL[] = /* VZEROALL */ { + { VEX_256_WIG(0x0F77), _modall }, // FIXME: need _modxmm + { ASM_END }, +}; + +PTRNTAB0 aptb0VZEROUPPER[] = /* VZEROUPPER */ { + { VEX_128_WIG(0x0F77), _modall }, // FIXME: need _modxmm + { ASM_END }, +}; + +PTRNTAB0 aptb0XGETBV[] = /* XGETBV */ { + { XGETBV, _modaxdx }, + { ASM_END }, +}; + +PTRNTAB1 aptb1XRSTOR[] = /* XRSTOR */ { + { 0x0FAE, _5, _m512 }, + { ASM_END } +}; + +PTRNTAB1 aptb1XRSTOR64[] = /* XRSTOR64 */ { + { 0x0FAE, _5|_64_bit, _m512 }, // TODO: REX_W override is implicit + { ASM_END } +}; + +PTRNTAB1 aptb1XSAVE[] = /* XSAVE */ { + { 0x0FAE, _4, _m512 }, + { ASM_END } +}; + +PTRNTAB1 aptb1XSAVE64[] = /* XSAVE64 */ { + { 0x0FAE, _4|_64_bit, _m512 }, // TODO: REX_W override is implicit + { ASM_END } +}; + +PTRNTAB1 aptb1XSAVEOPT[] = /* XSAVEOPT */ { + { 0x0FAE, _6, _m512 }, + { ASM_END } +}; + +PTRNTAB1 aptb1XSAVEOPT64[] = /* XSAVEOPT64 */ { + { 0x0FAE, _6|_64_bit, _m512 }, // TODO: REX_W override is implicit + { ASM_END } +}; + +PTRNTAB0 aptb0XSETBV[] = /* XSETBV */ { + { XSETBV, 0 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VPERMILPD[] = /* VPERMILPD */ { + { VEX_NDS_128_WIG(0x660F380D), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(0x660F380D), _r, _ymm, _ymm, _ymm_m256 }, + { VEX_128_WIG(0x660F3A05), _r, _xmm, _xmm_m128, _imm8 }, + { VEX_256_WIG(0x660F3A05), _r, _ymm, _ymm_m256, _imm8 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VPERMILPS[] = /* VPERMILPS */ { + { VEX_NDS_128_WIG(0x660F380C), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_NDS_256_WIG(0x660F380C), _r, _ymm, _ymm, _ymm_m256 }, + { VEX_128_WIG(0x660F3A04), _r, _xmm, _xmm_m128, _imm8 }, + { VEX_256_WIG(0x660F3A04), _r, _ymm, _ymm_m256, _imm8 }, + { ASM_END }, +}; + +PTRNTAB4 aptb3VPERM2F128[] = /* VPERM2F128 */ { + { VEX_NDS_256_WIG(0x660F3A06), _r, _ymm, _ymm, _ymm_m256, _imm8 }, + { ASM_END }, +}; + +/* ======================= AES ======================= */ + +PTRNTAB2 aptb2AESENC[] = /* AESENC */ { + { AESENC, _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VAESENC[] = /* VAESENC */ { + { VEX_NDS_128_WIG(AESENC), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB2 aptb2AESENCLAST[] = /* AESENCLAST */ { + { AESENCLAST, _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VAESENCLAST[] = /* VAESENCLAST */ { + { VEX_NDS_128_WIG(AESENCLAST), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB2 aptb2AESDEC[] = /* AESDEC */ { + { AESDEC, _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VAESDEC[] = /* VAESDEC */ { + { VEX_NDS_128_WIG(AESDEC), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB2 aptb2AESDECLAST[] = /* AESDECLAST */ { + { AESDECLAST, _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VAESDECLAST[] = /* VAESDECLAST */ { + { VEX_NDS_128_WIG(AESDECLAST), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB2 aptb2AESIMC[] = /* AESIMC */ { + { AESIMC, _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB2 aptb2VAESIMC[] = /* VAESIMC */ { + { VEX_128_WIG(AESIMC), _r, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3AESKEYGENASSIST[] = /* AESKEYGENASSIST */ { + { AESKEYGENASSIST, _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VAESKEYGENASSIST[] = /* VAESKEYGENASSIST */ { + { VEX_128_WIG(AESKEYGENASSIST), _r, _xmm, _xmm_m128, _imm8 }, + { ASM_END }, +}; + +/* ======================= FSGSBASE ======================= */ + +PTRNTAB1 aptb1RDFSBASE[] = /* RDFSBASE */ { + { 0xF30FAE, _0, _r32 }, + { 0xF30FAE, _0|_64_bit, _r64 }, + { ASM_END }, +}; + +PTRNTAB1 aptb1RDGSBASE[] = /* RDGSBASE */ { + { 0xF30FAE, _1, _r32 }, + { 0xF30FAE, _1|_64_bit, _r64 }, + { ASM_END }, +}; + +PTRNTAB1 aptb1WRFSBASE[] = /* WRFSBASE */ { + { 0xF30FAE, _2, _r32 }, + { 0xF30FAE, _2|_64_bit, _r64 }, + { ASM_END }, +}; + +PTRNTAB1 aptb1WRGSBASE[] = /* WRGSBASE */ { + { 0xF30FAE, _3, _r32 }, + { 0xF30FAE, _3|_64_bit, _r64 }, + { ASM_END }, +}; + +/* ======================= RDRAND ======================= */ + +PTRNTAB1 aptb1RDRAND[] = /* RDRAND */ { + { 0x0FC7, _6|_16_bit, _r16 }, + { 0x0FC7, _6|_32_bit, _r32 }, + { 0x0FC7, _6|_64_bit, _r64 }, + { ASM_END }, +}; + +/* ======================= FP16C ======================= */ + +PTRNTAB2 aptb2VCVTPH2PS[] = /* VCVTPH2PS */ { + { VEX_128_WIG(0x660F3813), _r, _xmm, _xmm_m64 }, + { VEX_256_WIG(0x660F3813), _r, _ymm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VCVTPS2PH[] = /* VCVTPS2PH */ { + { VEX_128_WIG(0x660F3A13), _r, _xmm_m64, _xmm, _imm8 }, + { VEX_256_WIG(0x660F3A13), _r, _xmm_m128, _ymm, _imm8 }, + { ASM_END }, +}; + +/* ======================= FMA ======================= */ + +PTRNTAB3 aptb3VFMADD132PD[] = /* VFMADD132PD */ { + { VEX_DDS_128_W1(0x660F3898), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F3898), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD213PD[] = /* VFMADD213PD */ { + { VEX_DDS_128_W1(0x660F38A8), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38A8), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD231PD[] = /* VFMADD231PD */ { + { VEX_DDS_128_W1(0x660F38B8), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38B8), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD132PS[] = /* VFMADD132PS */ { + { VEX_DDS_128_WIG(0x660F3898), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F3898), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD213PS[] = /* VFMADD213PS */ { + { VEX_DDS_128_WIG(0x660F38A8), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38A8), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD231PS[] = /* VFMADD231PS */ { + { VEX_DDS_128_WIG(0x660F38B8), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38B8), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD132SD[] = /* VFMADD132SD */ { + { VEX_DDS_128_W1(0x660F3899), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD213SD[] = /* VFMADD213SD */ { + { VEX_DDS_128_W1(0x660F38A9), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD231SD[] = /* VFMADD231SD */ { + { VEX_DDS_128_W1(0x660F38B9), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD132SS[] = /* VFMADD132SS */ { + { VEX_DDS_128_WIG(0x660F3899), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD213SS[] = /* VFMADD213SS */ { + { VEX_DDS_128_WIG(0x660F38A9), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADD231SS[] = /* VFMADD231SS */ { + { VEX_DDS_128_WIG(0x660F38B9), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB132PD[] = /* VFMADDSUB132PD */ { + { VEX_DDS_128_W1(0x660F3896), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F3896), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB213PD[] = /* VFMADDSUB213PD */ { + { VEX_DDS_128_W1(0x660F38A6), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38A6), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB231PD[] = /* VFMADDSUB231PD */ { + { VEX_DDS_128_W1(0x660F38B6), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38B6), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB132PS[] = /* VFMADDSUB132PS */ { + { VEX_DDS_128_WIG(0x660F3896), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F3896), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB213PS[] = /* VFMADDSUB213PS */ { + { VEX_DDS_128_WIG(0x660F38A6), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38A6), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMADDSUB231PS[] = /* VFMADDSUB231PS */ { + { VEX_DDS_128_WIG(0x660F38B6), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38B6), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD132PD[] = /* VFMSUBADD132PD */ { + { VEX_DDS_128_W1(0x660F3897), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F3897), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD213PD[] = /* VFMSUBADD213PD */ { + { VEX_DDS_128_W1(0x660F38A7), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38A7), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD231PD[] = /* VFMSUBADD231PD */ { + { VEX_DDS_128_W1(0x660F38B7), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38B7), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD132PS[] = /* VFMSUBADD132PS */ { + { VEX_DDS_128_WIG(0x660F3897), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F3897), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD213PS[] = /* VFMSUBADD213PS */ { + { VEX_DDS_128_WIG(0x660F38A7), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38A7), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUBADD231PS[] = /* VFMSUBADD231PS */ { + { VEX_DDS_128_WIG(0x660F38B7), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38B7), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB132PD[] = /* VFMSUB132PD */ { + { VEX_DDS_128_W1(0x660F389A), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F389A), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB213PD[] = /* VFMSUB213PD */ { + { VEX_DDS_128_W1(0x660F38AA), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38AA), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB231PD[] = /* VFMSUB231PD */ { + { VEX_DDS_128_W1(0x660F38BA), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_W1(0x660F38BA), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB132PS[] = /* VFMSUB132PS */ { + { VEX_DDS_128_WIG(0x660F389A), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F389A), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB213PS[] = /* VFMSUB213PS */ { + { VEX_DDS_128_WIG(0x660F38AA), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38AA), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB231PS[] = /* VFMSUB231PS */ { + { VEX_DDS_128_WIG(0x660F38BA), _r, _xmm, _xmm, _xmm_m128 }, + { VEX_DDS_256_WIG(0x660F38BA), _r, _ymm, _ymm, _ymm_m256 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB132SD[] = /* VFMSUB132SD */ { + { VEX_DDS_128_W1(0x660F389B), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB213SD[] = /* VFMSUB213SD */ { + { VEX_DDS_128_W1(0x660F38AB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB231SD[] = /* VFMSUB231SD */ { + { VEX_DDS_128_W1(0x660F38BB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB132SS[] = /* VFMSUB132SS */ { + { VEX_DDS_128_WIG(0x660F389B), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB213SS[] = /* VFMSUB213SS */ { + { VEX_DDS_128_WIG(0x660F38AB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +PTRNTAB3 aptb3VFMSUB231SS[] = /* VFMSUB231SS */ { + { VEX_DDS_128_WIG(0x660F38BB), _r, _xmm, _xmm, _xmm_m128 }, + { ASM_END }, +}; + +////////////////////////////////////////////////////////////////////// + + +// +// usNumops should be 0, 1, 2, or 3 other things are added into it +// for flag indications +// 10, 11, 12, and 13 indicate that it is a special prefix + +// 20, 21, 22, and 23 indicate that this statement is a control transfer +// and that a new block should be created when this statement is +// finished. (All Jxx and LOOPxx instructions.) + +// 30, 31, 32, 33 are reserved for instructions where the value of an +// immediate operand controls the code generation. +// 40, 41, 42, 43 are reserved for instructions where all of the operands +// are not required +// 50, 51, 52, 53 are reserved for the rotate and shift instructions that +// have extremely strange encodings for the second operand which is sometimes +// used to select an opcode and then discarded. The second operand is 0 +// if it is immediate 1, _cl for the CL register and _imm8 for the immediate +// 8 operand. If the operand is an immediate 1 or the cl register, it should +// be discarded and the opcode should be encoded as a 1 operand instruction. +// +// 60, 61, 62, 63 are reserved for floating point coprocessor operations +// +// ITdata is for the DB (_EMIT), DD, DW, DQ, DT pseudo-ops + +// BT is a 486 instruction. +// The encoding is 0f C0+reg and it is always a 32 +// bit operation + +#define P PPTRNTAB0 + +#if 0 +#define OPCODETABLE \ + X("aaa", 0, aptb0AAA ) +#else +#define OPCODETABLE1 \ + X("__emit", ITdata | OPdb, NULL ) \ + X("_emit", ITdata | OPdb, NULL ) \ + X("aaa", 0, aptb0AAA ) \ + X("aad", 0, aptb0AAD ) \ + X("aam", 0, aptb0AAM ) \ + X("aas", 0, aptb0AAS ) \ + X("adc", 2, (P) aptb2ADC ) \ + X("add", 2, (P) aptb2ADD ) \ + X("addpd", 2, (P) aptb2ADDPD ) \ + X("addps", 2, (P) aptb2ADDPS ) \ + X("addsd", 2, (P) aptb2ADDSD ) \ + X("addss", 2, (P) aptb2ADDSS ) \ + X("addsubpd", 2, (P) aptb2ADDSUBPD ) \ + X("addsubps", 2, (P) aptb2ADDSUBPS ) \ + X("aesdec", 2, (P) aptb2AESDEC ) \ + X("aesdeclast", 2, (P) aptb2AESDECLAST ) \ + X("aesenc", 2, (P) aptb2AESENC ) \ + X("aesenclast", 2, (P) aptb2AESENCLAST ) \ + X("aesimc", 2, (P) aptb2AESIMC ) \ + X("aeskeygenassist", 3, (P) aptb3AESKEYGENASSIST ) \ + X("and", 2, (P) aptb2AND ) \ + X("andnpd", 2, (P) aptb2ANDNPD ) \ + X("andnps", 2, (P) aptb2ANDNPS ) \ + X("andpd", 2, (P) aptb2ANDPD ) \ + X("andps", 2, (P) aptb2ANDPS ) \ + X("arpl", 2, (P) aptb2ARPL ) \ + X("blendpd", 3, (P) aptb3BLENDPD ) \ + X("blendps", 3, (P) aptb3BLENDPS ) \ + X("blendvpd", 3, (P) aptb3BLENDVPD ) \ + X("blendvps", 3, (P) aptb3BLENDVPS ) \ + X("bound", 2, (P) aptb2BOUND ) \ + X("bsf", 2, (P) aptb2BSF ) \ + X("bsr", 2, (P) aptb2BSR ) \ + X("bswap", 1, (P) aptb1BSWAP ) \ + X("bt", 2, (P) aptb2BT ) \ + X("btc", 2, (P) aptb2BTC ) \ + X("btr", 2, (P) aptb2BTR ) \ + X("bts", 2, (P) aptb2BTS ) \ + X("call", ITjump | 1, (P) aptb1CALL ) \ + X("cbw", 0, aptb0CBW ) \ + X("cdq", 0, aptb0CDQ ) \ + X("cdqe", 0, aptb0CDQE ) \ + X("clc", 0, aptb0CLC ) \ + X("cld", 0, aptb0CLD ) \ + X("clflush", 1, (P) aptb1CLFLUSH ) \ + X("cli", 0, aptb0CLI ) \ + X("clts", 0, aptb0CLTS ) \ + X("cmc", 0, aptb0CMC ) \ + X("cmova", 2, (P) aptb2CMOVNBE ) \ + X("cmovae", 2, (P) aptb2CMOVNB ) \ + X("cmovb", 2, (P) aptb2CMOVB ) \ + X("cmovbe", 2, (P) aptb2CMOVBE ) \ + X("cmovc", 2, (P) aptb2CMOVB ) \ + X("cmove", 2, (P) aptb2CMOVZ ) \ + X("cmovg", 2, (P) aptb2CMOVNLE ) \ + X("cmovge", 2, (P) aptb2CMOVNL ) \ + X("cmovl", 2, (P) aptb2CMOVL ) \ + X("cmovle", 2, (P) aptb2CMOVLE ) \ + X("cmovna", 2, (P) aptb2CMOVBE ) \ + X("cmovnae", 2, (P) aptb2CMOVB ) \ + X("cmovnb", 2, (P) aptb2CMOVNB ) \ + X("cmovnbe", 2, (P) aptb2CMOVNBE ) \ + X("cmovnc", 2, (P) aptb2CMOVNB ) \ + X("cmovne", 2, (P) aptb2CMOVNZ ) \ + X("cmovng", 2, (P) aptb2CMOVLE ) \ + X("cmovnge", 2, (P) aptb2CMOVL ) \ + X("cmovnl", 2, (P) aptb2CMOVNL ) \ + X("cmovnle", 2, (P) aptb2CMOVNLE ) \ + X("cmovno", 2, (P) aptb2CMOVNO ) \ + X("cmovnp", 2, (P) aptb2CMOVNP ) \ + X("cmovns", 2, (P) aptb2CMOVNS ) \ + X("cmovnz", 2, (P) aptb2CMOVNZ ) \ + X("cmovo", 2, (P) aptb2CMOVO ) \ + X("cmovp", 2, (P) aptb2CMOVP ) \ + X("cmovpe", 2, (P) aptb2CMOVP ) \ + X("cmovpo", 2, (P) aptb2CMOVNP ) \ + X("cmovs", 2, (P) aptb2CMOVS ) \ + X("cmovz", 2, (P) aptb2CMOVZ ) \ + X("cmp", 2, (P) aptb2CMP ) \ + X("cmppd", 3, (P) aptb3CMPPD ) \ + X("cmpps", 3, (P) aptb3CMPPS ) \ + X("cmps", 2, (P) aptb2CMPS ) \ + X("cmpsb", 0, aptb0CMPSB ) \ + /*X("cmpsd", 0, aptb0CMPSD )*/ \ + X("cmpsd", ITopt|3, (P) aptb3CMPSD ) \ + X("cmpsq", 0, aptb0CMPSQ ) \ + X("cmpss", 3, (P) aptb3CMPSS ) \ + X("cmpsw", 0, aptb0CMPSW ) \ + X("cmpxchg", 2, (P) aptb2CMPXCHG ) \ + X("cmpxchg16b", 1, (P) aptb1CMPXCH16B ) \ + X("cmpxchg8b", 1, (P) aptb1CMPXCH8B ) \ + X("comisd", 2, (P) aptb2COMISD ) \ + X("comiss", 2, (P) aptb2COMISS ) \ + X("cpuid", 0, aptb0CPUID ) \ + X("cqo", 0, aptb0CQO ) \ + X("crc32", 2, (P) aptb2CRC32 ) \ + X("cvtdq2pd", 2, (P) aptb2CVTDQ2PD ) \ + X("cvtdq2ps", 2, (P) aptb2CVTDQ2PS ) \ + X("cvtpd2dq", 2, (P) aptb2CVTPD2DQ ) \ + X("cvtpd2pi", 2, (P) aptb2CVTPD2PI ) \ + X("cvtpd2ps", 2, (P) aptb2CVTPD2PS ) \ + X("cvtpi2pd", 2, (P) aptb2CVTPI2PD ) \ + X("cvtpi2ps", 2, (P) aptb2CVTPI2PS ) \ + X("cvtps2dq", 2, (P) aptb2CVTPS2DQ ) \ + X("cvtps2pd", 2, (P) aptb2CVTPS2PD ) \ + X("cvtps2pi", 2, (P) aptb2CVTPS2PI ) \ + X("cvtsd2si", 2, (P) aptb2CVTSD2SI ) \ + X("cvtsd2ss", 2, (P) aptb2CVTSD2SS ) \ + X("cvtsi2sd", 2, (P) aptb2CVTSI2SD ) \ + X("cvtsi2ss", 2, (P) aptb2CVTSI2SS ) \ + X("cvtss2sd", 2, (P) aptb2CVTSS2SD ) \ + X("cvtss2si", 2, (P) aptb2CVTSS2SI ) \ + X("cvttpd2dq", 2, (P) aptb2CVTTPD2DQ ) \ + X("cvttpd2pi", 2, (P) aptb2CVTTPD2PI ) \ + X("cvttps2dq", 2, (P) aptb2CVTTPS2DQ ) \ + X("cvttps2pi", 2, (P) aptb2CVTTPS2PI ) \ + X("cvttsd2si", 2, (P) aptb2CVTTSD2SI ) \ + X("cvttss2si", 2, (P) aptb2CVTTSS2SI ) \ + X("cwd", 0, aptb0CWD ) \ + X("cwde", 0, aptb0CWDE ) \ + X("da", ITaddr | 4, NULL ) \ + X("daa", 0, aptb0DAA ) \ + X("das", 0, aptb0DAS ) \ + X("db", ITdata | OPdb, NULL ) \ + X("dd", ITdata | OPdd, NULL ) \ + X("de", ITdata | OPde, NULL ) \ + X("dec", 1, (P) aptb1DEC ) \ + X("df", ITdata | OPdf, NULL ) \ + X("di", ITdata | OPdi, NULL ) \ + X("div", ITopt | 2, (P) aptb2DIV ) \ + X("divpd", 2, (P) aptb2DIVPD ) \ + X("divps", 2, (P) aptb2DIVPS ) \ + X("divsd", 2, (P) aptb2DIVSD ) \ + X("divss", 2, (P) aptb2DIVSS ) \ + X("dl", ITdata | OPdl, NULL ) \ + X("dppd", 3, (P) aptb3DPPD ) \ + X("dpps", 3, (P) aptb3DPPS ) \ + X("dq", ITdata | OPdq, NULL ) \ + X("ds", ITdata | OPds, NULL ) \ + X("dt", ITdata | OPdt, NULL ) \ + X("dw", ITdata | OPdw, NULL ) \ + X("emms", 0, aptb0EMMS ) \ + X("enter", 2, (P) aptb2ENTER ) \ + X("extractps", 3, (P) aptb3EXTRACTPS ) \ + X("f2xm1", ITfloat | 0, aptb0F2XM1 ) \ + X("fabs", ITfloat | 0, aptb0FABS ) \ + X("fadd", ITfloat | 2, (P) aptb2FADD ) \ + X("faddp", ITfloat | 2, (P) aptb2FADDP ) \ + X("fbld", ITfloat | 1, (P) aptb1FBLD ) \ + X("fbstp", ITfloat | 1, (P) aptb1FBSTP ) \ + X("fchs", ITfloat | 0, aptb0FCHS ) \ + X("fclex", ITfloat | 0, aptb0FCLEX ) \ + X("fcmovb", ITfloat | 2, (P) aptb2FCMOVB ) \ + X("fcmovbe", ITfloat | 2, (P) aptb2FCMOVBE ) \ + X("fcmove", ITfloat | 2, (P) aptb2FCMOVE ) \ + X("fcmovnb", ITfloat | 2, (P) aptb2FCMOVNB ) \ + X("fcmovnbe", ITfloat | 2, (P) aptb2FCMOVNBE ) \ + X("fcmovne", ITfloat | 2, (P) aptb2FCMOVNE ) \ + X("fcmovnu", ITfloat | 2, (P) aptb2FCMOVNU ) \ + X("fcmovu", ITfloat | 2, (P) aptb2FCMOVU ) \ + X("fcom", ITfloat | 1, (P) aptb1FCOM ) \ + X("fcomi", ITfloat | 2, (P) aptb2FCOMI ) \ + X("fcomip", ITfloat | 2, (P) aptb2FCOMIP ) \ + X("fcomp", ITfloat | 1, (P) aptb1FCOMP ) \ + X("fcompp", ITfloat | 0, aptb0FCOMPP ) \ + X("fcos", ITfloat | 0, aptb0FCOS ) \ + X("fdecstp", ITfloat | 0, aptb0FDECSTP ) \ + X("fdisi", ITfloat | 0, aptb0FDISI ) \ + X("fdiv", ITfloat | 2, (P) aptb2FDIV ) \ + X("fdivp", ITfloat | 2, (P) aptb2FDIVP ) \ + X("fdivr", ITfloat | 2, (P) aptb2FDIVR ) \ + X("fdivrp", ITfloat | 2, (P) aptb2FDIVRP ) \ + X("feni", ITfloat | 0, aptb0FENI ) \ + X("ffree", ITfloat | 1, (P) aptb1FFREE ) \ + X("fiadd", ITfloat | 2, (P) aptb2FIADD ) \ + X("ficom", ITfloat | 1, (P) aptb1FICOM ) \ + X("ficomp", ITfloat | 1, (P) aptb1FICOMP ) \ + X("fidiv", ITfloat | 2, (P) aptb2FIDIV ) \ + X("fidivr", ITfloat | 2, (P) aptb2FIDIVR ) \ + X("fild", ITfloat | 1, (P) aptb1FILD ) \ + X("fimul", ITfloat | 2, (P) aptb2FIMUL ) \ + X("fincstp", ITfloat | 0, aptb0FINCSTP ) \ + X("finit", ITfloat | 0, aptb0FINIT ) \ + X("fist", ITfloat | 1, (P) aptb1FIST ) \ + X("fistp", ITfloat | 1, (P) aptb1FISTP ) \ + X("fisttp", ITfloat | 1, (P) aptb1FISTTP ) \ + X("fisub", ITfloat | 2, (P) aptb2FISUB ) \ + X("fisubr", ITfloat | 2, (P) aptb2FISUBR ) \ + X("fld", ITfloat | 1, (P) aptb1FLD ) \ + X("fld1", ITfloat | 0, aptb0FLD1 ) \ + X("fldcw", ITfloat | 1, (P) aptb1FLDCW ) \ + X("fldenv", ITfloat | 1, (P) aptb1FLDENV ) \ + X("fldl2e", ITfloat | 0, aptb0FLDL2E ) \ + X("fldl2t", ITfloat | 0, aptb0FLDL2T ) \ + X("fldlg2", ITfloat | 0, aptb0FLDLG2 ) \ + X("fldln2", ITfloat | 0, aptb0FLDLN2 ) \ + X("fldpi", ITfloat | 0, aptb0FLDPI ) \ + X("fldz", ITfloat | 0, aptb0FLDZ ) \ + X("fmul", ITfloat | 2, (P) aptb2FMUL ) \ + X("fmulp", ITfloat | 2, (P) aptb2FMULP ) \ + X("fnclex", ITfloat | 0, aptb0FNCLEX ) \ + X("fndisi", ITfloat | 0, aptb0FNDISI ) \ + X("fneni", ITfloat | 0, aptb0FNENI ) \ + X("fninit", ITfloat | 0, aptb0FNINIT ) \ + X("fnop", ITfloat | 0, aptb0FNOP ) \ + X("fnsave", ITfloat | 1, (P) aptb1FNSAVE ) \ + X("fnstcw", ITfloat | 1, (P) aptb1FNSTCW ) \ + X("fnstenv", ITfloat | 1, (P) aptb1FNSTENV ) \ + X("fnstsw", 1, (P) aptb1FNSTSW ) \ + X("fpatan", ITfloat | 0, aptb0FPATAN ) \ + X("fprem", ITfloat | 0, aptb0FPREM ) \ + X("fprem1", ITfloat | 0, aptb0FPREM1 ) \ + X("fptan", ITfloat | 0, aptb0FPTAN ) \ + X("frndint", ITfloat | 0, aptb0FRNDINT ) \ + X("frstor", ITfloat | 1, (P) aptb1FRSTOR ) \ + X("fsave", ITfloat | 1, (P) aptb1FSAVE ) \ + X("fscale", ITfloat | 0, aptb0FSCALE ) \ + X("fsetpm", ITfloat | 0, aptb0FSETPM ) \ + X("fsin", ITfloat | 0, aptb0FSIN ) \ + X("fsincos", ITfloat | 0, aptb0FSINCOS ) \ + X("fsqrt", ITfloat | 0, aptb0FSQRT ) \ + X("fst", ITfloat | 1, (P) aptb1FST ) \ + X("fstcw", ITfloat | 1, (P) aptb1FSTCW ) \ + X("fstenv", ITfloat | 1, (P) aptb1FSTENV ) \ + X("fstp", ITfloat | 1, (P) aptb1FSTP ) \ + X("fstsw", 1, (P) aptb1FSTSW ) \ + X("fsub", ITfloat | 2, (P) aptb2FSUB ) \ + X("fsubp", ITfloat | 2, (P) aptb2FSUBP ) \ + X("fsubr", ITfloat | 2, (P) aptb2FSUBR ) \ + X("fsubrp", ITfloat | 2, (P) aptb2FSUBRP ) \ + X("ftst", ITfloat | 0, aptb0FTST ) \ + X("fucom", ITfloat | 1, (P) aptb1FUCOM ) \ + X("fucomi", ITfloat | 2, (P) aptb2FUCOMI ) \ + X("fucomip", ITfloat | 2, (P) aptb2FUCOMIP ) \ + X("fucomp", ITfloat | 1, (P) aptb1FUCOMP ) \ + X("fucompp", ITfloat | 0, aptb0FUCOMPP ) \ + X("fwait", ITfloat | 0, aptb0FWAIT ) \ + X("fxam", ITfloat | 0, aptb0FXAM ) \ + X("fxch", ITfloat | 1, (P) aptb1FXCH ) \ + X("fxrstor", ITfloat | 1, (P) aptb1FXRSTOR ) \ + X("fxsave", ITfloat | 1, (P) aptb1FXSAVE ) \ + X("fxtract", ITfloat | 0, aptb0FXTRACT ) \ + X("fyl2x", ITfloat | 0, aptb0FYL2X ) \ + X("fyl2xp1", ITfloat | 0, aptb0FYL2XP1 ) \ + X("haddpd", 2, (P) aptb2HADDPD ) \ + X("haddps", 2, (P) aptb2HADDPS ) \ + X("hlt", 0, aptb0HLT ) \ + X("hsubpd", 2, (P) aptb2HSUBPD ) \ + X("hsubps", 2, (P) aptb2HSUBPS ) \ + X("idiv", ITopt | 2, (P) aptb2IDIV ) \ + X("imul", ITopt | 3, (P) aptb3IMUL ) \ + X("in", 2, (P) aptb2IN ) \ + X("inc", 1, (P) aptb1INC ) \ + X("ins", 2, (P) aptb2INS ) \ + X("insb", 0, aptb0INSB ) \ + X("insd", 0, aptb0INSD ) \ + X("insertps", 3, (P) aptb3INSERTPS ) \ + X("insw", 0, aptb0INSW ) \ + X("int", ITimmed | 1, (P) aptb1INT ) \ + X("into", 0, aptb0INTO ) \ + X("invd", 0, aptb0INVD ) \ + X("invlpg", 1, (P) aptb1INVLPG ) \ + X("iret", 0, aptb0IRET ) \ + X("iretd", 0, aptb0IRETD ) \ + X("ja", ITjump | 1, (P) aptb1JNBE ) \ + X("jae", ITjump | 1, (P) aptb1JNB ) \ + X("jb", ITjump | 1, (P) aptb1JB ) \ + X("jbe", ITjump | 1, (P) aptb1JBE ) \ + X("jc", ITjump | 1, (P) aptb1JB ) \ + X("jcxz", ITjump | 1, (P) aptb1JCXZ ) \ + X("je", ITjump | 1, (P) aptb1JZ ) \ + X("jecxz", ITjump | 1, (P) aptb1JECXZ ) \ + X("jg", ITjump | 1, (P) aptb1JNLE ) \ + X("jge", ITjump | 1, (P) aptb1JNL ) \ + X("jl", ITjump | 1, (P) aptb1JL ) \ + X("jle", ITjump | 1, (P) aptb1JLE ) \ + X("jmp", ITjump | 1, (P) aptb1JMP ) \ + X("jna", ITjump | 1, (P) aptb1JBE ) \ + X("jnae", ITjump | 1, (P) aptb1JB ) \ + X("jnb", ITjump | 1, (P) aptb1JNB ) \ + X("jnbe", ITjump | 1, (P) aptb1JNBE ) \ + X("jnc", ITjump | 1, (P) aptb1JNB ) \ + X("jne", ITjump | 1, (P) aptb1JNZ ) \ + X("jng", ITjump | 1, (P) aptb1JLE ) \ + X("jnge", ITjump | 1, (P) aptb1JL ) \ + X("jnl", ITjump | 1, (P) aptb1JNL ) \ + X("jnle", ITjump | 1, (P) aptb1JNLE ) \ + X("jno", ITjump | 1, (P) aptb1JNO ) \ + X("jnp", ITjump | 1, (P) aptb1JNP ) \ + X("jns", ITjump | 1, (P) aptb1JNS ) \ + X("jnz", ITjump | 1, (P) aptb1JNZ ) \ + X("jo", ITjump | 1, (P) aptb1JO ) \ + X("jp", ITjump | 1, (P) aptb1JP ) \ + X("jpe", ITjump | 1, (P) aptb1JP ) \ + X("jpo", ITjump | 1, (P) aptb1JNP ) \ + X("js", ITjump | 1, (P) aptb1JS ) \ + X("jz", ITjump | 1, (P) aptb1JZ ) \ + + +#define OPCODETABLE2 \ + X("lahf", 0, aptb0LAHF ) \ + X("lar", 2, (P) aptb2LAR ) \ + X("lddqu", 2, (P) aptb2LDDQU ) \ + X("ldmxcsr", 1, (P) aptb1LDMXCSR ) \ + X("lds", 2, (P) aptb2LDS ) \ + X("lea", 2, (P) aptb2LEA ) \ + X("leave", 0, aptb0LEAVE ) \ + X("les", 2, (P) aptb2LES ) \ + X("lfence", 0, aptb0LFENCE) \ + X("lfs", 2, (P) aptb2LFS ) \ + X("lgdt", 1, (P) aptb1LGDT ) \ + X("lgs", 2, (P) aptb2LGS ) \ + X("lidt", 1, (P) aptb1LIDT ) \ + X("lldt", 1, (P) aptb1LLDT ) \ + X("lmsw", 1, (P) aptb1LMSW ) \ + X("lock", ITprefix | 0, aptb0LOCK ) \ + X("lods", 1, (P) aptb1LODS ) \ + X("lodsb", 0, aptb0LODSB ) \ + X("lodsd", 0, aptb0LODSD ) \ + X("lodsq", 0, aptb0LODSQ ) \ + X("lodsw", 0, aptb0LODSW ) \ + X("loop", ITjump | 1, (P) aptb1LOOP ) \ + X("loope", ITjump | 1, (P) aptb1LOOPE ) \ + X("loopne", ITjump | 1, (P) aptb1LOOPNE ) \ + X("loopnz", ITjump | 1, (P) aptb1LOOPNE ) \ + X("loopz", ITjump | 1, (P) aptb1LOOPE ) \ + X("lsl", 2, (P) aptb2LSL ) \ + X("lss", 2, (P) aptb2LSS ) \ + X("ltr", 1, (P) aptb1LTR ) \ + X("maskmovdqu", 2, (P) aptb2MASKMOVDQU ) \ + X("maskmovq", 2, (P) aptb2MASKMOVQ ) \ + X("maxpd", 2, (P) aptb2MAXPD ) \ + X("maxps", 2, (P) aptb2MAXPS ) \ + X("maxsd", 2, (P) aptb2MAXSD ) \ + X("maxss", 2, (P) aptb2MAXSS ) \ + X("mfence", 0, aptb0MFENCE) \ + X("minpd", 2, (P) aptb2MINPD ) \ + X("minps", 2, (P) aptb2MINPS ) \ + X("minsd", 2, (P) aptb2MINSD ) \ + X("minss", 2, (P) aptb2MINSS ) \ + X("monitor", 0, (P) aptb0MONITOR ) \ + X("mov", 2, (P) aptb2MOV ) \ + X("movapd", 2, (P) aptb2MOVAPD ) \ + X("movaps", 2, (P) aptb2MOVAPS ) \ + X("movd", 2, (P) aptb2MOVD ) \ + X("movddup", 2, (P) aptb2MOVDDUP ) \ + X("movdq2q", 2, (P) aptb2MOVDQ2Q ) \ + X("movdqa", 2, (P) aptb2MOVDQA ) \ + X("movdqu", 2, (P) aptb2MOVDQU ) \ + X("movhlps", 2, (P) aptb2MOVHLPS ) \ + X("movhpd", 2, (P) aptb2MOVHPD ) \ + X("movhps", 2, (P) aptb2MOVHPS ) \ + X("movlhps", 2, (P) aptb2MOVLHPS ) \ + X("movlpd", 2, (P) aptb2MOVLPD ) \ + X("movlps", 2, (P) aptb2MOVLPS ) \ + X("movmskpd", 2, (P) aptb2MOVMSKPD ) \ + X("movmskps", 2, (P) aptb2MOVMSKPS ) \ + X("movntdq", 2, (P) aptb2MOVNTDQ ) \ + X("movntdqa", 2, (P) aptb2MOVNTDQA ) \ + X("movnti", 2, (P) aptb2MOVNTI ) \ + X("movntpd", 2, (P) aptb2MOVNTPD ) \ + X("movntps", 2, (P) aptb2MOVNTPS ) \ + X("movntq", 2, (P) aptb2MOVNTQ ) \ + X("movq", 2, (P) aptb2MOVQ ) \ + X("movq2dq", 2, (P) aptb2MOVQ2DQ ) \ + X("movs", 2, (P) aptb2MOVS ) \ + X("movsb", 0, aptb0MOVSB ) \ + X("movsd", ITopt | 2, (P) aptb2MOVSD ) \ + X("movshdup", 2, (P) aptb2MOVSHDUP ) \ + X("movsldup", 2, (P) aptb2MOVSLDUP ) \ + X("movsq", 0, aptb0MOVSQ ) \ + X("movss", 2, (P) aptb2MOVSS ) \ + X("movsw", 0, aptb0MOVSW ) \ + X("movsx", 2, (P) aptb2MOVSX ) \ + X("movupd", 2, (P) aptb2MOVUPD ) \ + X("movups", 2, (P) aptb2MOVUPS ) \ + X("movzx", 2, (P) aptb2MOVZX ) \ + X("mpsadbw", 3, (P) aptb3MPSADBW ) \ + X("mul", ITopt | 2, (P) aptb2MUL ) \ + X("mulpd", 2, (P) aptb2MULPD ) \ + X("mulps", 2, (P) aptb2MULPS ) \ + X("mulsd", 2, (P) aptb2MULSD ) \ + X("mulss", 2, (P) aptb2MULSS ) \ + X("mwait", 0, (P) aptb0MWAIT ) \ + X("neg", 1, (P) aptb1NEG ) \ + X("nop", 0, aptb0NOP ) \ + X("not", 1, (P) aptb1NOT ) \ + X("or", 2, (P) aptb2OR ) \ + X("orpd", 2, (P) aptb2ORPD ) \ + X("orps", 2, (P) aptb2ORPS ) \ + X("out", 2, (P) aptb2OUT ) \ + X("outs", 2, (P) aptb2OUTS ) \ + X("outsb", 0, aptb0OUTSB ) \ + X("outsd", 0, aptb0OUTSD ) \ + X("outsw", 0, aptb0OUTSW ) \ + X("pabsb", 2, (P) aptb2PABSB ) \ + X("pabsd", 2, (P) aptb2PABSD ) \ + X("pabsw", 2, (P) aptb2PABSW ) \ + X("packssdw", 2, (P) aptb2PACKSSDW ) \ + X("packsswb", 2, (P) aptb2PACKSSWB ) \ + X("packusdw", 2, (P) aptb2PACKUSDW ) \ + X("packuswb", 2, (P) aptb2PACKUSWB ) \ + X("paddb", 2, (P) aptb2PADDB ) \ + X("paddd", 2, (P) aptb2PADDD ) \ + X("paddq", 2, (P) aptb2PADDQ ) \ + X("paddsb", 2, (P) aptb2PADDSB ) \ + X("paddsw", 2, (P) aptb2PADDSW ) \ + X("paddusb", 2, (P) aptb2PADDUSB ) \ + X("paddusw", 2, (P) aptb2PADDUSW ) \ + X("paddw", 2, (P) aptb2PADDW ) \ + X("palignr", 3, (P) aptb3PALIGNR ) \ + X("pand", 2, (P) aptb2PAND ) \ + X("pandn", 2, (P) aptb2PANDN ) \ + /* X("pause", 0, aptb0PAUSE) */ \ + X("pavgb", 2, (P) aptb2PAVGB ) \ + X("pavgusb", 2, (P) aptb2PAVGUSB ) \ + X("pavgw", 2, (P) aptb2PAVGW ) \ + X("pblendvb", 3, (P) aptb3PBLENDVB ) \ + X("pblendw", 3, (P) aptb3PBLENDW ) \ + X("pcmpeqb", 2, (P) aptb2PCMPEQB ) \ + X("pcmpeqd", 2, (P) aptb2PCMPEQD ) \ + X("pcmpeqq", 2, (P) aptb2PCMPEQQ ) \ + X("pcmpeqw", 2, (P) aptb2PCMPEQW ) \ + X("pcmpestri", 3, (P) aptb3PCMPESTRI ) \ + X("pcmpestrm", 3, (P) aptb3PCMPESTRM ) \ + X("pcmpgtb", 2, (P) aptb2PCMPGTB ) \ + X("pcmpgtd", 2, (P) aptb2PCMPGTD ) \ + X("pcmpgtq", 2, (P) aptb2PCMPGTQ ) \ + X("pcmpgtw", 2, (P) aptb2PCMPGTW ) \ + X("pcmpistri", 3, (P) aptb3PCMPISTRI ) \ + X("pcmpistrm", 3, (P) aptb3PCMPISTRM ) \ + X("pextrb", 3, (P) aptb3PEXTRB ) \ + X("pextrd", 3, (P) aptb3PEXTRD ) \ + X("pextrq", 3, (P) aptb3PEXTRQ ) \ + X("pextrw", 3, (P) aptb3PEXTRW ) \ + X("pf2id", 2, (P) aptb2PF2ID ) \ + X("pfacc", 2, (P) aptb2PFACC ) \ + X("pfadd", 2, (P) aptb2PFADD ) \ + X("pfcmpeq", 2, (P) aptb2PFCMPEQ ) \ + X("pfcmpge", 2, (P) aptb2PFCMPGE ) \ + X("pfcmpgt", 2, (P) aptb2PFCMPGT ) \ + X("pfmax", 2, (P) aptb2PFMAX ) \ + X("pfmin", 2, (P) aptb2PFMIN ) \ + X("pfmul", 2, (P) aptb2PFMUL ) \ + X("pfnacc", 2, (P) aptb2PFNACC ) \ + X("pfpnacc", 2, (P) aptb2PFPNACC ) \ + X("pfrcp", 2, (P) aptb2PFRCP ) \ + X("pfrcpit1", 2, (P) aptb2PFRCPIT1 ) \ + X("pfrcpit2", 2, (P) aptb2PFRCPIT2 ) \ + X("pfrsqit1", 2, (P) aptb2PFRSQIT1 ) \ + X("pfrsqrt", 2, (P) aptb2PFRSQRT ) \ + X("pfsub", 2, (P) aptb2PFSUB ) \ + X("pfsubr", 2, (P) aptb2PFSUBR ) \ + X("phaddd", 2, (P) aptb2PHADDD ) \ + X("phaddsw", 2, (P) aptb2PHADDSW ) \ + X("phaddw", 2, (P) aptb2PHADDW ) \ + X("phminposuw", 2, (P) aptb2PHMINPOSUW ) \ + X("phsubd", 2, (P) aptb2PHSUBD ) \ + X("phsubsw", 2, (P) aptb2PHSUBSW ) \ + X("phsubw", 2, (P) aptb2PHSUBW ) \ + X("pi2fd", 2, (P) aptb2PI2FD ) \ + X("pinsrb", 3, (P) aptb3PINSRB ) \ + X("pinsrd", 3, (P) aptb3PINSRD ) \ + X("pinsrq", 3, (P) aptb3PINSRQ ) \ + X("pinsrw", 3, (P) aptb3PINSRW ) \ + X("pmaddubsw", 2, (P) aptb2PMADDUBSW ) \ + X("pmaddwd", 2, (P) aptb2PMADDWD ) \ + X("pmaxsb", 2, (P) aptb2PMAXSB ) \ + X("pmaxsd", 2, (P) aptb2PMAXSD ) \ + X("pmaxsw", 2, (P) aptb2PMAXSW ) \ + X("pmaxub", 2, (P) aptb2PMAXUB ) \ + X("pmaxud", 2, (P) aptb2PMAXUD ) \ + X("pmaxuw", 2, (P) aptb2PMAXUW ) \ + X("pminsb", 2, (P) aptb2PMINSB ) \ + X("pminsd", 2, (P) aptb2PMINSD ) \ + X("pminsw", 2, (P) aptb2PMINSW ) \ + X("pminub", 2, (P) aptb2PMINUB ) \ + X("pminud", 2, (P) aptb2PMINUD ) \ + X("pminuw", 2, (P) aptb2PMINUW ) \ + X("pmovmskb", 2, (P) aptb2PMOVMSKB ) \ + X("pmovsxbd", 2, (P) aptb2PMOVSXBD ) \ + X("pmovsxbq", 2, (P) aptb2PMOVSXBQ ) \ + X("pmovsxbw", 2, (P) aptb2PMOVSXBW ) \ + X("pmovsxdq", 2, (P) aptb2PMOVSXDQ ) \ + X("pmovsxwd", 2, (P) aptb2PMOVSXWD ) \ + X("pmovsxwq", 2, (P) aptb2PMOVSXWQ ) \ + X("pmovzxbd", 2, (P) aptb2PMOVZXBD ) \ + X("pmovzxbq", 2, (P) aptb2PMOVZXBQ ) \ + X("pmovzxbw", 2, (P) aptb2PMOVZXBW ) \ + X("pmovzxdq", 2, (P) aptb2PMOVZXDQ ) \ + X("pmovzxwd", 2, (P) aptb2PMOVZXWD ) \ + X("pmovzxwq", 2, (P) aptb2PMOVZXWQ ) \ + X("pmuldq", 2, (P) aptb2PMULDQ ) \ + X("pmulhrsw", 2, (P) aptb2PMULHRSW ) \ + X("pmulhrw", 2, (P) aptb2PMULHRW ) \ + X("pmulhuw", 2, (P) aptb2PMULHUW ) \ + X("pmulhw", 2, (P) aptb2PMULHW ) \ + X("pmulld", 2, (P) aptb2PMULLD ) \ + X("pmullw", 2, (P) aptb2PMULLW ) \ + X("pmuludq", 2, (P) aptb2PMULUDQ ) \ + X("pop", 1, (P) aptb1POP ) \ + X("popa", 0, aptb0POPA ) \ + X("popad", 0, aptb0POPAD ) \ + X("popcnt", 2, (P) aptb2POPCNT ) \ + X("popf", 0, aptb0POPF ) \ + X("popfd", 0, aptb0POPFD ) \ + X("popfq", 0, aptb0POPFQ ) \ + X("por", 2, (P) aptb2POR ) \ + X("prefetchnta", 1, (P) aptb1PREFETCHNTA ) \ + X("prefetcht0", 1, (P) aptb1PREFETCHT0 ) \ + X("prefetcht1", 1, (P) aptb1PREFETCHT1 ) \ + X("prefetcht2", 1, (P) aptb1PREFETCHT2 ) \ + X("psadbw", 2, (P) aptb2PSADBW ) \ + X("pshufb", 2, (P) aptb2PSHUFB ) \ + X("pshufd", 3, (P) aptb3PSHUFD ) \ + X("pshufhw", 3, (P) aptb3PSHUFHW ) \ + X("pshuflw", 3, (P) aptb3PSHUFLW ) \ + X("pshufw", 3, (P) aptb3PSHUFW ) \ + X("psignb", 2, (P) aptb2PSIGNB ) \ + X("psignd", 2, (P) aptb2PSIGND ) \ + X("psignw", 2, (P) aptb2PSIGNW ) \ + X("pslld", 2, (P) aptb2PSLLD ) \ + X("pslldq", 2, (P) aptb2PSLLDQ ) \ + X("psllq", 2, (P) aptb2PSLLQ ) \ + X("psllw", 2, (P) aptb2PSLLW ) \ + X("psrad", 2, (P) aptb2PSRAD ) \ + X("psraw", 2, (P) aptb2PSRAW ) \ + X("psrld", 2, (P) aptb2PSRLD ) \ + X("psrldq", 2, (P) aptb2PSRLDQ ) \ + X("psrlq", 2, (P) aptb2PSRLQ ) \ + X("psrlw", 2, (P) aptb2PSRLW ) \ + X("psubb", 2, (P) aptb2PSUBB ) \ + X("psubd", 2, (P) aptb2PSUBD ) \ + X("psubq", 2, (P) aptb2PSUBQ ) \ + X("psubsb", 2, (P) aptb2PSUBSB ) \ + X("psubsw", 2, (P) aptb2PSUBSW ) \ + X("psubusb", 2, (P) aptb2PSUBUSB ) \ + X("psubusw", 2, (P) aptb2PSUBUSW ) \ + X("psubw", 2, (P) aptb2PSUBW ) \ + X("pswapd", 2, (P) aptb2PSWAPD ) \ + X("ptest", 2, (P) aptb2PTEST ) \ + X("punpckhbw", 2, (P) aptb2PUNPCKHBW ) \ + X("punpckhdq", 2, (P) aptb2PUNPCKHDQ ) \ + X("punpckhqdq", 2, (P) aptb2PUNPCKHQDQ ) \ + X("punpckhwd", 2, (P) aptb2PUNPCKHWD ) \ + X("punpcklbw", 2, (P) aptb2PUNPCKLBW ) \ + X("punpckldq", 2, (P) aptb2PUNPCKLDQ ) \ + X("punpcklqdq", 2, (P) aptb2PUNPCKLQDQ ) \ + X("punpcklwd", 2, (P) aptb2PUNPCKLWD ) \ + X("push", 1, (P) aptb1PUSH ) \ + X("pusha", 0, aptb0PUSHA ) \ + X("pushad", 0, aptb0PUSHAD ) \ + X("pushf", 0, aptb0PUSHF ) \ + X("pushfd", 0, aptb0PUSHFD ) \ + X("pushfq", 0, aptb0PUSHFQ ) \ + X("pxor", 2, (P) aptb2PXOR ) \ + X("rcl", ITshift | 2, (P) aptb2RCL ) \ + X("rcpps", 2, (P) aptb2RCPPS ) \ + X("rcpss", 2, (P) aptb2RCPSS ) \ + X("rcr", ITshift | 2, (P) aptb2RCR ) \ + X("rdfsbase", 1, (P) aptb1RDFSBASE ) \ + X("rdgsbase", 1, (P) aptb1RDGSBASE ) \ + X("rdmsr", 0, aptb0RDMSR ) \ + X("rdpmc", 0, aptb0RDPMC ) \ + X("rdrand", 1, (P) aptb1RDRAND ) \ + X("rdtsc", 0, aptb0RDTSC ) \ + X("rep", ITprefix | 0, aptb0REP ) \ + X("repe", ITprefix | 0, aptb0REP ) \ + X("repne", ITprefix | 0, aptb0REPNE ) \ + X("repnz", ITprefix | 0, aptb0REPNE ) \ + X("repz", ITprefix | 0, aptb0REP ) \ + X("ret", ITopt | 1, (P) aptb1RET ) \ + X("retf", ITopt | 1, (P) aptb1RETF ) \ + X("rol", ITshift | 2, (P) aptb2ROL ) \ + X("ror", ITshift | 2, (P) aptb2ROR ) \ + X("roundpd", 3, (P) aptb3ROUNDPD ) \ + X("roundps", 3, (P) aptb3ROUNDPS ) \ + X("roundsd", 3, (P) aptb3ROUNDSD ) \ + X("roundss", 3, (P) aptb3ROUNDSS ) \ + X("rsm", 0, aptb0RSM ) \ + X("rsqrtps", 2, (P) aptb2RSQRTPS ) \ + X("rsqrtss", 2, (P) aptb2RSQRTSS ) \ + X("sahf", 0, aptb0SAHF ) \ + X("sal", ITshift | 2, (P) aptb2SHL ) \ + X("sar", ITshift | 2, (P) aptb2SAR ) \ + X("sbb", 2, (P) aptb2SBB ) \ + X("scas", 1, (P) aptb1SCAS ) \ + X("scasb", 0, aptb0SCASB ) \ + X("scasd", 0, aptb0SCASD ) \ + X("scasq", 0, aptb0SCASQ ) \ + X("scasw", 0, aptb0SCASW ) \ + X("seta", 1, (P) aptb1SETNBE ) \ + X("setae", 1, (P) aptb1SETNB ) \ + X("setb", 1, (P) aptb1SETB ) \ + X("setbe", 1, (P) aptb1SETBE ) \ + X("setc", 1, (P) aptb1SETB ) \ + X("sete", 1, (P) aptb1SETZ ) \ + X("setg", 1, (P) aptb1SETNLE ) \ + X("setge", 1, (P) aptb1SETNL ) \ + X("setl", 1, (P) aptb1SETL ) \ + X("setle", 1, (P) aptb1SETLE ) \ + X("setna", 1, (P) aptb1SETBE ) \ + X("setnae", 1, (P) aptb1SETB ) \ + X("setnb", 1, (P) aptb1SETNB ) \ + X("setnbe", 1, (P) aptb1SETNBE ) \ + X("setnc", 1, (P) aptb1SETNB ) \ + X("setne", 1, (P) aptb1SETNZ ) \ + X("setng", 1, (P) aptb1SETLE ) \ + X("setnge", 1, (P) aptb1SETL ) \ + X("setnl", 1, (P) aptb1SETNL ) \ + X("setnle", 1, (P) aptb1SETNLE ) \ + X("setno", 1, (P) aptb1SETNO ) \ + X("setnp", 1, (P) aptb1SETNP ) \ + X("setns", 1, (P) aptb1SETNS ) \ + X("setnz", 1, (P) aptb1SETNZ ) \ + X("seto", 1, (P) aptb1SETO ) \ + X("setp", 1, (P) aptb1SETP ) \ + X("setpe", 1, (P) aptb1SETP ) \ + X("setpo", 1, (P) aptb1SETNP ) \ + X("sets", 1, (P) aptb1SETS ) \ + X("setz", 1, (P) aptb1SETZ ) \ + X("sfence", 0, aptb0SFENCE) \ + X("sgdt", 1, (P) aptb1SGDT ) \ + X("shl", ITshift | 2, (P) aptb2SHL ) \ + X("shld", 3, (P) aptb3SHLD ) \ + X("shr", ITshift | 2, (P) aptb2SHR ) \ + X("shrd", 3, (P) aptb3SHRD ) \ + X("shufpd", 3, (P) aptb3SHUFPD ) \ + X("shufps", 3, (P) aptb3SHUFPS ) \ + X("sidt", 1, (P) aptb1SIDT ) \ + X("sldt", 1, (P) aptb1SLDT ) \ + X("smsw", 1, (P) aptb1SMSW ) \ + X("sqrtpd", 2, (P) aptb2SQRTPD ) \ + X("sqrtps", 2, (P) aptb2SQRTPS ) \ + X("sqrtsd", 2, (P) aptb2SQRTSD ) \ + X("sqrtss", 2, (P) aptb2SQRTSS ) \ + X("stc", 0, aptb0STC ) \ + X("std", 0, aptb0STD ) \ + X("sti", 0, aptb0STI ) \ + X("stmxcsr", 1, (P) aptb1STMXCSR ) \ + X("stos", 1, (P) aptb1STOS ) \ + X("stosb", 0, aptb0STOSB ) \ + X("stosd", 0, aptb0STOSD ) \ + X("stosq", 0, aptb0STOSQ ) \ + X("stosw", 0, aptb0STOSW ) \ + X("str", 1, (P) aptb1STR ) \ + X("sub", 2, (P) aptb2SUB ) \ + X("subpd", 2, (P) aptb2SUBPD ) \ + X("subps", 2, (P) aptb2SUBPS ) \ + X("subsd", 2, (P) aptb2SUBSD ) \ + X("subss", 2, (P) aptb2SUBSS ) \ + X("syscall", 0, aptb0SYSCALL ) \ + X("sysenter", 0, aptb0SYSENTER ) \ + X("sysexit", 0, aptb0SYSEXIT ) \ + X("sysret", 0, aptb0SYSRET ) \ + X("test", 2, (P) aptb2TEST ) \ + X("ucomisd", 2, (P) aptb2UCOMISD ) \ + X("ucomiss", 2, (P) aptb2UCOMISS ) \ + X("ud2", 0, aptb0UD2 ) \ + X("unpckhpd", 2, (P) aptb2UNPCKHPD ) \ + X("unpckhps", 2, (P) aptb2UNPCKHPS ) \ + X("unpcklpd", 2, (P) aptb2UNPCKLPD ) \ + X("unpcklps", 2, (P) aptb2UNPCKLPS ) \ + + +#define OPCODETABLE3 \ + X("vaddpd", 3, (P) aptb3VADDPD ) \ + X("vaddps", 3, (P) aptb3VADDPS ) \ + X("vaddsd", 3, (P) aptb3VADDSD ) \ + X("vaddss", 3, (P) aptb3VADDSS ) \ + X("vaddsubpd", 3, (P) aptb3VADDSUBPD ) \ + X("vaddsubps", 3, (P) aptb3VADDSUBPS ) \ + X("vaesdec", 3, (P) aptb3VAESDEC ) \ + X("vaesdeclast", 3, (P) aptb3VAESDECLAST ) \ + X("vaesenc", 3, (P) aptb3VAESENC ) \ + X("vaesenclast", 3, (P) aptb3VAESENCLAST ) \ + X("vaesimc", 2, (P) aptb2VAESIMC ) \ + X("vaeskeygenassist", 3, (P) aptb3VAESKEYGENASSIST ) \ + X("vandnpd", 3, (P) aptb3VANDNPD ) \ + X("vandnps", 3, (P) aptb3VANDNPS ) \ + X("vandpd", 3, (P) aptb3VANDPD ) \ + X("vandps", 3, (P) aptb3VANDPS ) \ + X("vblendpd", 4, (P) aptb4VBLENDPD ) \ + X("vblendps", 4, (P) aptb4VBLENDPS ) \ + X("vblendvpd", 4, (P) aptb4VBLENDVPD ) \ + X("vblendvps", 4, (P) aptb4VBLENDVPS ) \ + X("vbroadcastf128", 2, (P) aptb2VBROADCASTF128 ) \ + X("vbroadcastsd", 2, (P) aptb2VBROADCASTSD ) \ + X("vbroadcastss", 2, (P) aptb2VBROADCASTSS ) \ + X("vcmppd", 4, (P) aptb4VCMPPD ) \ + X("vcmpps", 4, (P) aptb4VCMPPS ) \ + X("vcmpsd", 4, (P) aptb4VCMPSD ) \ + X("vcmpss", 4, (P) aptb4VCMPSS ) \ + X("vcomisd", 2, (P) aptb2VCOMISD ) \ + X("vcomiss", 2, (P) aptb2VCOMISS ) \ + X("vcvtdq2pd", 2, (P) aptb2VCVTDQ2PD ) \ + X("vcvtdq2ps", 2, (P) aptb2VCVTDQ2PS ) \ + X("vcvtpd2dq", 2, (P) aptb2VCVTPD2DQ ) \ + X("vcvtpd2ps", 2, (P) aptb2VCVTPD2PS ) \ + X("vcvtph2ps", 2, (P) aptb2VCVTPH2PS ) \ + X("vcvtps2dq", 2, (P) aptb2VCVTPS2DQ ) \ + X("vcvtps2pd", 2, (P) aptb2VCVTPS2PD ) \ + X("vcvtps2ph", 3, (P) aptb3VCVTPS2PH ) \ + X("vcvtsd2si", 2, (P) aptb2VCVTSD2SI ) \ + X("vcvtsd2ss", 3, (P) aptb3VCVTSD2SS ) \ + X("vcvtsi2sd", 3, (P) aptb3VCVTSI2SD ) \ + X("vcvtsi2ss", 3, (P) aptb3VCVTSI2SS ) \ + X("vcvtss2sd", 3, (P) aptb3VCVTSS2SD ) \ + X("vcvtss2si", 2, (P) aptb2VCVTSS2SI ) \ + X("vcvttpd2dq", 2, (P) aptb2VCVTTPD2DQ ) \ + X("vcvttps2dq", 2, (P) aptb2VCVTTPS2DQ ) \ + X("vcvttsd2si", 2, (P) aptb2VCVTTSD2SI ) \ + X("vcvttss2si", 2, (P) aptb2VCVTTSS2SI ) \ + X("vdivpd", 3, (P) aptb3VDIVPD ) \ + X("vdivps", 3, (P) aptb3VDIVPS ) \ + X("vdivsd", 3, (P) aptb3VDIVSD ) \ + X("vdivss", 3, (P) aptb3VDIVSS ) \ + X("vdppd", 4, (P) aptb4VDPPD ) \ + X("vdpps", 4, (P) aptb4VDPPS ) \ + X("verr", 1, (P) aptb1VERR ) \ + X("verw", 1, (P) aptb1VERW ) \ + X("vextractf128", 3, (P) aptb3VEXTRACTF128 ) \ + X("vextractps", 3, (P) aptb3VEXTRACTPS ) \ + X("vfmadd132pd", 3, (P) aptb3VFMADD132PD ) \ + X("vfmadd132ps", 3, (P) aptb3VFMADD132PS ) \ + X("vfmadd132sd", 3, (P) aptb3VFMADD132SD ) \ + X("vfmadd132ss", 3, (P) aptb3VFMADD132SS ) \ + X("vfmadd213pd", 3, (P) aptb3VFMADD213PD ) \ + X("vfmadd213ps", 3, (P) aptb3VFMADD213PS ) \ + X("vfmadd213sd", 3, (P) aptb3VFMADD213SD ) \ + X("vfmadd213ss", 3, (P) aptb3VFMADD213SS ) \ + X("vfmadd231pd", 3, (P) aptb3VFMADD231PD ) \ + X("vfmadd231ps", 3, (P) aptb3VFMADD231PS ) \ + X("vfmadd231sd", 3, (P) aptb3VFMADD231SD ) \ + X("vfmadd231ss", 3, (P) aptb3VFMADD231SS ) \ + X("vfmaddsub132pd", 3, (P) aptb3VFMADDSUB132PD ) \ + X("vfmaddsub132ps", 3, (P) aptb3VFMADDSUB132PS ) \ + X("vfmaddsub213pd", 3, (P) aptb3VFMADDSUB213PD ) \ + X("vfmaddsub213ps", 3, (P) aptb3VFMADDSUB213PS ) \ + X("vfmaddsub231pd", 3, (P) aptb3VFMADDSUB231PD ) \ + X("vfmaddsub231ps", 3, (P) aptb3VFMADDSUB231PS ) \ + X("vfmsub132pd", 3, (P) aptb3VFMSUB132PD ) \ + X("vfmsub132ps", 3, (P) aptb3VFMSUB132PS ) \ + X("vfmsub132sd", 3, (P) aptb3VFMSUB132SD ) \ + X("vfmsub132ss", 3, (P) aptb3VFMSUB132SS ) \ + X("vfmsub213pd", 3, (P) aptb3VFMSUB213PD ) \ + X("vfmsub213ps", 3, (P) aptb3VFMSUB213PS ) \ + X("vfmsub213sd", 3, (P) aptb3VFMSUB213SD ) \ + X("vfmsub213ss", 3, (P) aptb3VFMSUB213SS ) \ + X("vfmsub231pd", 3, (P) aptb3VFMSUB231PD ) \ + X("vfmsub231ps", 3, (P) aptb3VFMSUB231PS ) \ + X("vfmsub231sd", 3, (P) aptb3VFMSUB231SD ) \ + X("vfmsub231ss", 3, (P) aptb3VFMSUB231SS ) \ + X("vfmsubadd132pd", 3, (P) aptb3VFMSUBADD132PD ) \ + X("vfmsubadd132ps", 3, (P) aptb3VFMSUBADD132PS ) \ + X("vfmsubadd213pd", 3, (P) aptb3VFMSUBADD213PD ) \ + X("vfmsubadd213ps", 3, (P) aptb3VFMSUBADD213PS ) \ + X("vfmsubadd231pd", 3, (P) aptb3VFMSUBADD231PD ) \ + X("vfmsubadd231ps", 3, (P) aptb3VFMSUBADD231PS ) \ + X("vhaddpd", 3, (P) aptb3VHADDPD ) \ + X("vhaddps", 3, (P) aptb3VHADDPS ) \ + X("vinsertf128", 4, (P) aptb4VINSERTF128 ) \ + X("vinsertps", 4, (P) aptb4VINSERTPS ) \ + X("vlddqu", 2, (P) aptb2VLDDQU ) \ + X("vldmxcsr", 1, (P) aptb1VLDMXCSR ) \ + X("vmaskmovdqu", 2, (P) aptb2VMASKMOVDQU ) \ + X("vmaskmovpd", 3, (P) aptb3VMASKMOVPD ) \ + X("vmaskmovps", 3, (P) aptb3VMASKMOVPS ) \ + X("vmaxpd", 3, (P) aptb3VMAXPD ) \ + X("vmaxps", 3, (P) aptb3VMAXPS ) \ + X("vmaxsd", 3, (P) aptb3VMAXSD ) \ + X("vmaxss", 3, (P) aptb3VMAXSS ) \ + X("vminpd", 3, (P) aptb3VMINPD ) \ + X("vminps", 3, (P) aptb3VMINPS ) \ + X("vminsd", 3, (P) aptb3VMINSD ) \ + X("vminss", 3, (P) aptb3VMINSS ) \ + X("vmovapd", 2, (P) aptb2VMOVAPD ) \ + X("vmovaps", 2, (P) aptb2VMOVAPS ) \ + X("vmovd", 2, (P) aptb2VMOVD ) \ + X("vmovddup", 2, (P) aptb2VMOVDDUP ) \ + X("vmovdqa", 2, (P) aptb2VMOVDQA ) \ + X("vmovdqu", 2, (P) aptb2VMOVDQU ) \ + X("vmovhlps", 3, (P) aptb3VMOVLHPS ) \ + X("vmovhpd", ITopt | 3, (P) aptb3VMOVHPD ) \ + X("vmovhps", ITopt | 3, (P) aptb3VMOVHPS ) \ + X("vmovlhps", 3, (P) aptb3VMOVHLPS ) \ + X("vmovlpd", ITopt | 3, (P) aptb3VMOVLPD ) \ + X("vmovlps", ITopt | 3, (P) aptb3VMOVLPS ) \ + X("vmovmskpd", 2, (P) aptb2VMOVMSKPD ) \ + X("vmovmskps", 2, (P) aptb2VMOVMSKPS ) \ + X("vmovntdq", 2, (P) aptb2VMOVNTDQ ) \ + X("vmovntdqa", 2, (P) aptb2VMOVNTDQA ) \ + X("vmovntpd", 2, (P) aptb2VMOVNTPD ) \ + X("vmovntps", 2, (P) aptb2VMOVNTPS ) \ + X("vmovq", 2, (P) aptb2VMOVQ ) \ + X("vmovsd", ITopt | 3, (P) aptb3VMOVSD ) \ + X("vmovshdup", 2, (P) aptb2VMOVSHDUP ) \ + X("vmovsldup", 2, (P) aptb2VMOVSLDUP ) \ + X("vmovss", ITopt | 3, (P) aptb3VMOVSS ) \ + X("vmovupd", 2, (P) aptb2VMOVUPD ) \ + X("vmovups", 2, (P) aptb2VMOVUPS ) \ + X("vmpsadbw", 4, (P) aptb4VMPSADBW ) \ + X("vmulpd", 3, (P) aptb3VMULPD ) \ + X("vmulps", 3, (P) aptb3VMULPS ) \ + X("vmulsd", 3, (P) aptb3VMULSD ) \ + X("vmulss", 3, (P) aptb3VMULSS ) \ + X("vorpd", 3, (P) aptb3VORPD ) \ + X("vorps", 3, (P) aptb3VORPS ) \ + X("vpabsb", 2, (P) aptb2VPABSB ) \ + X("vpabsd", 2, (P) aptb2VPABSD ) \ + X("vpabsw", 2, (P) aptb2VPABSW ) \ + X("vpackssdw", 3, (P) aptb3VPACKSSDW ) \ + X("vpacksswb", 3, (P) aptb3VPACKSSWB ) \ + X("vpackusdw", 3, (P) aptb3VPACKUSDW ) \ + X("vpackuswb", 3, (P) aptb3VPACKUSWB ) \ + X("vpaddb", 3, (P) aptb3VPADDB ) \ + X("vpaddd", 3, (P) aptb3VPADDD ) \ + X("vpaddq", 3, (P) aptb3VPADDQ ) \ + X("vpaddsb", 3, (P) aptb3VPADDSB ) \ + X("vpaddsw", 3, (P) aptb3VPADDSW ) \ + X("vpaddusb", 3, (P) aptb3VPADDUSB ) \ + X("vpaddusw", 3, (P) aptb3VPADDUSW ) \ + X("vpaddw", 3, (P) aptb3VPADDW ) \ + X("vpalignr", 4, (P) aptb4VPALIGNR ) \ + X("vpand", 3, (P) aptb3VPAND ) \ + X("vpandn", 3, (P) aptb3VPANDN ) \ + X("vpavgb", 3, (P) aptb3VPAVGB ) \ + X("vpavgw", 3, (P) aptb3VPAVGW ) \ + X("vpblendvb", 4, (P) aptb4VPBLENDVB ) \ + X("vpblendw", 4, (P) aptb4VPBLENDW ) \ + X("vpclmulqdq", 4, (P) aptb4VPCLMULQDQ ) \ + X("vpcmpeqb", 3, (P) aptb3VPCMPEQB ) \ + X("vpcmpeqd", 3, (P) aptb3VPCMPEQD ) \ + X("vpcmpeqq", 3, (P) aptb3VPCMPEQQ ) \ + X("vpcmpeqw", 3, (P) aptb3VPCMPEQW ) \ + X("vpcmpestri", 3, (P) aptb3VPCMPESTRI ) \ + X("vpcmpestrm", 3, (P) aptb3VPCMPESTRM ) \ + X("vpcmpgtb", 3, (P) aptb3VPCMPGTB ) \ + X("vpcmpgtd", 3, (P) aptb3VPCMPGTD ) \ + X("vpcmpgtq", 3, (P) aptb3VPCMPGTQ ) \ + X("vpcmpgtw", 3, (P) aptb3VPCMPGTW ) \ + X("vpcmpistri", 3, (P) aptb3VPCMPISTRI ) \ + X("vpcmpistrm", 3, (P) aptb3VPCMPISTRM ) \ + X("vperm2f128", 4, (P) aptb3VPERM2F128 ) \ + X("vpermilpd", 3, (P) aptb3VPERMILPD ) \ + X("vpermilps", 3, (P) aptb3VPERMILPS ) \ + X("vpextrb", 3, (P) aptb3VPEXTRB ) \ + X("vpextrd", 3, (P) aptb3VPEXTRD ) \ + X("vpextrq", 3, (P) aptb3VPEXTRQ ) \ + X("vpextrw", 3, (P) aptb3VPEXTRW ) \ + X("vphaddd", 3, (P) aptb3VPHADDD ) \ + X("vphaddsw", 3, (P) aptb3VPHADDSW ) \ + X("vphaddw", 3, (P) aptb3VPHADDW ) \ + X("vphminposuw", 2, (P) aptb2VPHMINPOSUW ) \ + X("vphsubd", 3, (P) aptb3VPHSUBD ) \ + X("vphsubsw", 3, (P) aptb3VPHSUBSW ) \ + X("vphsubw", 3, (P) aptb3VPHSUBW ) \ + X("vpinsrb", 4, (P) aptb4VPINSRB ) \ + X("vpinsrd", 4, (P) aptb4VPINSRD ) \ + X("vpinsrq", 4, (P) aptb4VPINSRQ ) \ + X("vpinsrw", 4, (P) aptb4VPINSRW ) \ + X("vpmaddubsw", 3, (P) aptb3VPMADDUBSW ) \ + X("vpmaddwd", 3, (P) aptb3VPMADDWD ) \ + X("vpmaxsb", 3, (P) aptb3VPMAXSB ) \ + X("vpmaxsd", 3, (P) aptb3VPMAXSD ) \ + X("vpmaxsw", 3, (P) aptb3VPMAXSW ) \ + X("vpmaxub", 3, (P) aptb3VPMAXUB ) \ + X("vpmaxud", 3, (P) aptb3VPMAXUD ) \ + X("vpmaxuw", 3, (P) aptb3VPMAXUW ) \ + X("vpminsb", 3, (P) aptb3VPMINSB ) \ + X("vpminsd", 3, (P) aptb3VPMINSD ) \ + X("vpminsw", 3, (P) aptb3VPMINSW ) \ + X("vpminub", 3, (P) aptb3VPMINUB ) \ + X("vpminud", 3, (P) aptb3VPMINUD ) \ + X("vpminuw", 3, (P) aptb3VPMINUW ) \ + X("vpmovmskb", 2, (P) aptb2VPMOVMSKB ) \ + X("vpmovsxbd", 2, (P) aptb2VPMOVSXBD ) \ + X("vpmovsxbq", 2, (P) aptb2VPMOVSXBQ ) \ + X("vpmovsxbw", 2, (P) aptb2VPMOVSXBW ) \ + X("vpmovsxdq", 2, (P) aptb2VPMOVSXDQ ) \ + X("vpmovsxwd", 2, (P) aptb2VPMOVSXWD ) \ + X("vpmovsxwq", 2, (P) aptb2VPMOVSXWQ ) \ + X("vpmovzxbd", 2, (P) aptb2VPMOVZXBD ) \ + X("vpmovzxbq", 2, (P) aptb2VPMOVZXBQ ) \ + X("vpmovzxbw", 2, (P) aptb2VPMOVZXBW ) \ + X("vpmovzxdq", 2, (P) aptb2VPMOVZXDQ ) \ + X("vpmovzxwd", 2, (P) aptb2VPMOVZXWD ) \ + X("vpmovzxwq", 2, (P) aptb2VPMOVZXWQ ) \ + X("vpmulhrsw", 3, (P) aptb3VPMULHRSW ) \ + X("vpmulhuw", 3, (P) aptb3VPMULHUW ) \ + X("vpmulhw", 3, (P) aptb3VPMULHW ) \ + X("vpmulld", 3, (P) aptb3VPMULLD ) \ + X("vpmullw", 3, (P) aptb3VPMULLW ) \ + X("vpmuludq", 3, (P) aptb3VPMULUDQ ) \ + X("vpor", 3, (P) aptb3VPOR ) \ + X("vpsadbw", 3, (P) aptb3VPSADBW ) \ + X("vpshufb", 3, (P) aptb3VPSHUFB ) \ + X("vpshufd", 3, (P) aptb3VPSHUFD ) \ + X("vpshufhw", 3, (P) aptb3VPSHUFHW ) \ + X("vpshuflw", 3, (P) aptb3VPSHUFLW ) \ + X("vpsignb", 3, (P) aptb3VPSIGNB ) \ + X("vpsignd", 3, (P) aptb3VPSIGND ) \ + X("vpsignw", 3, (P) aptb3VPSIGNW ) \ + X("vpslld", 3, (P) aptb3VPSLLD ) \ + X("vpslldq", 3, (P) aptb3VPSLLDQ ) \ + X("vpsllq", 3, (P) aptb3VPSLLQ ) \ + X("vpsllw", 3, (P) aptb3VPSLLW ) \ + X("vpsrad", 3, (P) aptb3VPSRAD ) \ + X("vpsraw", 3, (P) aptb3VPSRAW ) \ + X("vpsrld", 3, (P) aptb3VPSRLD ) \ + X("vpsrldq", 3, (P) aptb3VPSRLDQ ) \ + X("vpsrlq", 3, (P) aptb3VPSRLQ ) \ + X("vpsrlw", 3, (P) aptb3VPSRLW ) \ + X("vpsubb", 3, (P) aptb3VPSUBB ) \ + X("vpsubd", 3, (P) aptb3VPSUBD ) \ + X("vpsubq", 3, (P) aptb3VPSUBQ ) \ + X("vpsubsb", 3, (P) aptb3VPSUBSB ) \ + X("vpsubsw", 3, (P) aptb3VPSUBSW ) \ + X("vpsubusb", 3, (P) aptb3VPSUBUSB ) \ + X("vpsubusw", 3, (P) aptb3VPSUBUSW ) \ + X("vpsubw", 3, (P) aptb3VPSUBW ) \ + X("vptest", 2, (P) aptb2VPTEST ) \ + X("vpunpckhbw", 3, (P) aptb3VPUNPCKHBW ) \ + X("vpunpckhdq", 3, (P) aptb3VPUNPCKHDQ ) \ + X("vpunpckhqdq", 3, (P) aptb3VPUNPCKHQDQ ) \ + X("vpunpckhwd", 3, (P) aptb3VPUNPCKHWD ) \ + X("vpunpcklbw", 3, (P) aptb3VPUNPCKLBW ) \ + X("vpunpckldq", 3, (P) aptb3VPUNPCKLDQ ) \ + X("vpunpcklqdq", 3, (P) aptb3VPUNPCKLQDQ ) \ + X("vpunpcklwd", 3, (P) aptb3VPUNPCKLWD ) \ + X("vpxor", 3, (P) aptb3VPXOR ) \ + X("vrcpps", 2, (P) aptb2VRCPPS ) \ + X("vrcpss", 3, (P) aptb3VRCPSS ) \ + X("vroundpd", 3, (P) aptb3VROUNDPD ) \ + X("vroundps", 3, (P) aptb3VROUNDPS ) \ + X("vroundsd", 4, (P) aptb4VROUNDSD ) \ + X("vroundss", 4, (P) aptb4VROUNDSS ) \ + X("vshufpd", 4, (P) aptb4VSHUFPD ) \ + X("vshufps", 4, (P) aptb4VSHUFPS ) \ + X("vsqrtpd", 2, (P) aptb2VSQRTPD ) \ + X("vsqrtps", 2, (P) aptb2VSQRTPS ) \ + X("vsqrtsd", 3, (P) aptb3VSQRTSD ) \ + X("vsqrtss", 3, (P) aptb3VSQRTSS ) \ + X("vstmxcsr", 1, (P) aptb1VSTMXCSR ) \ + X("vsubpd", 3, (P) aptb3VSUBPD ) \ + X("vsubps", 3, (P) aptb3VSUBPS ) \ + X("vsubsd", 3, (P) aptb3VSUBSD ) \ + X("vsubss", 3, (P) aptb3VSUBSS ) \ + X("vucomisd", 2, (P) aptb2VUCOMISD ) \ + X("vucomiss", 2, (P) aptb2VUCOMISS ) \ + X("vunpckhpd", 3, (P) aptb3VUNPCKHPD ) \ + X("vunpckhps", 3, (P) aptb3VUNPCKHPS ) \ + X("vunpcklpd", 3, (P) aptb3VUNPCKLPD ) \ + X("vunpcklps", 3, (P) aptb3VUNPCKLPS ) \ + X("vxorpd", 3, (P) aptb3VXORPD ) \ + X("vxorps", 3, (P) aptb3VXORPS ) \ + X("vzeroall", 0, aptb0VZEROALL ) \ + X("vzeroupper", 0, aptb0VZEROUPPER ) \ + X("wait", 0, aptb0WAIT ) \ + X("wbinvd", 0, aptb0WBINVD ) \ + X("wrfsbase", 1, (P) aptb1WRFSBASE ) \ + X("wrgsbase", 1, (P) aptb1WRGSBASE ) \ + X("wrmsr", 0, aptb0WRMSR ) \ + X("xadd", 2, (P) aptb2XADD ) \ + X("xchg", 2, (P) aptb2XCHG ) \ + X("xgetbv", 0, aptb0XGETBV) \ + X("xlat", ITopt | 1, (P) aptb1XLAT ) \ + X("xlatb", 0, aptb0XLATB ) \ + X("xor", 2, (P) aptb2XOR ) \ + X("xorpd", 2, (P) aptb2XORPD ) \ + X("xorps", 2, (P) aptb2XORPS ) \ + X("xrstor", ITfloat | 1, (P) aptb1XRSTOR ) \ + X("xrstor64", ITfloat | 1, (P) aptb1XRSTOR64 ) \ + X("xsave", ITfloat | 1, (P) aptb1XSAVE ) \ + X("xsave64", ITfloat | 1, (P) aptb1XSAVE64 ) \ + X("xsaveopt", ITfloat | 1, (P) aptb1XSAVEOPT ) \ + X("xsaveopt64", ITfloat | 1, (P) aptb1XSAVEOPT64 ) \ + X("xsetbv", 0, aptb0XSETBV) \ + +#endif + +static const char *opcodestr[] = +{ + #define X(a,b,c) a, + OPCODETABLE1 + OPCODETABLE2 + OPCODETABLE3 + #undef X +}; + +static OP optab[] = +{ + #define X(a,b,c) b,c, + OPCODETABLE1 + OPCODETABLE2 + OPCODETABLE3 + #undef X +}; + + +/******************************* + */ + +const char *asm_opstr(OP *pop) +{ + return opcodestr[pop - optab]; +} + +/******************************* + */ + +OP *asm_op_lookup(const char *s) +{ + int i; + char szBuf[20]; + + //dbg_printf("asm_op_lookup('%s')\n",s); + if (strlen(s) >= sizeof(szBuf)) + return NULL; + strcpy(szBuf,s); +#if SCPP + strlwr(szBuf); +#endif + + i = binary(szBuf,opcodestr,sizeof(opcodestr)/sizeof(opcodestr[0])); + return (i == -1) ? NULL : &optab[i]; +} + +/******************************* + */ + +void init_optab() +{ int i; + +#ifdef DEBUG + for (i = 0; i < arraysize(opcodestr) - 1; i++) + { + if (strcmp(opcodestr[i],opcodestr[i + 1]) >= 0) + { + dbg_printf("opcodestr[%d] = '%s', [%d] = '%s'\n",i,opcodestr[i],i + 1,opcodestr[i + 1]); + assert(0); + } + } +#endif +} + + + +#endif // !SPP diff --git a/backend/rtlsym.c b/backend/rtlsym.c new file mode 100644 index 00000000..3cc54b8e --- /dev/null +++ b/backend/rtlsym.c @@ -0,0 +1,125 @@ +// Copyright (C) 1996-1998 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include "cc.h" +#include "type.h" +#include "oper.h" +#include "global.h" +#include "code.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +Symbol *rtlsym[RTLSYM_MAX]; + +#if MARS +// This varies depending on C ABI +#define FREGSAVED fregsaved +#else +#define FREGSAVED (mBP | mBX | mSI | mDI) +#endif + +static Symbol rtlsym2[RTLSYM_MAX]; + +/****************************************** + * Initialize rtl symbols. + */ + +void rtlsym_init() +{ + static int inited; + + if (!inited) + { inited++; + + //printf("rtlsym_init(%s)\n", regm_str(FREGSAVED)); + + for (int i = 0; i < RTLSYM_MAX; i++) + { + rtlsym[i] = &rtlsym2[i]; +#ifdef DEBUG + rtlsym[i]->id = IDsymbol; +#endif + rtlsym[i]->Stype = tsclib; + rtlsym[i]->Ssymnum = -1; + rtlsym[i]->Sclass = SCextern; + rtlsym[i]->Sfl = FLfunc; +#if ELFOBJ || MACHOBJ + rtlsym[i]->obj_si = (unsigned)-1; + rtlsym[i]->dwarf_off = (unsigned)-1; +#endif + rtlsym[i]->Sregsaved = FREGSAVED; + } + +#if MARS + type *t = type_fake(TYnfunc); + t->Tmangle = mTYman_c; + t->Tcount++; + + // Variadic function + type *tv = type_fake(TYnfunc); + tv->Tmangle = mTYman_c; + tv->Tcount++; +#endif + +#if MACHOBJ + type *tw = type_fake(TYnpfunc); + tw->Tmangle = mTYman_sys; + tw->Tcount++; +#else + type *tw = NULL; +#endif + +#undef SYMBOL_Z +#define SYMBOL_Z(e, fl, saved, n, flags, ty) \ + if (ty) rtlsym[RTLSYM_##e]->Stype = (ty); \ + if ((fl) != FLfunc) rtlsym[RTLSYM_##e]->Sfl = (fl); \ + if (flags) rtlsym[RTLSYM_##e]->Sflags = (flags); \ + if ((saved) != FREGSAVED) rtlsym[RTLSYM_##e]->Sregsaved = (saved); \ + strcpy(rtlsym[RTLSYM_##e]->Sident, (n)); \ + + RTLSYMS + } +} + +/******************************* + * Reset the symbols for the case when we are generating multiple + * .OBJ files from one compile. + */ + +#if MARS + +void rtlsym_reset() +{ int i; + + clib_inited = 0; + for (i = 0; i < RTLSYM_MAX; i++) + { rtlsym[i]->Sxtrnnum = 0; + rtlsym[i]->Stypidx = 0; + } +} + +#endif + +/******************************* + */ + +void rtlsym_term() +{ +} + +#endif diff --git a/backend/rtlsym.h b/backend/rtlsym.h new file mode 100644 index 00000000..89a14bed --- /dev/null +++ b/backend/rtlsym.h @@ -0,0 +1,155 @@ +// Copyright (C) 1994-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +/* + ty + ------------------------------------ + 0 tsclib TYnpfunc, C mangling + t TYnfunc, C mangling + tsjlib TYjfunc, C mangling + tsdlib TYjfunc, C mangling + */ + +#if SCPP +#define SYMBOL_SCPP(e, fl, saved, n, flags, ty) SYMBOL_Z(e,fl,saved,n,flags,ty) +#else +#define SYMBOL_SCPP(e, fl, saved, n, flags, ty) +#endif + +#if SCPP && TX86 +#define SYMBOL_SCPP_TX86(e, fl, saved, n, flags, ty) SYMBOL_Z(e,fl,saved,n,flags,ty) +#else +#define SYMBOL_SCPP_TX86(e, fl, saved, n, flags, ty) +#endif + +#if MARS +#define SYMBOL_MARS(e, fl, saved, n, flags, ty) SYMBOL_Z(e,fl,saved,n,flags,ty) +#else +#define SYMBOL_MARS(e, fl, saved, n, flags, ty) +#endif + + +#define RTLSYMS \ +\ +SYMBOL_MARS(THROW, FLfunc,(mES | mBP),"_d_throw@4", SFLexit, tw) \ +SYMBOL_MARS(THROWC, FLfunc,(mES | mBP),"_d_throwc", SFLexit, t) \ +SYMBOL_MARS(MONITOR_HANDLER, FLfunc,FREGSAVED,"_d_monitor_handler", 0, 0) \ +SYMBOL_MARS(MONITOR_PROLOG, FLfunc,FREGSAVED,"_d_monitor_prolog",0,t) \ +SYMBOL_MARS(MONITOR_EPILOG, FLfunc,FREGSAVED,"_d_monitor_epilog",0,t) \ +SYMBOL_MARS(DCOVER, FLfunc,FREGSAVED,"_d_cover_register", 0, t) \ +SYMBOL_MARS(DASSERT, FLfunc,FREGSAVED,"_d_assert", SFLexit, t) \ +SYMBOL_MARS(DASSERTM, FLfunc,FREGSAVED,"_d_assertm", SFLexit, t) \ +SYMBOL_MARS(DASSERT_MSG, FLfunc,FREGSAVED,"_d_assert_msg", SFLexit, t) \ +SYMBOL_MARS(DUNITTEST, FLfunc,FREGSAVED,"_d_unittest", 0, t) \ +SYMBOL_MARS(DUNITTESTM, FLfunc,FREGSAVED,"_d_unittestm", 0, t) \ +SYMBOL_MARS(DUNITTEST_MSG, FLfunc,FREGSAVED,"_d_unittest_msg", 0, t) \ +SYMBOL_MARS(DARRAY, FLfunc,FREGSAVED,"_d_array_bounds", SFLexit, t) \ +SYMBOL_MARS(DINVARIANT, FLfunc,FREGSAVED,"D9invariant12_d_invariantFC6ObjectZv", 0, tsdlib) \ +SYMBOL_MARS(_DINVARIANT, FLfunc,FREGSAVED,"_D9invariant12_d_invariantFC6ObjectZv", 0, tsdlib) \ +SYMBOL_MARS(MEMCPY, FLfunc,FREGSAVED,"memcpy", 0, t) \ +SYMBOL_MARS(MEMSET8, FLfunc,FREGSAVED,"memset", 0, t) \ +SYMBOL_MARS(MEMSET16, FLfunc,FREGSAVED,"_memset16", 0, t) \ +SYMBOL_MARS(MEMSET32, FLfunc,FREGSAVED,"_memset32", 0, t) \ +SYMBOL_MARS(MEMSET64, FLfunc,FREGSAVED,"_memset64", 0, t) \ +SYMBOL_MARS(MEMSET128, FLfunc,FREGSAVED,"_memset128",0, t) \ +SYMBOL_MARS(MEMSET80, FLfunc,FREGSAVED,"_memset80", 0, t) \ +SYMBOL_MARS(MEMSET160, FLfunc,FREGSAVED,"_memset160",0, t) \ +SYMBOL_MARS(MEMSETFLOAT, FLfunc,FREGSAVED,"_memsetFloat", 0, t) \ +SYMBOL_MARS(MEMSETDOUBLE, FLfunc,FREGSAVED,"_memsetDouble", 0, t) \ +SYMBOL_MARS(MEMSETN, FLfunc,FREGSAVED,"_memsetn", 0, t) \ +SYMBOL_MARS(MODULO, FLfunc,FREGSAVED,"_modulo", 0, t) \ +SYMBOL_MARS(MONITORENTER, FLfunc,FREGSAVED,"_d_monitorenter",0, t) \ +SYMBOL_MARS(MONITOREXIT, FLfunc,FREGSAVED,"_d_monitorexit",0, t) \ +SYMBOL_MARS(CRITICALENTER, FLfunc,FREGSAVED,"_d_criticalenter",0, t) \ +SYMBOL_MARS(CRITICALEXIT, FLfunc,FREGSAVED,"_d_criticalexit",0, t) \ +SYMBOL_MARS(SWITCH_STRING, FLfunc,FREGSAVED,"_d_switch_string", 0, t) \ +SYMBOL_MARS(SWITCH_USTRING,FLfunc,FREGSAVED,"_d_switch_ustring", 0, t) \ +SYMBOL_MARS(SWITCH_DSTRING,FLfunc,FREGSAVED,"_d_switch_dstring", 0, t) \ +SYMBOL_MARS(DSWITCHERR, FLfunc,FREGSAVED,"_d_switch_error", SFLexit, t) \ +SYMBOL_MARS(DHIDDENFUNC, FLfunc,FREGSAVED,"_d_hidden_func", 0, t) \ +SYMBOL_MARS(NEWCLASS, FLfunc,FREGSAVED,"_d_newclass", 0, t) \ +SYMBOL_MARS(NEWARRAYT, FLfunc,FREGSAVED,"_d_newarrayT", 0, t) \ +SYMBOL_MARS(NEWARRAYIT, FLfunc,FREGSAVED,"_d_newarrayiT", 0, t) \ +SYMBOL_MARS(NEWARRAYMT, FLfunc,FREGSAVED,"_d_newarraymT", 0, tv) \ +SYMBOL_MARS(NEWARRAYMIT, FLfunc,FREGSAVED,"_d_newarraymiT", 0, tv) \ +SYMBOL_MARS(ARRAYLITERALT, FLfunc,FREGSAVED,"_d_arrayliteralT", 0, tv) \ +SYMBOL_MARS(ARRAYLITERALTX, FLfunc,FREGSAVED,"_d_arrayliteralTX", 0, t) \ +SYMBOL_MARS(ASSOCARRAYLITERALT, FLfunc,FREGSAVED,"_d_assocarrayliteralT", 0, tv) \ +SYMBOL_MARS(ASSOCARRAYLITERALTX, FLfunc,FREGSAVED,"_d_assocarrayliteralTX", 0, t) \ +SYMBOL_MARS(CALLFINALIZER, FLfunc,FREGSAVED,"_d_callfinalizer", 0, t) \ +SYMBOL_MARS(CALLINTERFACEFINALIZER, FLfunc,FREGSAVED,"_d_callinterfacefinalizer", 0, t) \ +SYMBOL_MARS(DELCLASS, FLfunc,FREGSAVED,"_d_delclass", 0, t) \ +SYMBOL_MARS(DELINTERFACE, FLfunc,FREGSAVED,"_d_delinterface", 0, t) \ +SYMBOL_MARS(ALLOCMEMORY, FLfunc,FREGSAVED,"_d_allocmemory", 0, t) \ +SYMBOL_MARS(DELARRAY, FLfunc,FREGSAVED,"_d_delarray", 0, t) \ +SYMBOL_MARS(DELARRAYT, FLfunc,FREGSAVED,"_d_delarray_t", 0, t) \ +SYMBOL_MARS(DELMEMORY, FLfunc,FREGSAVED,"_d_delmemory", 0, t) \ +SYMBOL_MARS(INTERFACE, FLfunc,FREGSAVED,"_d_interface_vtbl", 0, t) \ +SYMBOL_MARS(DYNAMIC_CAST, FLfunc,FREGSAVED,"_d_dynamic_cast", 0, t) \ +SYMBOL_MARS(INTERFACE_CAST,FLfunc,FREGSAVED,"_d_interface_cast", 0, t) \ +SYMBOL_MARS(FATEXIT, FLfunc,FREGSAVED,"_fatexit", 0, t) \ +SYMBOL_MARS(ARRAYCATT, FLfunc,FREGSAVED,"_d_arraycatT", 0, t) \ +SYMBOL_MARS(ARRAYCATNT, FLfunc,FREGSAVED,"_d_arraycatnT", 0, tv) \ +SYMBOL_MARS(ARRAYAPPENDT, FLfunc,FREGSAVED,"_d_arrayappendT", 0, t) \ +SYMBOL_MARS(ARRAYAPPENDCT, FLfunc,FREGSAVED,"_d_arrayappendcT", 0, tv) \ +SYMBOL_MARS(ARRAYAPPENDCTX, FLfunc,FREGSAVED,"_d_arrayappendcTX", 0, t) \ +SYMBOL_MARS(ARRAYAPPENDCD, FLfunc,FREGSAVED,"_d_arrayappendcd", 0, t) \ +SYMBOL_MARS(ARRAYAPPENDWD, FLfunc,FREGSAVED,"_d_arrayappendwd", 0, t) \ +SYMBOL_MARS(ARRAYSETLENGTHT,FLfunc,FREGSAVED,"_d_arraysetlengthT", 0, t) \ +SYMBOL_MARS(ARRAYSETLENGTHIT,FLfunc,FREGSAVED,"_d_arraysetlengthiT", 0, t) \ +SYMBOL_MARS(ARRAYCOPY, FLfunc,FREGSAVED,"_d_arraycopy", 0, t) \ +SYMBOL_MARS(ARRAYASSIGN, FLfunc,FREGSAVED,"_d_arrayassign", 0, t) \ +SYMBOL_MARS(ARRAYCTOR, FLfunc,FREGSAVED,"_d_arrayctor", 0, t) \ +SYMBOL_MARS(ARRAYSETASSIGN, FLfunc,FREGSAVED,"_d_arraysetassign", 0, t) \ +SYMBOL_MARS(ARRAYSETCTOR, FLfunc,FREGSAVED,"_d_arraysetctor", 0, t) \ +SYMBOL_MARS(ARRAYCAST, FLfunc,FREGSAVED,"_d_arraycast", 0, t) \ +SYMBOL_MARS(ARRAYCAST_FROMBIT, FLfunc,FREGSAVED,"_d_arraycast_frombit", 0, t) \ +SYMBOL_MARS(ARRAYEQ, FLfunc,FREGSAVED,"_adEq", 0, t) \ +SYMBOL_MARS(ARRAYEQ2, FLfunc,FREGSAVED,"_adEq2", 0, t) \ +SYMBOL_MARS(ARRAYEQBIT, FLfunc,FREGSAVED,"_adEqBit", 0, t) \ +SYMBOL_MARS(ARRAYCMP, FLfunc,FREGSAVED,"_adCmp", 0, t) \ +SYMBOL_MARS(ARRAYCMP2, FLfunc,FREGSAVED,"_adCmp2", 0, t) \ +SYMBOL_MARS(ARRAYCMPCHAR, FLfunc,FREGSAVED,"_adCmpChar", 0, t) \ +SYMBOL_MARS(ARRAYCMPBIT, FLfunc,FREGSAVED,"_adCmpBit", 0, t) \ +SYMBOL_MARS(OBJ_EQ, FLfunc,FREGSAVED,"_d_obj_eq", 0, t) \ +SYMBOL_MARS(OBJ_CMP, FLfunc,FREGSAVED,"_d_obj_cmp", 0, t) \ +\ +SYMBOL_Z(EXCEPT_HANDLER2, FLfunc,fregsaved,"_except_handler2", 0, 0) \ +SYMBOL_Z(EXCEPT_HANDLER3, FLfunc,fregsaved,"_except_handler3", 0, 0) \ +SYMBOL_SCPP(CPP_HANDLER, FLfunc,FREGSAVED,"_cpp_framehandler", 0, 0) \ +SYMBOL_MARS(CPP_HANDLER, FLfunc,FREGSAVED,"_d_framehandler", 0, 0) \ +SYMBOL_MARS(D_LOCAL_UNWIND2, FLfunc,FREGSAVED,"_d_local_unwind2", 0, 0) \ +SYMBOL_SCPP(LOCAL_UNWIND2, FLfunc,FREGSAVED,"_local_unwind2", 0, 0) \ +\ +SYMBOL_Z(TLS_INDEX, FLextern,0,"_tls_index",0,tsint) \ +SYMBOL_Z(TLS_ARRAY, FLextern,0,"_tls_array",0,tsint) \ +SYMBOL_SCPP(AHSHIFT, FLfunc,0,"_AHSHIFT",0,tstrace) \ +\ +SYMBOL_SCPP_TX86(HDIFFN, FLfunc,mBX|mCX|mSI|mDI|mBP|mES,"_aNahdiff", 0, 0) \ +SYMBOL_SCPP_TX86(HDIFFF, FLfunc,mBX|mCX|mSI|mDI|mBP|mES,"_aFahdiff", 0, 0) \ +\ +SYMBOL_Z(EXCEPT_LIST, FLextern,0,"_except_list",0,tsint) \ +SYMBOL_Z(SETJMP3, FLfunc,FREGSAVED,"_setjmp3", 0, 0) \ +SYMBOL_Z(LONGJMP, FLfunc,FREGSAVED,"_seh_longjmp_unwind@4", 0, 0) \ +SYMBOL_Z(INTONLY, FLfunc,mSI|mDI,"_intonly", 0, 0) \ +SYMBOL_Z(ALLOCA, FLfunc,fregsaved,"__alloca", 0, 0) \ +SYMBOL_Z(CPP_LONGJMP, FLfunc,FREGSAVED,"_cpp_longjmp_unwind@4", 0, 0) \ +SYMBOL_Z(PTRCHK, FLfunc,fregsaved,"_ptrchk", 0, 0) \ +SYMBOL_Z(CHKSTK, FLfunc,fregsaved,"_chkstk", 0, 0) \ +SYMBOL_Z(TRACE_PRO_N, FLfunc,ALLREGS|mBP|mES,"_trace_pro_n",0,tstrace) \ +SYMBOL_Z(TRACE_PRO_F, FLfunc,ALLREGS|mBP|mES,"_trace_pro_f",0,tstrace) \ +SYMBOL_Z(TRACE_EPI_N, FLfunc,ALLREGS|mBP|mES,"_trace_epi_n",0,tstrace) \ +SYMBOL_Z(TRACE_EPI_F, FLfunc,ALLREGS|mBP|mES,"_trace_epi_f",0,tstrace) \ + + + diff --git a/backend/strtold.c b/backend/strtold.c new file mode 100644 index 00000000..190d5577 --- /dev/null +++ b/backend/strtold.c @@ -0,0 +1,712 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include +#include +#include +#include +#include +#include +#if _WIN32 +#include +#include +#endif +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#endif + +#if _WIN32 +// from \sc\src\include\setlocal.h +extern char * __cdecl __locale_decpoint; +void __pascal __set_errno (int an_errno); +#endif + +#if _WIN32 || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + +#if 0 +/* This is for compilers that don't support hex float literals, + * and also makes it clearer what constants we're trying to use. + */ + +static long double negtab[] = + {1e-4096L,1e-2048L,1e-1024L,1e-512L, + 1e-256L,1e-128L,1e-64L,1e-32L,1e-16L,1e-8L,1e-4L,1e-2L,1e-1L,1.0L}; + +static long double postab[] = + {1e+4096L,1e+2048L,1e+1024L,1e+512L, + 1e+256L,1e+128L,1e+64L,1e+32L,1e+16L,1e+8L,1e+4L,1e+2L,1e+1L}; + +#elif defined(__GNUC__) && __FreeBSD__ && __i386__ + +// GCC on FreeBSD/i386 incorrectly rounds long double constants to double precision. Workaround: + +// Note that the [sizeof(long double)] takes care of whatever the 0 padding is for the +// target platform + +static unsigned char _negtab_bytes[][sizeof(long double)] = + { { 0xDE,0x9F,0xCE,0xD2,0xC8,0x04,0xDD,0xA6,0xD8,0x0A,0xBF,0xBF }, + { 0xE4,0x2D,0x36,0x34,0x4F,0x53,0xAE,0xCE,0x6B,0x25,0xBF,0xBF }, + { 0xBE,0xC0,0x57,0xDA,0xA5,0x82,0xA6,0xA2,0xB5,0x32,0xBF,0xBF }, + { 0x1C,0xD2,0x23,0xDB,0x32,0xEE,0x49,0x90,0x5A,0x39,0xBF,0xBF }, + { 0x3A,0x19,0x7A,0x63,0x25,0x43,0x31,0xC0,0xAC,0x3C,0xBF,0xBF }, + { 0xA1,0xE4,0xBC,0x64,0x7C,0x46,0xD0,0xDD,0x55,0x3E,0xBF,0xBF }, + { 0xA5,0xE9,0x39,0xA5,0x27,0xEA,0x7F,0xA8,0x2A,0x3F,0xBF,0xBF }, + { 0xBA,0x94,0x39,0x45,0xAD,0x1E,0xB1,0xCF,0x94,0x3F,0xBF,0xBF }, + { 0x5B,0xE1,0x4D,0xC4,0xBE,0x94,0x95,0xE6,0xC9,0x3F,0xBF,0xBF }, + { 0xFD,0xCE,0x61,0x84,0x11,0x77,0xCC,0xAB,0xE4,0x3F,0xBF,0xBF }, + { 0x2C,0x65,0x19,0xE2,0x58,0x17,0xB7,0xD1,0xF1,0x3F,0xBF,0xBF }, + { 0x0A,0xD7,0xA3,0x70,0x3D,0x0A,0xD7,0xA3,0xF8,0x3F,0xBF,0xBF }, + { 0xCD,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFB,0x3F,0xBF,0xBF }, + { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x3F,0xBF,0xBF } }; + +static unsigned char _postab_bytes[][sizeof(long double)] = + { { 0x9B,0x97,0x20,0x8A,0x02,0x52,0x60,0xC4,0x25,0x75,0x18,0x28 }, + { 0xE5,0x5D,0x3D,0xC5,0x5D,0x3B,0x8B,0x9E,0x92,0x5A,0x18,0x28 }, + { 0x17,0x0C,0x75,0x81,0x86,0x75,0x76,0xC9,0x48,0x4D,0x18,0x28 }, + { 0xC7,0x91,0x0E,0xA6,0xAE,0xA0,0x19,0xE3,0xA3,0x46,0x18,0x28 }, + { 0x8E,0xDE,0xF9,0x9D,0xFB,0xEB,0x7E,0xAA,0x51,0x43,0x18,0x28 }, + { 0xE0,0x8C,0xE9,0x80,0xC9,0x47,0xBA,0x93,0xA8,0x41,0x18,0x28 }, + { 0xD5,0xA6,0xCF,0xFF,0x49,0x1F,0x78,0xC2,0xD3,0x40,0x18,0x28 }, + { 0x9E,0xB5,0x70,0x2B,0xA8,0xAD,0xC5,0x9D,0x69,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x04,0xBF,0xC9,0x1B,0x8E,0x34,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x00,0x00,0x20,0xBC,0xBE,0x19,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x9C,0x0C,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC8,0x05,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA0,0x02,0x40,0x18,0x28 }, + { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x3F,0x18,0x28 } }; + +static long double *negtab = (long double *) _negtab_bytes; +static long double *postab = (long double *) _postab_bytes; + +#else + +// Use exact values, computed separately, to bootstrap. +// The digits here past 17 are just for amusement value, they +// only contribute to the 'sticky' bit. + +static long double negtab[] = +{ + 1 / 0x62.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, + 1 / 0x9.e8b3b5dc53d5de4a74d28ce329ace526a3197bbebe3034f77154ce2bcba19648b21c11eb962b1b61b93cf2ee5ca6f7e928e61d08e2d694222771e50f30278c9836230af908b40a753b7d77cd8c6be7151aab4efac5dcd83e49d6907855eeb028af623f6f7024d2c36fa9ce9d04a487fa1fb992be221ef1bd0ad5f775677ce0de08402ad3fa140eac7d56c7c9dee0bedd8a6c038f9245b2e87c348ad803ecca8f0070f8dbb57a6a445f278b3d5cf42915e818415c7f3ef82df84658ccf45cfad379433f3389a4408f43c513ef5a83fb8886fbf56d9d4bd5f860792e55ecee70beb1810d76ce39de9ec24bcf99d01953761abd9d7389c0a244de3c195355d84eeebeee6f46eadb56c6815b785ce6b7b125ac8edb0708fd8f6cae5f5715f7915b33eb417bf03c19d7917c7ba1fc6b9681428c85744695f0e866d7efc9ac375d77c1a42f40660460944545ff87a7dc62d752f7a66a57b1ab730f203c1aa9f44484d80e2e5fc5a04779c56b8a9e110c7bcbea4ca7982da4663cfe491d0dbd21feab49869733554c36685e5510c4a656654419bd438e48ff35d6c7d6ab91bac974fb1264b4f111821fa2bca416afe609c313b41e449952fbed5a151440967abbb3a8281ed6a8f16f9210c17f94e3892ee98074ff01e3cb64f32dbb6643a7a8289c8c6c54de34c101349713b44938209ce1f3861ce0fb7fedcc235552eb57a7842d71c7fd8f66912e4ad2f869c29279498719342c12866ed6f1c850dabc98342c9e51b78db2ea50d142fd8277732ed56d55a5e5a191368b8abbb6067584ee87e354ec2e472149e28dcfb27d4d3fe30968651333e001p+6800L, + 1 / 0x3.25d9d61a05d4305d9434f4a3c62d433949ae6209d4926c3f5bd2db49ef47187094c1a6970ca7e6bd2a73c5534936a8de061e8d4649f4f3235e005b80411640114a88bc491b9fc4ed520190fba035faaba6c356e38a31b5653f445975836cb0b6c975a351a28e4262ce3ce3a0b8df68368ae26a7b7e976a3310fc8f1f9031eb0f669a20288280bda5a580d98089dc1a47fe6b7595fb101a3616b6f4654b31fb6bfdf56deeecb1b896bc8fc51a16bf3fdeb3d814b505ba34c4118ad822a51abe1de3045b7a748e1042c462be695a9f9f2a07a7e89431922bbb9fc96359861c5cd134f451218b65dc60d7233e55c7231d2b9c9fce837d1e43f61f7de16cfb896634ee0ed1440ecc2cd8194c7d1e1a140ac53515c51a88991c4e871ec29f866e7c215bf55b2b722919f001p+3400L, + 1 / 0x1c.633415d4c1d238d98cab8a978a0b1f138cb07303a269974845a71d46b099bc817343afac69be5b0e9449775c1366732a93abade4b2908ee0f95f635e85a91924c3fc0695e7fc7153329c57aebfa3edac96e14f5dbc51fb2eb21a2f221e25cfea703ed321aa1da1bf28f8733b4475b579c88976c194e6574746c40513c31e1ad9b83a8a975d96976f8f9546dc77f27267fc6cf801p+1696L, + 1 / 0x5.53f75fdcefcef46eeddc80dcc7f755bc28f265f9ef17cc5573c063ff540e3c42d35a1d153624adc666b026b2716ed595d80fcf4a6e706bde50c612152f87d8d99f72bed3875b982e7c01p+848L, + 1 / 0x2.4ee91f2603a6337f19bccdb0dac404dc08d3cff5ec2374e42f0f1538fd03df99092e953e01p+424L, + 1 / 0x18.4f03e93ff9f4daa797ed6e38ed64bf6a1f01p+208L, + 1 / 0x4.ee2d6d415b85acef81p+104L, + 1 / 0x23.86f26fc1p+48L, + 1 / 0x5.f5e1p+24L, + 1 / 0x27.10p+8L, + 1 / 0x64.p+0L, + 1 / 0xa.p+0L, +}; + +static long double postab[] = +{ + 0x62.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, + 0x9.e8b3b5dc53d5de4a74d28ce329ace526a3197bbebe3034f77154ce2bcba19648b21c11eb962b1b61b93cf2ee5ca6f7e928e61d08e2d694222771e50f30278c9836230af908b40a753b7d77cd8c6be7151aab4efac5dcd83e49d6907855eeb028af623f6f7024d2c36fa9ce9d04a487fa1fb992be221ef1bd0ad5f775677ce0de08402ad3fa140eac7d56c7c9dee0bedd8a6c038f9245b2e87c348ad803ecca8f0070f8dbb57a6a445f278b3d5cf42915e818415c7f3ef82df84658ccf45cfad379433f3389a4408f43c513ef5a83fb8886fbf56d9d4bd5f860792e55ecee70beb1810d76ce39de9ec24bcf99d01953761abd9d7389c0a244de3c195355d84eeebeee6f46eadb56c6815b785ce6b7b125ac8edb0708fd8f6cae5f5715f7915b33eb417bf03c19d7917c7ba1fc6b9681428c85744695f0e866d7efc9ac375d77c1a42f40660460944545ff87a7dc62d752f7a66a57b1ab730f203c1aa9f44484d80e2e5fc5a04779c56b8a9e110c7bcbea4ca7982da4663cfe491d0dbd21feab49869733554c36685e5510c4a656654419bd438e48ff35d6c7d6ab91bac974fb1264b4f111821fa2bca416afe609c313b41e449952fbed5a151440967abbb3a8281ed6a8f16f9210c17f94e3892ee98074ff01e3cb64f32dbb6643a7a8289c8c6c54de34c101349713b44938209ce1f3861ce0fb7fedcc235552eb57a7842d71c7fd8f66912e4ad2f869c29279498719342c12866ed6f1c850dabc98342c9e51b78db2ea50d142fd8277732ed56d55a5e5a191368b8abbb6067584ee87e354ec2e472149e28dcfb27d4d3fe30968651333e001p+6800L, + 0x3.25d9d61a05d4305d9434f4a3c62d433949ae6209d4926c3f5bd2db49ef47187094c1a6970ca7e6bd2a73c5534936a8de061e8d4649f4f3235e005b80411640114a88bc491b9fc4ed520190fba035faaba6c356e38a31b5653f445975836cb0b6c975a351a28e4262ce3ce3a0b8df68368ae26a7b7e976a3310fc8f1f9031eb0f669a20288280bda5a580d98089dc1a47fe6b7595fb101a3616b6f4654b31fb6bfdf56deeecb1b896bc8fc51a16bf3fdeb3d814b505ba34c4118ad822a51abe1de3045b7a748e1042c462be695a9f9f2a07a7e89431922bbb9fc96359861c5cd134f451218b65dc60d7233e55c7231d2b9c9fce837d1e43f61f7de16cfb896634ee0ed1440ecc2cd8194c7d1e1a140ac53515c51a88991c4e871ec29f866e7c215bf55b2b722919f001p+3400L, + 0x1c.633415d4c1d238d98cab8a978a0b1f138cb07303a269974845a71d46b099bc817343afac69be5b0e9449775c1366732a93abade4b2908ee0f95f635e85a91924c3fc0695e7fc7153329c57aebfa3edac96e14f5dbc51fb2eb21a2f221e25cfea703ed321aa1da1bf28f8733b4475b579c88976c194e6574746c40513c31e1ad9b83a8a975d96976f8f9546dc77f27267fc6cf801p+1696L, + 0x5.53f75fdcefcef46eeddc80dcc7f755bc28f265f9ef17cc5573c063ff540e3c42d35a1d153624adc666b026b2716ed595d80fcf4a6e706bde50c612152f87d8d99f72bed3875b982e7c01p+848L, + 0x2.4ee91f2603a6337f19bccdb0dac404dc08d3cff5ec2374e42f0f1538fd03df99092e953e01p+424L, + 0x18.4f03e93ff9f4daa797ed6e38ed64bf6a1f01p+208L, + 0x4.ee2d6d415b85acef81p+104L, + 0x23.86f26fc1p+48L, + 0x5.f5e1p+24L, + 0x27.10p+8L, + 0x64.p+0L, + 0xa.p+0L, +}; + +#endif + +/************************* + * Convert string to double. + * Terminates on first unrecognized character. + */ + +long double strtold(const char *p,char **endp) +{ + long double ldval; + int exp; + long long msdec,lsdec; + unsigned long msscale; + char dot,sign; + int pow; + int ndigits; + const char *pinit = p; + static char infinity[] = "infinity"; + static char nans[] = "nans"; + unsigned int old_cw; + unsigned int old_status; + +#if _WIN32 + fenv_t flagp; + fegetenv(&flagp); /* Store all exceptions, and current status word */ + if (_8087) + { + // disable exceptions from occurring, set max precision, and round to nearest +#if __DMC__ + __asm + { + fstcw word ptr old_cw + mov EAX,old_cw + mov ECX,EAX + and EAX,0xf0c0 + or EAX,033fh + mov old_cw,EAX + fldcw word ptr old_cw + mov old_cw,ECX + } +#else + old_cw = _control87(_MCW_EM | _PC_64 | _RC_NEAR, + _MCW_EM | _MCW_PC | _MCW_RC); +#endif + } +#endif + + while (isspace(*p)) + p++; + sign = 0; /* indicating + */ + switch (*p) + { case '-': + sign++; + /* FALL-THROUGH */ + case '+': + p++; + } + ldval = 0.0; + dot = 0; /* if decimal point has been seen */ + exp = 0; + msdec = lsdec = 0; + msscale = 1; + ndigits = 0; + +#if __DMC__ + switch (*p) + { case 'i': + case 'I': + if (memicmp(p,infinity,8) == 0) + { p += 8; + goto L4; + } + if (memicmp(p,infinity,3) == 0) /* is it "inf"? */ + { p += 3; + L4: + ldval = HUGE_VAL; + goto L3; + } + break; + case 'n': + case 'N': + if (memicmp(p,nans,4) == 0) /* "nans"? */ + { p += 4; + ldval = NANS; + goto L5; + } + if (memicmp(p,nans,3) == 0) /* "nan"? */ + { p += 3; + ldval = NAN; + L5: + if (*p == '(') /* if (n-char-sequence) */ + goto Lerr; /* invalid input */ + goto L3; + } + } +#endif + + if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) + { int guard = 0; + int anydigits = 0; + + p += 2; + while (1) + { int i = *p; + + while (isxdigit(i)) + { + anydigits = 1; + i = isalpha(i) ? ((i & ~0x20) - ('A' - 10)) : i - '0'; + if (ndigits < 16) + { + msdec = msdec * 16 + i; + if (msdec) + ndigits++; + } + else if (ndigits == 16) + { + while (msdec >= 0) + { + exp--; + msdec <<= 1; + i <<= 1; + if (i & 0x10) + msdec |= 1; + } + guard = i << 4; + ndigits++; + exp += 4; + } + else + { + guard |= i; + exp += 4; + } + exp -= dot; + i = *++p; + } +#ifdef _WIN32 + if (i == *__locale_decpoint && !dot) +#else + if (i == '.' && !dot) +#endif + { p++; + dot = 4; + } + else + break; + } + + // Round up if (guard && (sticky || odd)) + if (guard & 0x80 && (guard & 0x7F || msdec & 1)) + { + msdec++; + if (msdec == 0) // overflow + { msdec = 0x8000000000000000LL; + exp++; + } + } + + if (anydigits == 0) // if error (no digits seen) + goto Lerr; + if (*p == 'p' || *p == 'P') + { + char sexp; + int e; + + sexp = 0; + switch (*++p) + { case '-': sexp++; + case '+': p++; + } + ndigits = 0; + e = 0; + while (isdigit(*p)) + { + if (e < 0x7FFFFFFF / 10 - 10) // prevent integer overflow + { + e = e * 10 + *p - '0'; + } + p++; + ndigits = 1; + } + exp += (sexp) ? -e : e; + if (!ndigits) // if no digits in exponent + goto Lerr; + + if (msdec) + { +#if __DMC__ + // The 8087 has no instruction to load an + // unsigned long long + if (msdec < 0) + { + *(long long *)&ldval = msdec; + ((unsigned short *)&ldval)[4] = 0x3FFF + 63; + } + else + { // But does for a signed one + __asm + { + fild qword ptr msdec + fstp tbyte ptr ldval + } + } +#else + int e2 = 0x3FFF + 63; + + // left justify mantissa + while (msdec >= 0) + { msdec <<= 1; + e2--; + } + + // Stuff mantissa directly into long double + *(long long *)&ldval = msdec; + ((unsigned short *)&ldval)[4] = e2; +#endif + +#if 0 + if (0) + { int i; + printf("msdec = x%llx, ldval = %Lg\n", msdec, ldval); + for (i = 0; i < 5; i++) + printf("%04x ",((unsigned short *)&ldval)[i]); + printf("\n"); + printf("%llx\n",ldval); + } +#endif + // Exponent is power of 2, not power of 10 +#if _WIN32 && __DMC__ + __asm + { + fild dword ptr exp + fld tbyte ptr ldval + fscale // ST(0) = ST(0) * (2**ST(1)) + fstp ST(1) + fstp tbyte ptr ldval + } +#else + ldval = ldexpl(ldval,exp); +#endif + } + goto L6; + } + else + goto Lerr; // exponent is required + } + else + { + while (1) + { int i = *p; + + while (isdigit(i)) + { + ndigits = 1; /* must have at least 1 digit */ + if (msdec < (0x7FFFFFFFFFFFLL-10)/10) + msdec = msdec * 10 + (i - '0'); + else if (msscale < (0xFFFFFFFF-10)/10) + { lsdec = lsdec * 10 + (i - '0'); + msscale *= 10; + } + else + { + exp++; + } + exp -= dot; + i = *++p; + } +#if _WIN32 + if (i == *__locale_decpoint && !dot) +#else + if (i == '.' && !dot) +#endif + { p++; + dot++; + } + else + break; + } + if (!ndigits) // if error (no digits seen) + goto Lerr; // return 0.0 + } + if (*p == 'e' || *p == 'E') + { + char sexp; + int e; + + sexp = 0; + switch (*++p) + { case '-': sexp++; + case '+': p++; + } + ndigits = 0; + e = 0; + while (isdigit(*p)) + { + if (e < 0x7FFFFFFF / 10 - 10) // prevent integer overflow + { + e = e * 10 + *p - '0'; + } + p++; + ndigits = 1; + } + exp += (sexp) ? -e : e; + if (!ndigits) // if no digits in exponent + goto Lerr; // return 0.0 + } + +#if _WIN32 + __asm + { + fild qword ptr msdec + mov EAX,msscale + cmp EAX,1 + je La1 + fild long ptr msscale + fmul + fild qword ptr lsdec + fadd + La1: + fstp tbyte ptr ldval + } +#else + ldval = msdec; + if (msscale != 1) /* if stuff was accumulated in lsdec */ + ldval = ldval * msscale + lsdec; +#endif + if (ldval) + { unsigned u; + + u = 0; + pow = 4096; + +#if _WIN32 + //printf("msdec = x%x, lsdec = x%x, msscale = x%x\n",msdec,lsdec,msscale); + //printf("dval = %g, x%llx, exp = %d\n",dval,dval,exp); + __asm fld tbyte ptr ldval +#endif + + while (exp > 0) + { + while (exp >= pow) + { +#if _WIN32 + __asm + { + mov EAX,u + imul EAX,10 + fld tbyte ptr postab[EAX] + fmul + } +#else + ldval *= postab[u]; +#endif + exp -= pow; + } + pow >>= 1; + u++; + } +#if _WIN32 + __asm fstp tbyte ptr ldval +#endif + while (exp < 0) + { while (exp <= -pow) + { +#if _WIN32 + __asm + { + mov EAX,u + imul EAX,10 + fld tbyte ptr ldval + fld tbyte ptr negtab[EAX] + fmul + fstp tbyte ptr ldval + } +#else + ldval *= negtab[u]; +#endif + if (ldval == 0) +#if _WIN32 + __set_errno (ERANGE); +#else + errno = ERANGE; +#endif + exp += pow; + } + pow >>= 1; + u++; + } +#if 0 + if (0) + { int i; + for (i = 0; i < 5; i++) + printf("%04x ",ldval.value[i]); + printf("\n"); + printf("%llx\n",dval); + } +#endif + } + L6: // if overflow occurred + if (ldval == HUGE_VAL) +#if _WIN32 + __set_errno (ERANGE); // range error +#else + errno = ERANGE; +#endif + + L1: + if (endp) + { + *endp = (char *) p; + } + L3: +#if _WIN32 + fesetenv(&flagp); // reset floating point environment + if (_8087) + { + __asm + { + xor EAX,EAX + fstsw AX + fclex + fldcw word ptr old_cw + } + } +#endif + + return (sign) ? -ldval : ldval; + + Lerr: + p = pinit; + goto L1; +} + +#else + +long double strtold(const char *p,char **endp) +{ + return strtod(p, endp); +} + +#endif + +/************************* Test ************************************/ + +#if 0 + +#include +#include +#include + +extern "C" long double strtold(const char *p,char **endp); + +struct longdouble +{ + unsigned short value[5]; +}; + +void main() +{ + long double ld; + struct longdouble x; + int i; + + errno = 0; +// ld = strtold("0x1.FFFFFFFFFFFFFFFEp16383", NULL); + ld = strtold("0x1.FFFFFFFFFFFFFFFEp-16382", NULL); + x = *(struct longdouble *)&ld; + for (i = 4; i >= 0; i--) + { + printf("%04x ", x.value[i]); + } + printf("\t%d\n", errno); + + ld = strtold("1.0e5", NULL); + x = *(struct longdouble *)&ld; + for (i = 4; i >= 0; i--) + { + printf("%04x ", x.value[i]); + } + printf("\n"); +} + +#endif + +/************************* Bigint ************************************/ + +#if 0 + +/* This program computes powers of 10 exactly. + * Used to generate postab[]. + */ + + +#include +#include +#include + +#define NDIGITS 4096 + +void times10(unsigned *a) +{ + int i; + + for (i = 0; i < NDIGITS; i++) + { + a[i] *= 10; + if (i) + { + a[i] += a[i - 1] >> 8; + a[i - 1] &= 0xFF; + } + } +} + +void print(unsigned *a) +{ + int i; + int p; + int j; + + for (i = NDIGITS; i; ) + { + --i; + if (a[i]) + break; + } + + printf("0x%x.", a[i]); + p = i * 8; + i--; + for (j = 0; j < i; j++) + if (a[j]) + break; + for (; i >= j; i--) + { + printf("%02x", a[i]); + } + printf("p+%d", p); +} + +void main() +{ + unsigned a[NDIGITS]; + int i; + int j; + + static long double tab[] = + { + 0x62.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, + 0x9.e8b3b5dc53d5de4a74d28ce329ace526a3197bbebe3034f77154ce2bcba19648b21c11eb962b1b61b93cf2ee5ca6f7e928e61d08e2d694222771e50f30278c9836230af908b40a753b7d77cd8c6be7151aab4efac5dcd83e49d6907855eeb028af623f6f7024d2c36fa9ce9d04a487fa1fb992be221ef1bd0ad5f775677ce0de08402ad3fa140eac7d56c7c9dee0bedd8a6c038f9245b2e87c348ad803ecca8f0070f8dbb57a6a445f278b3d5cf42915e818415c7f3ef82df84658ccf45cfad379433f3389a4408f43c513ef5a83fb8886fbf56d9d4bd5f860792e55ecee70beb1810d76ce39de9ec24bcf99d01953761abd9d7389c0a244de3c195355d84eeebeee6f46eadb56c6815b785ce6b7b125ac8edb0708fd8f6cae5f5715f7915b33eb417bf03c19d7917c7ba1fc6b9681428c85744695f0e866d7efc9ac375d77c1a42f40660460944545ff87a7dc62d752f7a66a57b1ab730f203c1aa9f44484d80e2e5fc5a04779c56b8a9e110c7bcbea4ca7982da4663cfe491d0dbd21feab49869733554c36685e5510c4a656654419bd438e48ff35d6c7d6ab91bac974fb1264b4f111821fa2bca416afe609c313b41e449952fbed5a151440967abbb3a8281ed6a8f16f9210c17f94e3892ee98074ff01e3cb64f32dbb6643a7a8289c8c6c54de34c101349713b44938209ce1f3861ce0fb7fedcc235552eb57a7842d71c7fd8f66912e4ad2f869c29279498719342c12866ed6f1c850dabc98342c9e51b78db2ea50d142fd8277732ed56d55a5e5a191368b8abbb6067584ee87e354ec2e472149e28dcfb27d4d3fe30968651333e001p+6800L, + 0x3.25d9d61a05d4305d9434f4a3c62d433949ae6209d4926c3f5bd2db49ef47187094c1a6970ca7e6bd2a73c5534936a8de061e8d4649f4f3235e005b80411640114a88bc491b9fc4ed520190fba035faaba6c356e38a31b5653f445975836cb0b6c975a351a28e4262ce3ce3a0b8df68368ae26a7b7e976a3310fc8f1f9031eb0f669a20288280bda5a580d98089dc1a47fe6b7595fb101a3616b6f4654b31fb6bfdf56deeecb1b896bc8fc51a16bf3fdeb3d814b505ba34c4118ad822a51abe1de3045b7a748e1042c462be695a9f9f2a07a7e89431922bbb9fc96359861c5cd134f451218b65dc60d7233e55c7231d2b9c9fce837d1e43f61f7de16cfb896634ee0ed1440ecc2cd8194c7d1e1a140ac53515c51a88991c4e871ec29f866e7c215bf55b2b722919f001p+3400L, + 0x1c.633415d4c1d238d98cab8a978a0b1f138cb07303a269974845a71d46b099bc817343afac69be5b0e9449775c1366732a93abade4b2908ee0f95f635e85a91924c3fc0695e7fc7153329c57aebfa3edac96e14f5dbc51fb2eb21a2f221e25cfea703ed321aa1da1bf28f8733b4475b579c88976c194e6574746c40513c31e1ad9b83a8a975d96976f8f9546dc77f27267fc6cf801p+1696L, + 0x5.53f75fdcefcef46eeddc80dcc7f755bc28f265f9ef17cc5573c063ff540e3c42d35a1d153624adc666b026b2716ed595d80fcf4a6e706bde50c612152f87d8d99f72bed3875b982e7c01p+848L, + 0x2.4ee91f2603a6337f19bccdb0dac404dc08d3cff5ec2374e42f0f1538fd03df99092e953e01p+424L, + 0x18.4f03e93ff9f4daa797ed6e38ed64bf6a1f01p+208L, + 0x4.ee2d6d415b85acef81p+104L, + 0x23.86f26fc1p+48L, + 0x5.f5e1p+24L, + 0x27.10p+8L, + 0x64.p+0L, + 0xa.p+0L, + }; + + for (j = 1; j <= 4096; j *= 2) + { + printf("%4d: ", j); + memset(a, 0, sizeof(a)); + a[0] = 1; + for (i = 0; i < j; i++) + times10(a); + print(a); + printf("L,\n"); + } + + for (i = 0; i < 13; i++) + { + printf("tab[%d] = %Lg\n", i, tab[i]); + } +} + +#endif + diff --git a/backend/symbol.c b/backend/symbol.c new file mode 100644 index 00000000..8c413631 --- /dev/null +++ b/backend/symbol.c @@ -0,0 +1,2307 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include +#include + +#include "cc.h" +#include "global.h" +#include "type.h" +#include "dt.h" +#if TX86 +#include "cgcv.h" +#endif + +#include "el.h" +#include "oper.h" /* for OPMAX */ +#include "token.h" + +#if SCPP +#include "parser.h" +#include "cpp.h" +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +//STATIC void symbol_undef(symbol *s); +STATIC void symbol_freemember(symbol *s); +STATIC void mptr_hydrate(mptr_t **); +STATIC void mptr_dehydrate(mptr_t **); +STATIC void baseclass_hydrate(baseclass_t **); +STATIC void baseclass_dehydrate(baseclass_t **); + +/********************************* + * Allocate/free symbol table. + */ + +symbol **symtab_realloc(symbol **tab, size_t symmax) +{ symbol **newtab; + + if (config.flags2 & (CFG2phgen | CFG2phuse | CFG2phauto | CFG2phautoy)) + { + newtab = (symbol **) MEM_PH_REALLOC(tab, symmax * sizeof(symbol *)); + } + else + { + newtab = (symbol **) realloc(tab, symmax * sizeof(symbol *)); + if (!newtab) + err_nomem(); + } + return newtab; +} + +symbol **symtab_malloc(size_t symmax) +{ symbol **newtab; + + if (config.flags2 & (CFG2phgen | CFG2phuse | CFG2phauto | CFG2phautoy)) + { + newtab = (symbol **) MEM_PH_MALLOC(symmax * sizeof(symbol *)); + } + else + { + newtab = (symbol **) malloc(symmax * sizeof(symbol *)); + if (!newtab) + err_nomem(); + } + return newtab; +} + +symbol **symtab_calloc(size_t symmax) +{ symbol **newtab; + + if (config.flags2 & (CFG2phgen | CFG2phuse | CFG2phauto | CFG2phautoy)) + { + newtab = (symbol **) MEM_PH_CALLOC(symmax * sizeof(symbol *)); + } + else + { + newtab = (symbol **) calloc(symmax, sizeof(symbol *)); + if (!newtab) + err_nomem(); + } + return newtab; +} + +void symtab_free(symbol **tab) +{ + if (config.flags2 & (CFG2phgen | CFG2phuse | CFG2phauto | CFG2phautoy)) + MEM_PH_FREE(tab); + else if (tab) + free(tab); +} + +/******************************* + * Type out symbol information. + */ + +#ifdef DEBUG + +void symbol_print(symbol *s) +{ +#if !SPP + if (!s) return; + dbg_printf("symbol %p '%s'\n ",s,s->Sident); + dbg_printf(" Sclass = "); WRclass((enum SC) s->Sclass); + dbg_printf(" Ssymnum = %d",s->Ssymnum); + dbg_printf(" Sfl = "); WRFL((enum FL) s->Sfl); + dbg_printf(" Sseg = %d\n",s->Sseg); +// dbg_printf(" Ssize = x%02x\n",s->Ssize); + dbg_printf(" Soffset = x%04llx",(unsigned long long)s->Soffset); + dbg_printf(" Sweight = %d",s->Sweight); + dbg_printf(" Sflags = x%04lx",(unsigned long)s->Sflags); + dbg_printf(" Sxtrnnum = %d\n",s->Sxtrnnum); + dbg_printf(" Stype = %p",s->Stype); +#if SCPP + dbg_printf(" Ssequence = %x", s->Ssequence); + dbg_printf(" Scover = %p", s->Scover); +#endif + dbg_printf(" Sl = %p",s->Sl); + dbg_printf(" Sr = %p\n",s->Sr); +#if SCPP + if (s->Sscope) + dbg_printf(" Sscope = '%s'\n",s->Sscope->Sident); +#endif + if (s->Stype) + type_print(s->Stype); + if (s->Sclass == SCmember || s->Sclass == SCfield) + { + dbg_printf(" Smemoff =%5lld", (long long)s->Smemoff); + dbg_printf(" Sbit =%3d",s->Sbit); + dbg_printf(" Swidth =%3d\n",s->Swidth); + } +#if SCPP + if (s->Sclass == SCstruct) + { +#if VBTABLES + dbg_printf(" Svbptr = %p, Svptr = %p\n",s->Sstruct->Svbptr,s->Sstruct->Svptr); +#endif + } +#endif +#endif +} + +#endif + +/********************************* + * Terminate use of symbol table. + */ + +static symbol *keep; + +void symbol_term() +{ + symbol_free(keep); +} + +/**************************************** + * Keep symbol around until symbol_term(). + */ + +#if TERMCODE + +void symbol_keep(symbol *s) +{ + symbol_debug(s); + s->Sr = keep; // use Sr so symbol_free() doesn't nest + keep = s; +} + +#endif + +/*********************************** + * Get user name of symbol. + */ + +char *symbol_ident(symbol *s) +{ +#if SCPP + static char noname[] = "__unnamed"; + switch (s->Sclass) + { case SCstruct: + if (s->Sstruct->Salias) + s = s->Sstruct->Salias; + else if (s->Sstruct->Sflags & STRnotagname) + return noname; + break; + case SCenum: + if (CPP) + { if (s->Senum->SEalias) + s = s->Senum->SEalias; + else if (s->Senum->SEflags & SENnotagname) + return noname; + } + break; + + case SCnamespace: + if (s->Sident[0] == '?' && s->Sident[1] == '%') + return "unique"; // an unnamed namespace + break; + } +#endif + return s->Sident; +} + +/**************************************** + * Create a new symbol. + */ + +symbol * symbol_calloc(const char *id) +{ symbol *s; + int len; + + len = strlen(id); + //printf("sizeof(symbol)=%d, sizeof(s->Sident)=%d, len=%d\n",sizeof(symbol),sizeof(s->Sident),len); + s = (symbol *) mem_fmalloc(sizeof(symbol) - sizeof(s->Sident) + len + 1 + 5); + memset(s,0,sizeof(symbol) - sizeof(s->Sident)); +#if SCPP + s->Ssequence = pstate.STsequence; + pstate.STsequence += 1; + //if (s->Ssequence == 0x21) *(char*)0=0; +#endif +#ifdef DEBUG + if (debugy) + dbg_printf("symbol_calloc('%s') = %p\n",id,s); + s->id = IDsymbol; +#endif + memcpy(s->Sident,id,len + 1); + s->Ssymnum = -1; + return s; +} + +/**************************************** + * Create a symbol, given a name and type. + */ + +symbol * symbol_name(const char *name,int sclass,type *t) +{ + type_debug(t); + symbol *s = symbol_calloc(name); + s->Sclass = (enum SC) sclass; + s->Stype = t; + s->Stype->Tcount++; +#if ELFOBJ || MACHOBJ // Burton + s->Sseg = CDATA; +#endif + + if (tyfunc(t->Tty)) + symbol_func(s); + return s; +} + +/**************************************** + * Create a symbol that is an alias to another function symbol. + */ + +Funcsym *symbol_funcalias(Funcsym *sf) +{ + Funcsym *s; + + symbol_debug(sf); + assert(tyfunc(sf->Stype->Tty)); + if (sf->Sclass == SCfuncalias) + sf = sf->Sfunc->Falias; + s = (Funcsym *)symbol_name(sf->Sident,SCfuncalias,sf->Stype); + s->Sfunc->Falias = sf; +#if SCPP + s->Scover = sf->Scover; +#endif + return s; +} + +/**************************************** + * Create a symbol, give it a name, storage class and type. + */ + +symbol * symbol_generate(int sclass,type *t) +{ char name[10]; + static int tmpnum; + + sprintf(name,"_TMP%d",tmpnum++); +#ifdef DEBUG + symbol *s = symbol_name(name,sclass,t); + //symbol_print(s); + return s; +#else + return symbol_name(name,sclass,t); +#endif +} + +/**************************************** + * Generate an auto symbol, and add it to the symbol table. + */ + +symbol * symbol_genauto(type *t) +{ symbol *s; + + s = symbol_generate(SCauto,t); +#if SCPP + //printf("symbol_genauto(t) '%s'\n", s->Sident); + if (pstate.STdefertemps) + { symbol_keep(s); + s->Ssymnum = -1; + } + else + { s->Sflags |= SFLfree; + if (init_staticctor) + { // variable goes into _STI_xxxx + s->Ssymnum = -1; // deferred allocation +//printf("test2\n"); +//if (s->Sident[4] == '2') *(char*)0=0; + } + else + { + symbol_add(s); + } + } +#else + s->Sflags |= SFLfree; + symbol_add(s); +#endif + return s; +} + +/****************************************** + * Generate symbol into which we can copy the contents of expression e. + */ + +Symbol *symbol_genauto(elem *e) +{ + return symbol_genauto(type_fake(e->Ety)); +} + +/****************************************** + * Generate symbol into which we can copy the contents of expression e. + */ + +Symbol *symbol_genauto(tym_t ty) +{ + return symbol_genauto(type_fake(ty)); +} + +/**************************************** + * Add in the variants for a function symbol. + */ + +void symbol_func(symbol *s) +{ + //printf("symbol_func(%s, x%x)\n", s->Sident, fregsaved); + symbol_debug(s); + s->Sfl = FLfunc; + // Interrupt functions modify all registers +#if TX86 + // BUG: do interrupt functions really save BP? + #define mBP 0x20 + // Note that fregsaved may not be set yet + s->Sregsaved = (s->Stype && tybasic(s->Stype->Tty) == TYifunc) ? mBP : fregsaved; + s->Sseg = UNKNOWN; // don't know what segment it is in +#endif + if (!s->Sfunc) + s->Sfunc = func_calloc(); +} + +/******************************** + * Define symbol in specified symbol table. + * Returns: + * pointer to symbol + */ + +#if SCPP + +symbol * defsy(const char *p,symbol **parent) +{ + symbol *s = symbol_calloc(p); + symbol_addtotree(parent,s); + return s; +} + +#endif + +/******************************** + * Check integrity of symbol data structure. + */ + +#ifdef DEBUG + +void symbol_check(symbol *s) +{ + //dbg_printf("symbol_check('%s',%p)\n",s->Sident,s); + symbol_debug(s); + if (s->Stype) type_debug(s->Stype); + assert((unsigned)s->Sclass < (unsigned)SCMAX); +#if SCPP + if (s->Sscope) + symbol_check(s->Sscope); + if (s->Scover) + symbol_check(s->Scover); +#endif +} + +void symbol_tree_check(symbol *s) +{ + while (s) + { symbol_check(s); + symbol_tree_check(s->Sl); + s = s->Sr; + } +} + +#endif + +/******************************** + * Insert symbol in specified symbol table. + */ + +#if SCPP + +void symbol_addtotree(symbol **parent,symbol *s) +{ symbol *rover; + signed char cmp; + size_t len; + const char *p; + char c; + + //dbg_printf("symbol_addtotree('%s',%p)\n",s->Sident,*parent); +#ifdef DEBUG + symbol_tree_check(*parent); + assert(!s->Sl && !s->Sr); +#endif + symbol_debug(s); + p = s->Sident; + c = *p; + len = strlen(p); + p++; + rover = *parent; + while (rover != NULL) // while we haven't run out of tree + { symbol_debug(rover); + if ((cmp = c - rover->Sident[0]) == 0) + { cmp = memcmp(p,rover->Sident + 1,len); // compare identifier strings + if (cmp == 0) // found it if strings match + { + if (CPP) + { symbol *s2; + + switch (rover->Sclass) + { case SCstruct: + s2 = rover; + goto case_struct; + + case_struct: + if (s2->Sstruct->Sctor && + !(s2->Sstruct->Sctor->Sfunc->Fflags & Fgen)) + cpperr(EM_ctor_disallowed,p); // no ctor allowed for class rover + s2->Sstruct->Sflags |= STRnoctor; + goto case_cover; + + case_cover: + // Replace rover with the new symbol s, and + // have s 'cover' the tag symbol s2. + // BUG: memory leak on rover if s2!=rover + assert(!s2->Scover); + s->Sl = rover->Sl; + s->Sr = rover->Sr; + s->Scover = s2; + *parent = s; + rover->Sl = rover->Sr = NULL; + return; + + case SCenum: + s2 = rover; + goto case_cover; + + case SCtemplate: + s2 = rover; + s2->Stemplate->TMflags |= STRnoctor; + goto case_cover; + + case SCalias: + s2 = rover->Smemalias; + if (s2->Sclass == SCstruct) + goto case_struct; + if (s2->Sclass == SCenum) + goto case_cover; + break; + } + } + synerr(EM_multiple_def,p - 1); // symbol is already defined + //symbol_undef(s); // undefine the symbol + return; + } + } + parent = (cmp < 0) ? /* if we go down left side */ + &(rover->Sl) : /* then get left child */ + &(rover->Sr); /* else get right child */ + rover = *parent; /* get child */ + } + /* not in table, so insert into table */ + *parent = s; /* link new symbol into tree */ +L1: + ; +} + +#endif + +/************************************* + * Search for symbol in multiple symbol tables, + * starting with most recently nested one. + * Input: + * p -> identifier string + * Returns: + * pointer to symbol + * NULL if couldn't find it + */ + +#if 0 +symbol * lookupsym(const char *p) +{ + return scope_search(p,SCTglobal | SCTlocal); +} +#endif + +/************************************* + * Search for symbol in symbol table. + * Input: + * p -> identifier string + * rover -> where to start looking + * Returns: + * pointer to symbol (NULL if not found) + */ + +#if SCPP + +symbol * findsy(const char *p,symbol *rover) +{ +#if __INTSIZE == 2 && TX86 && !defined(_MSC_VER) + volatile int len; + __asm + { + push DS + mov DS,word ptr p+2 + les DI,p + mov DX,word ptr p + mov BX,ES:[DI] + xor AL,AL + mov CX,0FFFFh + repne scasb + not CX + sub CX,2 + mov len,CX + add DX,2 + mov AX,BX + les BX,rover + jmp short L1 + +L38C: les BX,ES:symbol.Sl[BX] +L1: test BX,BX + je L3A5 + cmp AL,ES:symbol.Sident[BX] + js L38C + je L2 + les BX,ES:symbol.Sr[BX] + jmp L1 + +L2: cmp AH,ES:symbol.Sident+1[BX] + js L38C + je L3 + les BX,ES:symbol.Sr[BX] + jmp L1 + +L3: mov SI,DX + lea DI,symbol.Sident+2[BX] + mov CX,len + rep cmpsb + js L38C + je L3A5 + les BX,ES:symbol.Sr[BX] + jmp L1 + +L3A5: mov DX,ES + mov AX,BX + pop DS + } +#elif __INTSIZE == 4 && TX86 && !defined(_MSC_VER) && !M_UNIX + volatile int len; + __asm + { +#if !_WIN32 + push DS + pop ES +#endif + mov EDI,p + xor AL,AL + + mov BL,[EDI] + mov ECX,-1 + + repne scasb + + not ECX + mov EDX,p + + dec ECX + inc EDX + + mov len,ECX + mov AL,BL + + mov EBX,rover + mov ESI,EDX + + test EBX,EBX + je L6 + + cmp AL,symbol.Sident[EBX] + js L2 + + lea EDI,symbol.Sident+1[EBX] + je L5 + + mov EBX,symbol.Sr[EBX] + jmp L3 + +L1: mov ECX,len +L2: mov EBX,symbol.Sl[EBX] + +L3: test EBX,EBX + je L6 + +L4: cmp AL,symbol.Sident[EBX] + js L2 + + lea EDI,symbol.Sident+1[EBX] + je L5 + + mov EBX,symbol.Sr[EBX] + jmp L3 + +L5: rep cmpsb + + mov ESI,EDX + js L1 + + je L6 + + mov EBX,symbol.Sr[EBX] + mov ECX,len + + test EBX,EBX + jne L4 + +L6: mov EAX,EBX + } +#else + size_t len; + signed char cmp; /* set to value of strcmp */ + char c = *p; + + len = strlen(p); + p++; // will pick up 0 on memcmp + while (rover != NULL) // while we haven't run out of tree + { symbol_debug(rover); + if ((cmp = c - rover->Sident[0]) == 0) + { cmp = memcmp(p,rover->Sident + 1,len); /* compare identifier strings */ + if (cmp == 0) + return rover; /* found it if strings match */ + } + rover = (cmp < 0) ? rover->Sl : rover->Sr; + } + return rover; // failed to find it +#endif +} + +#endif + +/*********************************** + * Create a new symbol table. + */ + +#if SCPP + +void createglobalsymtab() +{ + assert(!scope_end); + if (CPP) + scope_push(NULL,(scope_fp)findsy, SCTcglobal); + else + scope_push(NULL,(scope_fp)findsy, SCTglobaltag); + scope_push(NULL,(scope_fp)findsy, SCTglobal); +} + + +void createlocalsymtab() +{ + assert(scope_end); + if (!CPP) + scope_push(NULL,(scope_fp)findsy, SCTtag); + scope_push(NULL,(scope_fp)findsy, SCTlocal); +} + + +/*********************************** + * Delete current symbol table and back up one. + */ + +void deletesymtab() +{ symbol *root; + + root = (symbol *)scope_pop(); + if (root) + { + if (funcsym_p) + list_prepend(&funcsym_p->Sfunc->Fsymtree,root); + else + symbol_free(root); // free symbol table + } + + if (!CPP) + { + root = (symbol *)scope_pop(); + if (root) + { + if (funcsym_p) + list_prepend(&funcsym_p->Sfunc->Fsymtree,root); + else + symbol_free(root); // free symbol table + } + } +} + +#endif + +/********************************* + * Delete symbol from symbol table, taking care to delete + * all children of a symbol. + * Make sure there are no more forward references (labels, tags). + * Input: + * pointer to a symbol + */ + +void meminit_free(meminit_t *m) /* helper for symbol_free() */ +{ + list_free(&m->MIelemlist,(list_free_fp)el_free); + MEM_PARF_FREE(m); +} + +void symbol_free(symbol *s) +{ + while (s) /* if symbol exists */ + { symbol *sr; + +#ifdef DEBUG + if (debugy) + dbg_printf("symbol_free('%s',%p)\n",s->Sident,s); + symbol_debug(s); + assert(/*s->Sclass != SCunde &&*/ (int) s->Sclass < (int) SCMAX); +#endif + { type *t = s->Stype; + + if (t) + type_debug(t); + if (t && tyfunc(t->Tty) && s->Sfunc) + { + func_t *f = s->Sfunc; + + debug(assert(f)); + blocklist_free(&f->Fstartblock); + freesymtab(f->Flocsym.tab,0,f->Flocsym.top); + + symtab_free(f->Flocsym.tab); + if (CPP) + { + if (f->Fflags & Fnotparent) + { debug(debugy && dbg_printf("not parent, returning\n")); + return; + } + + /* We could be freeing the symbol before it's class is */ + /* freed, so remove it from the class's field list */ +#if 1 + if (f->Fclass) + { list_t tl; + + symbol_debug(f->Fclass); + tl = list_inlist(f->Fclass->Sstruct->Sfldlst,s); + if (tl) + list_setsymbol(tl,0); + } +#endif + if (f->Foversym && f->Foversym->Sfunc) + { f->Foversym->Sfunc->Fflags &= ~Fnotparent; + f->Foversym->Sfunc->Fclass = NULL; + symbol_free(f->Foversym); + } + + if (f->Fexplicitspec) + symbol_free(f->Fexplicitspec); + + /* If operator function, remove from list of such functions */ + if (f->Fflags & Foperator) + { assert(f->Foper && f->Foper < OPMAX); + //if (list_inlist(cpp_operfuncs[f->Foper],s)) + // list_subtract(&cpp_operfuncs[f->Foper],s); + } + + list_free(&f->Fclassfriends,FPNULL); + list_free(&f->Ffwdrefinstances,FPNULL); + param_free(&f->Farglist); + param_free(&f->Fptal); + list_free(&f->Fexcspec,(list_free_fp)type_free); +#if SCPP + token_free(f->Fbody); +#endif + el_free(f->Fbaseinit); + if (f->Fthunk && !(f->Fflags & Finstance)) + MEM_PH_FREE(f->Fthunk); + list_free(&f->Fthunks,(list_free_fp)symbol_free); + } + list_free(&f->Fsymtree,(list_free_fp)symbol_free); + func_free(f); + } + switch (s->Sclass) + { +#if SCPP + case SClabel: + if (!s->Slabel) + synerr(EM_unknown_label,s->Sident); + break; +#endif + case SCstruct: +#if SCPP + if (CPP) + { + struct_t *st = s->Sstruct; + assert(st); + list_free(&st->Sclassfriends,FPNULL); + list_free(&st->Sfriendclass,FPNULL); + list_free(&st->Sfriendfuncs,FPNULL); + list_free(&st->Scastoverload,FPNULL); + list_free(&st->Sopoverload,FPNULL); + list_free(&st->Svirtual,MEM_PH_FREEFP); + list_free(&st->Sfldlst,FPNULL); + symbol_free(st->Sroot); + baseclass_t *b,*bn; + + for (b = st->Sbase; b; b = bn) + { bn = b->BCnext; + list_free(&b->BCpublics,FPNULL); + baseclass_free(b); + } + for (b = st->Svirtbase; b; b = bn) + { bn = b->BCnext; + baseclass_free(b); + } + for (b = st->Smptrbase; b; b = bn) + { bn = b->BCnext; + list_free(&b->BCmptrlist,MEM_PH_FREEFP); + baseclass_free(b); + } +#if VBTABLES + for (b = st->Svbptrbase; b; b = bn) + { bn = b->BCnext; + baseclass_free(b); + } +#endif + param_free(&st->Sarglist); + param_free(&st->Spr_arglist); + struct_free(st); + } + else +#endif + { +#ifdef DEBUG + if (debugy) + dbg_printf("freeing members %p\n",s->Sstruct->Sfldlst); +#endif + list_free(&s->Sstruct->Sfldlst,FPNULL); + symbol_free(s->Sstruct->Sroot); + struct_free(s->Sstruct); + } +#if 0 /* Don't complain anymore about these, ANSI C says */ + /* it's ok */ + if (t && t->Tflags & TFsizeunknown) + synerr(EM_unknown_tag,s->Sident); +#endif + break; + case SCenum: + /* The actual member symbols are either in a local */ + /* table or on the member list of a class, so we */ + /* don't free them here. */ + assert(s->Senum); + list_free(&s->Senumlist,FPNULL); + MEM_PH_FREE(s->Senum); + s->Senum = NULL; + break; + +#if SCPP + case SCtemplate: + { template_t *tm = s->Stemplate; + + list_free(&tm->TMinstances,FPNULL); + list_free(&tm->TMmemberfuncs,(list_free_fp)tmf_free); + list_free(&tm->TMexplicit,(list_free_fp)tme_free); + list_free(&tm->TMnestedexplicit,(list_free_fp)tmne_free); + list_free(&tm->TMnestedfriends,(list_free_fp)tmnf_free); + param_free(&tm->TMptpl); + param_free(&tm->TMptal); + token_free(tm->TMbody); + symbol_free(tm->TMpartial); + list_free(&tm->TMfriends,FPNULL); + MEM_PH_FREE(tm); + break; + } + case SCnamespace: + symbol_free(s->Snameroot); + list_free(&s->Susing,FPNULL); + break; + + case SCmemalias: + case SCfuncalias: + case SCadl: + list_free(&s->Spath,FPNULL); + break; +#endif + case SCparameter: + case SCregpar: + case SCfastpar: + case SCregister: + case SCtmp: + case SCauto: + vec_free(s->Srange); + /* FALL-THROUGH */ +#if 0 + case SCconst: + if (s->Sflags & (SFLvalue | SFLdtorexp)) + el_free(s->Svalue); +#endif + break; + default: + break; + } + if (s->Sflags & (SFLvalue | SFLdtorexp)) + el_free(s->Svalue); + if (s->Sdt) + dt_free(s->Sdt); + type_free(t); + symbol_free(s->Sl); +#if SCPP + if (s->Scover) + symbol_free(s->Scover); +#endif + sr = s->Sr; +#ifdef DEBUG + s->id = 0; +#endif + mem_ffree(s); + } + s = sr; + } +} + +/******************************** + * Undefine a symbol. + * Assume error msg was already printed. + */ + +#if 0 +STATIC void symbol_undef(symbol *s) +{ + s->Sclass = SCunde; + s->Ssymnum = -1; + type_free(s->Stype); /* free type data */ + s->Stype = NULL; +} +#endif + +/***************************** + * Add symbol to current symbol array. + */ + +SYMIDX symbol_add(symbol *s) +{ SYMIDX sitop; + + //printf("symbol_add('%s')\n", s->Sident); +#ifdef DEBUG + if (!s || !s->Sident[0]) + { dbg_printf("bad symbol\n"); + assert(0); + } +#endif + symbol_debug(s); + if (pstate.STinsizeof) + { symbol_keep(s); + return -1; + } + debug(assert(cstate.CSpsymtab)); + sitop = cstate.CSpsymtab->top; + assert(sitop <= cstate.CSpsymtab->symmax); + if (sitop == cstate.CSpsymtab->symmax) + { +#ifdef DEBUG +#define SYMINC 1 /* flush out reallocation bugs */ +#else +#define SYMINC 99 +#endif + cstate.CSpsymtab->symmax += (cstate.CSpsymtab == &globsym) ? SYMINC : 1; + //assert(cstate.CSpsymtab->symmax * sizeof(symbol *) < 4096 * 4); + cstate.CSpsymtab->tab = symtab_realloc(cstate.CSpsymtab->tab, cstate.CSpsymtab->symmax); + } + cstate.CSpsymtab->tab[sitop] = s; +#if AUTONEST + if (pushcount) + { s->Spush = pushcount; + pushcount = 0; + } +#endif +#ifdef DEBUG + if (debugy) + dbg_printf("symbol_add(%p '%s') = %d\n",s,s->Sident,cstate.CSpsymtab->top); +#endif + assert(s->Ssymnum == -1); + return s->Ssymnum = cstate.CSpsymtab->top++; +} + +/**************************** + * Free up the symbol table, from symbols n1 through n2, not + * including n2. + */ + +void freesymtab(symbol **stab,SYMIDX n1,SYMIDX n2) +{ SYMIDX si; + + if (!stab) + return; +#ifdef DEBUG + if (debugy) + dbg_printf("freesymtab(from %d to %d)\n",n1,n2); +#endif + assert(stab != globsym.tab || (n1 <= n2 && n2 <= globsym.top)); + for (si = n1; si < n2; si++) + { symbol *s; + + s = stab[si]; + if (s && s->Sflags & SFLfree) + { stab[si] = NULL; +#ifdef DEBUG + if (debugy) + dbg_printf("Freeing %p '%s' (%d)\n",s,s->Sident,si); + symbol_debug(s); +#endif + s->Sl = s->Sr = NULL; + s->Ssymnum = -1; + symbol_free(s); + } + } +} + +/**************************** + * Create a copy of a symbol. + */ + +symbol * symbol_copy(symbol *s) +{ symbol *scopy; + type *t; + + symbol_debug(s); + /*dbg_printf("symbol_copy(%s)\n",s->Sident);*/ + scopy = symbol_calloc(s->Sident); + memcpy(scopy,s,sizeof(symbol) - sizeof(s->Sident)); + scopy->Sl = scopy->Sr = scopy->Snext = NULL; + scopy->Ssymnum = -1; + if (scopy->Sdt) + dtsymsize(scopy); + if (scopy->Sflags & (SFLvalue | SFLdtorexp)) + scopy->Svalue = el_copytree(s->Svalue); + t = scopy->Stype; + if (t) + { t->Tcount++; /* one more parent of the type */ + type_debug(t); + } + return scopy; +} + +/******************************* + * Search list for a symbol with an identifier that matches. + * Returns: + * pointer to matching symbol + * NULL if not found + */ + +#if SCPP + +symbol * symbol_searchlist(symlist_t sl,const char *vident) +{ symbol *s; +#ifdef DEBUG + int count = 0; +#endif + + //dbg_printf("searchlist(%s)\n",vident); + for (; sl; sl = list_next(sl)) + { s = list_symbol(sl); + symbol_debug(s); + /*dbg_printf("\tcomparing with %s\n",s->Sident);*/ + if (strcmp(vident,s->Sident) == 0) + return s; +#ifdef DEBUG + assert(++count < 300); /* prevent infinite loops */ +#endif + } + return NULL; +} + +/*************************************** + * Search for symbol in sequence of symbol tables. + * Input: + * glbl !=0 if global symbol table only + */ + +symbol *symbol_search(const char *id) +{ + Scope *sc; + if (CPP) + { unsigned sct; + + sct = pstate.STclasssym ? SCTclass : 0; + sct |= SCTmfunc | SCTlocal | SCTwith | SCTglobal | SCTnspace | SCTtemparg | SCTtempsym; + return scope_searchx(id,sct,&sc); + } + else + return scope_searchx(id,SCTglobal | SCTlocal,&sc); +} + +#endif + +/******************************************* + * Hydrate a symbol tree. + */ + +#if HYDRATE +void symbol_tree_hydrate(symbol **ps) +{ symbol *s; + + while (isdehydrated(*ps)) /* if symbol is dehydrated */ + { + s = symbol_hydrate(ps); + symbol_debug(s); + if (s->Scover) + symbol_hydrate(&s->Scover); + symbol_tree_hydrate(&s->Sl); + ps = &s->Sr; + } + +} +#endif + +/******************************************* + * Dehydrate a symbol tree. + */ + +#if DEHYDRATE +void symbol_tree_dehydrate(symbol **ps) +{ symbol *s; + + while ((s = *ps) != NULL && !isdehydrated(s)) /* if symbol exists */ + { + symbol_debug(s); + symbol_dehydrate(ps); +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(s)) + return; +#endif + symbol_dehydrate(&s->Scover); + symbol_tree_dehydrate(&s->Sl); + ps = &s->Sr; + } +} +#endif + +/******************************************* + * Hydrate a symbol. + */ + +#if HYDRATE +symbol *symbol_hydrate(symbol **ps) +{ symbol *s; + + s = *ps; + if (isdehydrated(s)) /* if symbol is dehydrated */ + { type *t; + struct_t *st; + + s = (symbol *) ph_hydrate(ps); +#ifdef DEBUG + debugy && dbg_printf("symbol_hydrate('%s')\n",s->Sident); +#endif + symbol_debug(s); + if (!isdehydrated(s->Stype)) // if this symbol is already dehydrated + return s; // no need to do it again +#if SOURCE_4SYMS + s->Ssrcpos.Sfilnum += File_Hydrate_Num; /* file number relative header build */ +#endif + if (pstate.SThflag != FLAG_INPLACE && s->Sfl != FLreg) + s->Sxtrnnum = 0; // not written to .OBJ file yet + type_hydrate(&s->Stype); + //dbg_printf("symbol_hydrate(%p, '%s', t = %p)\n",s,s->Sident,s->Stype); + t = s->Stype; + if (t) + type_debug(t); + + if (t && tyfunc(t->Tty) && ph_hydrate(&s->Sfunc)) + { + func_t *f = s->Sfunc; + SYMIDX si; + + debug(assert(f)); + + list_hydrate(&f->Fsymtree,(list_free_fp)symbol_tree_hydrate); + blocklist_hydrate(&f->Fstartblock); + + ph_hydrate(&f->Flocsym.tab); + for (si = 0; si < f->Flocsym.top; si++) + symbol_hydrate(&f->Flocsym.tab[si]); + + srcpos_hydrate(&f->Fstartline); + srcpos_hydrate(&f->Fendline); + + symbol_hydrate(&f->F__func__); + + if (CPP) + { + symbol_hydrate(&f->Fparsescope); + Classsym_hydrate(&f->Fclass); + symbol_hydrate(&f->Foversym); + symbol_hydrate(&f->Fexplicitspec); + symbol_hydrate(&f->Fsurrogatesym); + + list_hydrate(&f->Fclassfriends,(list_free_fp)symbol_hydrate); + el_hydrate(&f->Fbaseinit); + token_hydrate(&f->Fbody); + symbol_hydrate(&f->Falias); + list_hydrate(&f->Fthunks,(list_free_fp)symbol_hydrate); + if (f->Fflags & Finstance) + symbol_hydrate(&f->Ftempl); + else + thunk_hydrate(&f->Fthunk); + param_hydrate(&f->Farglist); + param_hydrate(&f->Fptal); + list_hydrate(&f->Ffwdrefinstances,(list_free_fp)symbol_hydrate); + list_hydrate(&f->Fexcspec,(list_free_fp)type_hydrate); + } + } + if (CPP) + symbol_hydrate(&s->Sscope); + switch (s->Sclass) + { + case SCstruct: + if (CPP) + { + st = (struct_t *) ph_hydrate(&s->Sstruct); + assert(st); + symbol_tree_hydrate(&st->Sroot); + ph_hydrate(&st->Spvirtder); + list_hydrate(&st->Sfldlst,(list_free_fp)symbol_hydrate); + list_hydrate(&st->Svirtual,(list_free_fp)mptr_hydrate); + list_hydrate(&st->Sopoverload,(list_free_fp)symbol_hydrate); + list_hydrate(&st->Scastoverload,(list_free_fp)symbol_hydrate); + list_hydrate(&st->Sclassfriends,(list_free_fp)symbol_hydrate); + list_hydrate(&st->Sfriendclass,(list_free_fp)symbol_hydrate); + list_hydrate(&st->Sfriendfuncs,(list_free_fp)symbol_hydrate); + assert(!st->Sinlinefuncs); + + baseclass_hydrate(&st->Sbase); + baseclass_hydrate(&st->Svirtbase); + baseclass_hydrate(&st->Smptrbase); + baseclass_hydrate(&st->Sprimary); +#if VBTABLES + baseclass_hydrate(&st->Svbptrbase); +#endif + + ph_hydrate(&st->Svecctor); + ph_hydrate(&st->Sctor); + ph_hydrate(&st->Sdtor); +#if VBTABLES + ph_hydrate(&st->Sprimdtor); + ph_hydrate(&st->Spriminv); + ph_hydrate(&st->Sscaldeldtor); +#endif + ph_hydrate(&st->Sinvariant); + ph_hydrate(&st->Svptr); + ph_hydrate(&st->Svtbl); + ph_hydrate(&st->Sopeq); + ph_hydrate(&st->Sopeq2); + ph_hydrate(&st->Scpct); + ph_hydrate(&st->Sveccpct); + ph_hydrate(&st->Salias); + ph_hydrate(&st->Stempsym); + param_hydrate(&st->Sarglist); + param_hydrate(&st->Spr_arglist); +#if VBTABLES + ph_hydrate(&st->Svbptr); + ph_hydrate(&st->Svbptr_parent); + ph_hydrate(&st->Svbtbl); +#endif + } + else + { + ph_hydrate(&s->Sstruct); + symbol_tree_hydrate(&s->Sstruct->Sroot); + list_hydrate(&s->Sstruct->Sfldlst,(list_free_fp)symbol_hydrate); + } + break; + + case SCenum: + assert(s->Senum); + ph_hydrate(&s->Senum); + if (CPP) + { ph_hydrate(&s->Senum->SEalias); + list_hydrate(&s->Senumlist,(list_free_fp)symbol_hydrate); + } + break; + + case SCtemplate: + { template_t *tm; + + tm = (template_t *) ph_hydrate(&s->Stemplate); + list_hydrate(&tm->TMinstances,(list_free_fp)symbol_hydrate); + list_hydrate(&tm->TMfriends,(list_free_fp)symbol_hydrate); + param_hydrate(&tm->TMptpl); + param_hydrate(&tm->TMptal); + token_hydrate(&tm->TMbody); + list_hydrate(&tm->TMmemberfuncs,(list_free_fp)tmf_hydrate); + list_hydrate(&tm->TMexplicit,(list_free_fp)tme_hydrate); + list_hydrate(&tm->TMnestedexplicit,(list_free_fp)tmne_hydrate); + list_hydrate(&tm->TMnestedfriends,(list_free_fp)tmnf_hydrate); + ph_hydrate(&tm->TMnext); + symbol_hydrate(&tm->TMpartial); + symbol_hydrate(&tm->TMprimary); + break; + } + + case SCnamespace: + symbol_tree_hydrate(&s->Snameroot); + list_hydrate(&s->Susing,(list_free_fp)symbol_hydrate); + break; + + case SCmemalias: + case SCfuncalias: + case SCadl: + list_hydrate(&s->Spath,(list_free_fp)symbol_hydrate); + case SCalias: + ph_hydrate(&s->Smemalias); + break; + + default: + if (s->Sflags & (SFLvalue | SFLdtorexp)) + el_hydrate(&s->Svalue); + break; + } + { dt_t **pdt,*dt; + + for (pdt = &s->Sdt; isdehydrated(*pdt); pdt = &dt->DTnext) + { + dt = (dt_t *) ph_hydrate(pdt); + switch (dt->dt) + { case DT_abytes: + case DT_nbytes: + ph_hydrate(&dt->DTpbytes); + break; + case DT_xoff: + symbol_hydrate(&dt->DTsym); + break; + } + } + } + if (s->Scover) + symbol_hydrate(&s->Scover); + } + return s; +} +#endif + +/******************************************* + * Dehydrate a symbol. + */ + +#if DEHYDRATE +void symbol_dehydrate(symbol **ps) +{ + symbol *s; + + if ((s = *ps) != NULL && !isdehydrated(s)) /* if symbol exists */ + { type *t; + struct_t *st; + +#ifdef DEBUG + if (debugy) + dbg_printf("symbol_dehydrate('%s')\n",s->Sident); +#endif + ph_dehydrate(ps); +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(s)) + return; +#endif + symbol_debug(s); + t = s->Stype; + if (isdehydrated(t)) + return; + type_dehydrate(&s->Stype); + + if (tyfunc(t->Tty) && !isdehydrated(s->Sfunc)) + { + func_t *f = s->Sfunc; + SYMIDX si; + + debug(assert(f)); + ph_dehydrate(&s->Sfunc); + + list_dehydrate(&f->Fsymtree,(list_free_fp)symbol_tree_dehydrate); + blocklist_dehydrate(&f->Fstartblock); + assert(!isdehydrated(&f->Flocsym.tab)); + +#if DEBUG_XSYMGEN + if (!xsym_gen || !ph_in_head(f->Flocsym.tab)) + +#endif + for (si = 0; si < f->Flocsym.top; si++) + symbol_dehydrate(&f->Flocsym.tab[si]); + ph_dehydrate(&f->Flocsym.tab); + + srcpos_dehydrate(&f->Fstartline); + srcpos_dehydrate(&f->Fendline); + symbol_dehydrate(&f->F__func__); + if (CPP) + { + symbol_dehydrate(&f->Fparsescope); + ph_dehydrate(&f->Fclass); + symbol_dehydrate(&f->Foversym); + symbol_dehydrate(&f->Fexplicitspec); + symbol_dehydrate(&f->Fsurrogatesym); + + list_dehydrate(&f->Fclassfriends,FPNULL); + el_dehydrate(&f->Fbaseinit); +#if DEBUG_XSYMGEN + if (xsym_gen && s->Sclass == SCfunctempl) + ph_dehydrate(&f->Fbody); + else +#endif + token_dehydrate(&f->Fbody); + symbol_dehydrate(&f->Falias); + list_dehydrate(&f->Fthunks,(list_free_fp)symbol_dehydrate); + if (f->Fflags & Finstance) + symbol_dehydrate(&f->Ftempl); + else + thunk_dehydrate(&f->Fthunk); +#if !TX86 && DEBUG_XSYMGEN + if (xsym_gen && s->Sclass == SCfunctempl) + ph_dehydrate(&f->Farglist); + else +#endif + param_dehydrate(&f->Farglist); + param_dehydrate(&f->Fptal); + list_dehydrate(&f->Ffwdrefinstances,(list_free_fp)symbol_dehydrate); + list_dehydrate(&f->Fexcspec,(list_free_fp)type_dehydrate); + } + } + if (CPP) + ph_dehydrate(&s->Sscope); + switch (s->Sclass) + { + case SCstruct: + if (CPP) + { + st = s->Sstruct; + if (isdehydrated(st)) + break; + ph_dehydrate(&s->Sstruct); + assert(st); + symbol_tree_dehydrate(&st->Sroot); + ph_dehydrate(&st->Spvirtder); + list_dehydrate(&st->Sfldlst,(list_free_fp)symbol_dehydrate); + list_dehydrate(&st->Svirtual,(list_free_fp)mptr_dehydrate); + list_dehydrate(&st->Sopoverload,(list_free_fp)symbol_dehydrate); + list_dehydrate(&st->Scastoverload,(list_free_fp)symbol_dehydrate); + list_dehydrate(&st->Sclassfriends,(list_free_fp)symbol_dehydrate); + list_dehydrate(&st->Sfriendclass,(list_free_fp)ph_dehydrate); + list_dehydrate(&st->Sfriendfuncs,(list_free_fp)ph_dehydrate); + assert(!st->Sinlinefuncs); + + baseclass_dehydrate(&st->Sbase); + baseclass_dehydrate(&st->Svirtbase); + baseclass_dehydrate(&st->Smptrbase); + baseclass_dehydrate(&st->Sprimary); +#if VBTABLES + baseclass_dehydrate(&st->Svbptrbase); +#endif + + ph_dehydrate(&st->Svecctor); + ph_dehydrate(&st->Sctor); + ph_dehydrate(&st->Sdtor); +#if VBTABLES + ph_dehydrate(&st->Sprimdtor); + ph_dehydrate(&st->Spriminv); + ph_dehydrate(&st->Sscaldeldtor); +#endif + ph_dehydrate(&st->Sinvariant); + ph_dehydrate(&st->Svptr); + ph_dehydrate(&st->Svtbl); + ph_dehydrate(&st->Sopeq); + ph_dehydrate(&st->Sopeq2); + ph_dehydrate(&st->Scpct); + ph_dehydrate(&st->Sveccpct); + ph_dehydrate(&st->Salias); + ph_dehydrate(&st->Stempsym); + param_dehydrate(&st->Sarglist); + param_dehydrate(&st->Spr_arglist); +#if VBTABLES + ph_dehydrate(&st->Svbptr); + ph_dehydrate(&st->Svbptr_parent); + ph_dehydrate(&st->Svbtbl); +#endif + } + else + { + symbol_tree_dehydrate(&s->Sstruct->Sroot); + list_dehydrate(&s->Sstruct->Sfldlst,(list_free_fp)symbol_dehydrate); + ph_dehydrate(&s->Sstruct); + } + break; + + case SCenum: + assert(s->Senum); + if (!isdehydrated(s->Senum)) + { + if (CPP) + { ph_dehydrate(&s->Senum->SEalias); + list_dehydrate(&s->Senumlist,(list_free_fp)ph_dehydrate); + } + ph_dehydrate(&s->Senum); + } + break; + + case SCtemplate: + { template_t *tm; + + tm = s->Stemplate; + if (!isdehydrated(tm)) + { + ph_dehydrate(&s->Stemplate); + list_dehydrate(&tm->TMinstances,(list_free_fp)symbol_dehydrate); + list_dehydrate(&tm->TMfriends,(list_free_fp)symbol_dehydrate); + list_dehydrate(&tm->TMnestedfriends,(list_free_fp)tmnf_dehydrate); + param_dehydrate(&tm->TMptpl); + param_dehydrate(&tm->TMptal); + token_dehydrate(&tm->TMbody); + list_dehydrate(&tm->TMmemberfuncs,(list_free_fp)tmf_dehydrate); + list_dehydrate(&tm->TMexplicit,(list_free_fp)tme_dehydrate); + list_dehydrate(&tm->TMnestedexplicit,(list_free_fp)tmne_dehydrate); + ph_dehydrate(&tm->TMnext); + symbol_dehydrate(&tm->TMpartial); + symbol_dehydrate(&tm->TMprimary); + } + break; + } + + case SCnamespace: + symbol_tree_dehydrate(&s->Snameroot); + list_dehydrate(&s->Susing,(list_free_fp)symbol_dehydrate); + break; + + case SCmemalias: + case SCfuncalias: + case SCadl: + list_dehydrate(&s->Spath,(list_free_fp)symbol_dehydrate); + case SCalias: + ph_dehydrate(&s->Smemalias); + break; + + default: + if (s->Sflags & (SFLvalue | SFLdtorexp)) + el_dehydrate(&s->Svalue); + break; + } + { dt_t **pdt,*dt; + + for (pdt = &s->Sdt; + (dt = *pdt) != NULL && !isdehydrated(dt); + pdt = &dt->DTnext) + { + ph_dehydrate(pdt); + switch (dt->dt) + { case DT_abytes: + case DT_nbytes: + ph_dehydrate(&dt->DTpbytes); + break; + case DT_xoff: + symbol_dehydrate(&dt->DTsym); + break; + } + } + } + if (s->Scover) + symbol_dehydrate(&s->Scover); + } +} +#endif + +/*************************** + * Dehydrate threaded list of symbols. + */ + +#if DEHYDRATE +void symbol_symdefs_dehydrate(symbol **ps) +{ + symbol *s; + + for (; *ps; ps = &s->Snext) + { + s = *ps; + symbol_debug(s); + //dbg_printf("symbol_symdefs_dehydrate(%p, '%s')\n",s,s->Sident); + symbol_dehydrate(ps); + } +} +#endif + +/*************************** + * Hydrate threaded list of symbols. + * Input: + * *ps start of threaded list + * *parent root of symbol table to add symbol into + * flag !=0 means add onto existing stuff + * 0 means hydrate in place + */ + +#if SCPP + +void symbol_symdefs_hydrate(symbol **ps,symbol **parent,int flag) +{ symbol *s; + + //printf("symbol_symdefs_hydrate(flag = %d)\n",flag); +#ifdef DEBUG + int count = 0; + + if (flag) symbol_tree_check(*parent); +#endif + for (; *ps; ps = &s->Snext) + { + //dbg_printf("%p ",*ps); +#ifdef DEBUG + count++; +#endif + s = dohydrate ? symbol_hydrate(ps) : *ps; + + //if (s->Sclass == SCstruct) + //dbg_printf("symbol_symdefs_hydrate(%p, '%s')\n",s,s->Sident); + symbol_debug(s); +#if 0 + if (tyfunc(s->Stype->Tty)) + { Outbuffer buf; + char *p1; + + p1 = param_tostring(&buf,s->Stype); + dbg_printf("'%s%s'\n",cpp_prettyident(s),p1); + } +#endif + type_debug(s->Stype); + if (flag) + { char *p; + symbol **ps; + symbol *rover; + char c; + size_t len; + + p = s->Sident; + c = *p; + + // Put symbol s into symbol table + +#if MMFIO + if (s->Sl || s->Sr) // avoid writing to page if possible +#endif + s->Sl = s->Sr = NULL; + len = strlen(p); + p++; + ps = parent; + while ((rover = *ps) != NULL) + { signed char cmp; + + if ((cmp = c - rover->Sident[0]) == 0) + { cmp = memcmp(p,rover->Sident + 1,len); // compare identifier strings + if (cmp == 0) + { + if (CPP && tyfunc(s->Stype->Tty) && tyfunc(rover->Stype->Tty)) + { symbol **ps; + symbol *sn; + symbol *so; + + so = s; + do + { + // Tack onto end of overloaded function list + for (ps = &rover; *ps; ps = &(*ps)->Sfunc->Foversym) + { if (cpp_funccmp(so, *ps)) + { //printf("function '%s' already in list\n",so->Sident); + goto L2; + } + } + //printf("appending '%s' to rover\n",so->Sident); + *ps = so; + L2: + sn = so->Sfunc->Foversym; + so->Sfunc->Foversym = NULL; + so = sn; + } while (so); + //printf("overloading...\n"); + } + else if (s->Sclass == SCstruct) + { + if (CPP && rover->Scover) + { ps = &rover->Scover; + rover = *ps; + } + else + if (rover->Sclass == SCstruct) + { + if (!(s->Stype->Tflags & TFforward)) + { // Replace rover with s in symbol table + //printf("Replacing '%s'\n",s->Sident); + *ps = s; + s->Sl = rover->Sl; + s->Sr = rover->Sr; + rover->Sl = rover->Sr = NULL; + rover->Stype->Ttag = (Classsym *)s; + symbol_keep(rover); + } + else + s->Stype->Ttag = (Classsym *)rover; + } + } + goto L1; + } + } + ps = (cmp < 0) ? /* if we go down left side */ + &rover->Sl : + &rover->Sr; + } + *ps = s; + if (s->Sclass == SCcomdef) + { s->Sclass = SCglobal; + outcommon(s,type_size(s->Stype)); + } + } + L1: ; + } // for +#ifdef DEBUG + if (flag) symbol_tree_check(*parent); + printf("%d symbols hydrated\n",count); +#endif +} + +#endif + +#if 0 + +/************************************* + * Put symbol table s into parent symbol table. + */ + +void symboltable_hydrate(symbol *s,symbol **parent) +{ + while (s) + { symbol *sl,*sr; + char *p; + + symbol_debug(s); + + sl = s->Sl; + sr = s->Sr; + p = s->Sident; + + //dbg_printf("symboltable_hydrate('%s')\n",p); + + /* Put symbol s into symbol table */ + { symbol **ps; + symbol *rover; + int c = *p; + + ps = parent; + while ((rover = *ps) != NULL) + { int cmp; + + if ((cmp = c - rover->Sident[0]) == 0) + { cmp = strcmp(p,rover->Sident); /* compare identifier strings */ + if (cmp == 0) + { + if (CPP && tyfunc(s->Stype->Tty) && tyfunc(rover->Stype->Tty)) + { symbol **ps; + symbol *sn; + + do + { + // Tack onto end of overloaded function list + for (ps = &rover; *ps; ps = &(*ps)->Sfunc->Foversym) + { if (cpp_funccmp(s, *ps)) + goto L2; + } + s->Sl = s->Sr = NULL; + *ps = s; + L2: + sn = s->Sfunc->Foversym; + s->Sfunc->Foversym = NULL; + s = sn; + } while (s); + } + else + { + if (!typematch(s->Stype,rover->Stype,0)) + { + // cpp_predefine() will define this again + if (type_struct(rover->Stype) && + rover->Sstruct->Sflags & STRpredef) + { s->Sl = s->Sr = NULL; + symbol_keep(s); + } + else + synerr(EM_multiple_def,p); // already defined + } + } + goto L1; + } + } + ps = (cmp < 0) ? /* if we go down left side */ + &rover->Sl : + &rover->Sr; + } + { + s->Sl = s->Sr = NULL; + *ps = s; + } + } + L1: + symboltable_hydrate(sl,parent); + s = sr; + } +} + +#endif + + +/************************************ + * Hydrate/dehydrate an mptr_t. + */ + +#if HYDRATE +STATIC void mptr_hydrate(mptr_t **pm) +{ mptr_t *m; + + m = (mptr_t *) ph_hydrate(pm); + symbol_hydrate(&m->MPf); + symbol_hydrate(&m->MPparent); +} +#endif + +#if DEHYDRATE +STATIC void mptr_dehydrate(mptr_t **pm) +{ mptr_t *m; + + m = *pm; + if (m && !isdehydrated(m)) + { + ph_dehydrate(pm); +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(m->MPf)) + ph_dehydrate(&m->MPf); + else +#endif + symbol_dehydrate(&m->MPf); + symbol_dehydrate(&m->MPparent); + } +} +#endif + +/************************************ + * Hydrate/dehydrate a baseclass_t. + */ + +#if HYDRATE +STATIC void baseclass_hydrate(baseclass_t **pb) +{ baseclass_t *b; + + assert(pb); + while (isdehydrated(*pb)) + { + b = (baseclass_t *) ph_hydrate(pb); + + ph_hydrate(&b->BCbase); + ph_hydrate(&b->BCpbase); + list_hydrate(&b->BCpublics,(list_free_fp)symbol_hydrate); +#if VBTABLES +#else + symbol_hydrate(&b->param); +#endif + list_hydrate(&b->BCmptrlist,(list_free_fp)mptr_hydrate); + symbol_hydrate(&b->BCvtbl); + Classsym_hydrate(&b->BCparent); + + pb = &b->BCnext; + } +} +#endif + +/********************************** + * Dehydrate a baseclass_t. + */ + +#if DEHYDRATE +STATIC void baseclass_dehydrate(baseclass_t **pb) +{ baseclass_t *b; + + while ((b = *pb) != NULL && !isdehydrated(b)) + { + ph_dehydrate(pb); + +#if DEBUG_XSYMGEN + if (xsym_gen && ph_in_head(b)) + return; +#endif + + ph_dehydrate(&b->BCbase); + ph_dehydrate(&b->BCpbase); + list_dehydrate(&b->BCpublics,(list_free_fp)symbol_dehydrate); +#if VBTABLES +#else + symbol_dehydrate(&b->param); +#endif + list_dehydrate(&b->BCmptrlist,(list_free_fp)mptr_dehydrate); + symbol_dehydrate(&b->BCvtbl); + Classsym_dehydrate(&b->BCparent); + + pb = &b->BCnext; + } +} +#endif + +/*************************** + * Look down baseclass list to find sbase. + * Returns: + * NULL not found + * pointer to baseclass + */ + +baseclass_t *baseclass_find(baseclass_t *bm,Classsym *sbase) +{ + symbol_debug(sbase); + for (; bm; bm = bm->BCnext) + if (bm->BCbase == sbase) + break; + return bm; +} + +baseclass_t *baseclass_find_nest(baseclass_t *bm,Classsym *sbase) +{ + symbol_debug(sbase); + for (; bm; bm = bm->BCnext) + { + if (bm->BCbase == sbase || + baseclass_find_nest(bm->BCbase->Sstruct->Sbase, sbase)) + break; + } + return bm; +} + +/****************************** + * Calculate number of baseclasses in list. + */ + +#if VBTABLES + +int baseclass_nitems(baseclass_t *b) +{ int i; + + for (i = 0; b; b = b->BCnext) + i++; + return i; +} + +#endif + + +/***************************** + * Go through symbol table preparing it to be written to a precompiled + * header. That means removing references to things in the .OBJ file. + */ + +#if SCPP + +void symboltable_clean(symbol *s) +{ + while (s) + { + struct_t *st; + + //printf("clean('%s')\n",s->Sident); + if (config.fulltypes != CVTDB && s->Sxtrnnum && s->Sfl != FLreg) + s->Sxtrnnum = 0; // eliminate debug info type index + switch (s->Sclass) + { + case SCstruct: + s->Stypidx = 0; + st = s->Sstruct; + assert(st); + symboltable_clean(st->Sroot); + //list_apply(&st->Sfldlst,(list_free_fp)symboltable_clean); + break; + + case SCtypedef: + case SCenum: + s->Stypidx = 0; + break; +#if 1 + case SCtemplate: + { template_t *tm = s->Stemplate; + + list_apply(&tm->TMinstances,(list_free_fp)symboltable_clean); + break; + } +#endif + case SCnamespace: + symboltable_clean(s->Snameroot); + break; + + default: + if (s->Sxtrnnum && s->Sfl != FLreg) + s->Sxtrnnum = 0; // eliminate external symbol index + if (tyfunc(s->Stype->Tty)) + { + func_t *f = s->Sfunc; + SYMIDX si; + + debug(assert(f)); + + list_apply(&f->Fsymtree,(list_free_fp)symboltable_clean); + for (si = 0; si < f->Flocsym.top; si++) + symboltable_clean(f->Flocsym.tab[si]); + if (f->Foversym) + symboltable_clean(f->Foversym); + if (f->Fexplicitspec) + symboltable_clean(f->Fexplicitspec); + } + break; + } + if (s->Sl) + symboltable_clean(s->Sl); + if (s->Scover) + symboltable_clean(s->Scover); + s = s->Sr; + } +} + +#endif + +#if SCPP + +/* + * Balance our symbol tree in place. This is nice for precompiled headers, since they + * will typically be written out once, but read in many times. We balance the tree in + * place by traversing the tree inorder and writing the pointers out to an ordered + * list. Once we have a list of symbol pointers, we can create a tree by recursively + * dividing the list, using the midpoint of each division as the new root for that + * subtree. + */ + +struct Balance +{ + unsigned nsyms; + symbol **array; + unsigned index; +}; + +static Balance balance; + +STATIC void count_symbols(symbol *s) +{ + while (s) + { + balance.nsyms++; + switch (s->Sclass) + { + case SCnamespace: + symboltable_balance(&s->Snameroot); + break; + + case SCstruct: + symboltable_balance(&s->Sstruct->Sroot); + break; + } + count_symbols(s->Sl); + s = s->Sr; + } +} + +STATIC void place_in_array(symbol *s) +{ + while (s) + { + place_in_array(s->Sl); + balance.array[balance.index++] = s; + s = s->Sr; + } +} + +/* + * Create a tree in place by subdividing between lo and hi inclusive, using i + * as the root for the tree. When the lo-hi interval is one, we've either + * reached a leaf or an empty node. We subdivide below i by halving the interval + * between i and lo, and using i-1 as our new hi point. A similar subdivision + * is created above i. + */ +STATIC symbol * create_tree(int i, int lo, int hi) +{ + symbol *s = balance.array[i]; + + if (i < lo || i > hi) /* empty node ? */ + return NULL; + + assert((unsigned) i < balance.nsyms); + if (i == lo && i == hi) { /* leaf node ? */ + s->Sl = NULL; + s->Sr = NULL; + return s; + } + + s->Sl = create_tree((i + lo) / 2, lo, i - 1); + s->Sr = create_tree((i + hi + 1) / 2, i + 1, hi); + + return s; +} + +#define METRICS 0 + +#if METRICS +void symbol_table_metrics(void); +#endif + +void symboltable_balance(symbol **ps) +{ + Balance balancesave; +#if METRICS + long ticks; + + dbg_printf("symbol table before balance:\n"); + symbol_table_metrics(); + ticks = clock(); +#endif + balancesave = balance; // so we can nest + balance.nsyms = 0; + count_symbols(*ps); + //dbg_printf("Number of global symbols = %d\n",balance.nsyms); + +#if __INTSIZE == 2 + // Don't balance tree if we get 16 bit overflow + if (balance.nsyms >= (unsigned)(0x10000 / sizeof(symbol *))) + goto Lret; +#endif + + // Use malloc instead of mem because of pagesize limits + balance.array = (symbol **) malloc(balance.nsyms * sizeof(symbol *)); + if (!balance.array) + goto Lret; // no error, just don't balance + + balance.index = 0; + place_in_array(*ps); + + *ps = create_tree(balance.nsyms / 2, 0, balance.nsyms - 1); + + free(balance.array); +#if METRICS + dbg_printf("time to balance: %ld\n", clock() - ticks); + dbg_printf("symbol table after balance:\n"); + symbol_table_metrics(); +#endif +Lret: + balance = balancesave; +} + +#endif + +/***************************************** + * Symbol table search routine for members of structs, given that + * we don't know which struct it is in. + * Give error message if it appears more than once. + * Returns: + * NULL member not found + * symbol* symbol matching member + */ + +#if SCPP + +struct Paramblock // to minimize stack usage in helper function +{ const char *id; // identifier we are looking for + symbol *sm; // where to put result + symbol *s; +}; + +STATIC void membersearchx(struct Paramblock *p,symbol *s) +{ symbol *sm; + list_t sl; + + while (s) + { symbol_debug(s); + + switch (s->Sclass) + { case SCstruct: + for (sl = s->Sstruct->Sfldlst; sl; sl = list_next(sl)) + { sm = list_symbol(sl); + symbol_debug(sm); + if ((sm->Sclass == SCmember || sm->Sclass == SCfield) && + strcmp(p->id,sm->Sident) == 0) + { + if (p->sm && p->sm->Smemoff != sm->Smemoff) + synerr(EM_ambig_member,p->id,s->Sident,p->s->Sident); // ambiguous reference to id + p->s = s; + p->sm = sm; + break; + } + } + break; + } + + if (s->Sl) + membersearchx(p,s->Sl); + s = s->Sr; + } +} + +symbol *symbol_membersearch(const char *id) +{ + list_t sl; + struct Paramblock pb; + Scope *sc; + + pb.id = id; + pb.sm = NULL; + for (sc = scope_end; sc; sc = sc->next) + { + if (sc->sctype & (CPP ? (SCTglobal | SCTlocal) : (SCTglobaltag | SCTtag))) + membersearchx((struct Paramblock *)&pb,(symbol *)sc->root); + } + return pb.sm; +} + +/******************************************* + * Generate debug info for global struct tag symbols. + */ + +STATIC void symbol_gendebuginfox(symbol *s) +{ + for (; s; s = s->Sr) + { + if (s->Sl) + symbol_gendebuginfox(s->Sl); + if (s->Scover) + symbol_gendebuginfox(s->Scover); + switch (s->Sclass) + { + case SCenum: + if (CPP && s->Senum->SEflags & SENnotagname) + break; + goto Lout; + case SCstruct: + if (s->Sstruct->Sflags & STRanonymous) + break; + goto Lout; + case SCtypedef: + Lout: + if (!s->Stypidx) + cv_outsym(s); + break; + } + } +} + +void symbol_gendebuginfo() +{ Scope *sc; + + for (sc = scope_end; sc; sc = sc->next) + { + if (sc->sctype & (SCTglobaltag | SCTglobal)) + symbol_gendebuginfox((symbol *)sc->root); + } +} + +#endif + +#endif /* !SPP */ + diff --git a/backend/tassert.h b/backend/tassert.h new file mode 100644 index 00000000..3e9e8410 --- /dev/null +++ b/backend/tassert.h @@ -0,0 +1,54 @@ +// Copyright (C) 1989-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +//#pragma once +#ifndef TASSERT_H +#define TASSERT_H 1 + +/***************************** + * Define a local assert function. + */ + +#undef assert +#define assert(e) ((e) || (local_assert(__LINE__), 0)) + +#if __clang__ + +void util_assert ( char * , int ) __attribute__((analyzer_noreturn)); + +static void local_assert(int line) +{ + util_assert(__file__,line); + __builtin_unreachable(); +} + +#else + +#if _MSC_VER +__declspec(noreturn) +#endif +void util_assert ( char * , int ); + +static void local_assert(int line) +{ + util_assert(__file__,line); +} + +#if __DMC__ +#pragma noreturn(util_assert) +#pragma noreturn(local_assert) +#endif + +#endif + + +#endif /* TASSERT_H */ diff --git a/backend/ti_achar.c b/backend/ti_achar.c new file mode 100644 index 00000000..f59dc2e7 --- /dev/null +++ b/backend/ti_achar.c @@ -0,0 +1,61 @@ + +// Copyright (c) 2006-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#include +#include + +#include "tinfo.h" + + +// char* + +TypeInfo_Achar ti_achar; + +const char* TypeInfo_Achar::toString() +{ + return "char*"; +} + +hash_t TypeInfo_Achar::getHash(void *p) +{ char* s; + hash_t hash = 0; + + for (s = *(char**)p; *s; s++) + { + hash = hash * 11 + *s; + } + return hash; +} + +int TypeInfo_Achar::equals(void *p1, void *p2) +{ + char* s1 = *(char**)p1; + char* s2 = *(char**)p2; + + return strcmp(s1, s2) == 0; +} + +int TypeInfo_Achar::compare(void *p1, void *p2) +{ + char* s1 = *(char**)p1; + char* s2 = *(char**)p2; + + return strcmp(s1, s2); +} + +size_t TypeInfo_Achar::tsize() +{ + return sizeof(char*); +} + +void TypeInfo_Achar::swap(void *p1, void *p2) +{ +} + diff --git a/backend/ti_pvoid.c b/backend/ti_pvoid.c new file mode 100644 index 00000000..205cdbc7 --- /dev/null +++ b/backend/ti_pvoid.c @@ -0,0 +1,54 @@ + +// Copyright (c) 2011-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#include + +#include "tinfo.h" + + +// void* + +TypeInfo_Pvoid ti_pvoid; + +const char* TypeInfo_Pvoid::toString() +{ + return "void*"; +} + +hash_t TypeInfo_Pvoid::getHash(void *p) +{ void* s = *(void **)p; + return (hash_t)s; +} + +int TypeInfo_Pvoid::equals(void *p1, void *p2) +{ + void* s1 = *(void**)p1; + void* s2 = *(void**)p2; + + return s1 == s2; +} + +int TypeInfo_Pvoid::compare(void *p1, void *p2) +{ + void* s1 = *(void**)p1; + void* s2 = *(void**)p2; + + return (s1 < s2) ? -1 : ((s1 == s2) ? 0 : 1); +} + +size_t TypeInfo_Pvoid::tsize() +{ + return sizeof(void*); +} + +void TypeInfo_Pvoid::swap(void *p1, void *p2) +{ +} + diff --git a/backend/tinfo.h b/backend/tinfo.h new file mode 100644 index 00000000..45c5a380 --- /dev/null +++ b/backend/tinfo.h @@ -0,0 +1,52 @@ + +// Copyright (c) 2000-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gpl.txt. +// See the included readme.txt for details. + + +#ifndef TYPEINFO_H +#define TYPEINFO_H + +#include + +typedef size_t hash_t; + +struct TypeInfo +{ + virtual const char* toString() = 0; + virtual hash_t getHash(void *p) = 0; + virtual int equals(void *p1, void *p2) = 0; + virtual int compare(void *p1, void *p2) = 0; + virtual size_t tsize() = 0; + virtual void swap(void *p1, void *p2) = 0; +}; + +struct TypeInfo_Achar : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +extern TypeInfo_Achar ti_achar; + +struct TypeInfo_Pvoid : TypeInfo +{ + const char* toString(); + hash_t getHash(void *p); + int equals(void *p1, void *p2); + int compare(void *p1, void *p2); + size_t tsize(); + void swap(void *p1, void *p2); +}; + +extern TypeInfo_Pvoid ti_pvoid; + +#endif diff --git a/backend/token.h b/backend/token.h new file mode 100644 index 00000000..b00d0da2 --- /dev/null +++ b/backend/token.h @@ -0,0 +1,458 @@ +// Copyright (C) 1984-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/********************************** + * Symbol tokens: + * + * TKstar * TKdot . TKeq = + * TKand & TKlbra [ TKaddass += + * TKmin - TKrbra ] TKminass -= + * TKnot ! TKarrow -> TKmulass *= + * TKcom ~ TKdiv / TKdivass /= + * TKplpl ++ TKmod % TKmodass %= + * TKlpar ( TKxor ^ TKshrass >>= + * TKrpar ) TKor | TKshlass <<= + * TKques ? TKoror || TKandass &= + * TKcolon : TKandand && TKxorass ^= + * TKcomma , TKshl << TKorass |= + * TKmimi -- TKshr >> TKsemi ; + * TKlcur { TKrcur } TKlt < + * TKle <= TKgt > TKge >= + * TKeqeq == TKne != TKadd + + * TKellipsis ... TKcolcol :: TKdollar $ + * + * Other tokens: + * + * TKstring string + * TKfilespec + */ + +//#pragma once +#ifndef TOKEN_H +#define TOKEN_H 1 + +#if !defined(TOKENS_ONLY) || TOKENS_ONLY +// Keyword tokens. Needn't be ascii sorted +typedef unsigned char enum_TK; +enum TK { + TKauto, + TKbreak, + TKcase, + TKchar, + TKconst, + TKcontinue, + TKdefault, + TKdo, + TKdouble, + TKelse, + TKenum, + TKextern, + TKfloat, + TKfor, + TKgoto, + TKif, + TKint, + TKlong, + TKregister, + TKreturn, + TKshort, + TKsigned, + TKsizeof, + TKstatic, + TKstruct, + TKswitch, + TKtypedef, + TKunion, + TKunsigned, + TKvoid, + TKvolatile, + TKwhile, + + // ANSI C99 + TK_Complex, + TK_Imaginary, + TKrestrict, + +//#if CPP + TKbool, + TKcatch, + TKclass, + TKconst_cast, + TKdelete, + TKdynamic_cast, + TKexplicit, + TKfalse, + TKfriend, + TKinline, + TKmutable, + TKnamespace, + TKnew, + TKoperator, + TKoverload, + TKprivate, + TKprotected, + TKpublic, + TKreinterpret_cast, + TKstatic_cast, + TKtemplate, + TKthis, + TKthrow, + TKtrue, + TKtry, + TKtypeid, + TKtypename, + TKusing, + TKvirtual, + TKwchar_t, + TK_typeinfo, + TK_typemask, +//#endif + +#if CPP0X + TKalignof, + TKchar16_t, + TKchar32_t, + TKconstexpr, + TKdecltype, + TKnoexcept, + TKnullptr, + TKstatic_assert, + TKthread_local, +#endif + + TKasm, + TK_inf, + TK_nan, + TK_nans, + TK_i, // imaginary constant i + TK_with, + TK_istype, + TK_cdecl, + TK_fortran, + TK_pascal, + + TK_debug, + TK_in, + TK_out, + TK_body, + TK_invariant, +#if TX86 + TK_Seg16, + TK_System, + TK__emit__, + TK_far, + TK_huge, + TK_near, + + TK_asm, + TK_based, + TK_cs, + TK_declspec, + TK_except, + TK_export, + TK_far16, + TK_fastcall, + TK_finally, + TK_handle, + TK_java, + TK_int64, + TK_interrupt, + TK_leave, + TK_loadds, + TK_real80, + TK_saveregs, + TK_segname, + TK_ss, + TK_stdcall, + TK_syscall, + TK_try, +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + TK_attribute, + TK_extension, + TK_format, + TK_restrict, + TK_bltin_const, +#endif +#else + TKcomp, + TKextended, + TK_handle, + TK_machdl, + TK_pasobj, +//#if CPP + TK__class, + TKinherited, +//#endif +#endif + TK_unaligned, + TKsymbol, // special internal token + +#define KWMAX (TK_unaligned + 1) // number of keywords + + TKcolcol, // :: + TKarrowstar, // ->* + TKdotstar, // .* + + TKstar,TKand,TKmin,TKnot,TKcom,TKplpl,TKlpar,TKrpar,TKques,TKcolon,TKcomma, + TKmimi,TKlcur,TKdot,TKlbra,TKrbra,TKarrow,TKdiv,TKmod,TKxor,TKor,TKoror, + TKandand,TKshl,TKshr,TKrcur,TKeq,TKaddass,TKminass,TKmulass,TKdivass, + TKmodass,TKshrass,TKshlass,TKandass,TKxorass,TKorass,TKsemi, + TKadd,TKellipsis, +#if !TX86 || TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + TKdollar, +#endif + + /* The following relational tokens must be in the same order as the + corresponding operators. + */ + /* == != */ + TKle,TKgt,TKlt,TKge,TKeqeq,TKne, + + /* !<>= <> <>= !> !>= !< !<= !<> */ + TKunord,TKlg,TKleg,TKule,TKul,TKuge,TKug,TKue, + + TKstring, + TKfilespec, /* */ + TKpragma, + TKnum, /* integral number */ + TKreal_f, + TKreal_d, + TKreal_da, + TKreal_ld, + TKident, /* identifier */ + TKeol, /* end of line */ + TKeof, /* end of file */ + TKnone, /* no token */ + TKMAX /* number of tokens */ +}; +#endif + +#if !defined(TOKENS_ONLY) || !TOKENS_ONLY +struct token_t +{ + enum_TK TKval; // what the token is + unsigned char TKflags; // Token flags +#define TKFfree 1 // free the token after it's scanned +#define TKFinherited 2 // keyword INHERITED prior to token +#define TKFpasstr 4 // pascal string + unsigned char TKty; // TYxxxx for TKstring and TKnum + union _TKutok + { + // Scheme for short IDs avoids malloc/frees + struct _ident // TKident + { char *ident; // pointer to identifier + char idtext[4]; // if short identifier + } _idx; + + struct _uts /* TKstring and TKfilespec */ + { + char *string;/* for strings (not null terminated) */ + int lenstr; /* length of string */ + } uts; + symbol *sym; // TKsymbol + int pragma; // TKpragma: PRxxxx, pragma number + // -1 if unrecognized pragma + targ_long Vlong; /* integer when TKnum */ +#if LONGLONG + targ_llong Vllong; +#else +#define Vllong Vlong +#endif + targ_float Vfloat; + targ_double Vdouble; + targ_ldouble Vldouble; + } TKutok; + Srcpos TKsrcpos; // line number from where it was taken + token_t *TKnext; // to create a list of tokens + +#ifdef DEBUG + unsigned short id; +#define IDtoken 0xA745 +#define token_debug(e) assert((e)->id == IDtoken) +#else +#define token_debug(e) +#endif + + void setSymbol(symbol *s); + void print(); +}; + +#define TKstr TKutok.uts.string +#define TKlenstr TKutok.uts.lenstr +#define TKid TKutok._idx.ident +#define TKsym TKutok.sym + +// Use this for fast scans +#define _IDS 1 // start of identifier +#define _ID 2 // identifier +#define _TOK 4 // single character token +#define _EOL 8 // end of line +#define _MUL 0x10 // start of multibyte character sequence +#define _BCS 0x20 // in basic-source-character-set +#define _MTK 0x40 // could be multi-character token +#define _ZFF 0x80 // 0 or 0xFF (must be sign bit) + +#define istok(x) (_chartype[(x) + 1] & _TOK) +#define iseol(x) (_chartype[(x) + 1] & _EOL) +#define isidstart(x) (_chartype[(x) + 1] & _IDS) +#define isidchar(x) (_chartype[(x) + 1] & (_IDS | _ID)) +#define ismulti(x) (_chartype[(x) + 1] & _MUL) +#define isbcs(x) (_chartype[(x) + 1] & _BCS) + +/* from token.c */ +extern int igncomment; +extern char *tok_arg; +extern unsigned argmax; +extern token_t tok; +extern int ininclude; +CEXTERN char tok_ident[]; // identifier +extern unsigned char _chartype[]; +extern token_t *toklist; + +void token_setdbcs(int); +void token_setlocale(const char *); +token_t *token_copy(void); +void token_free(token_t *tl); +void token_hydrate(token_t **ptl); +void token_dehydrate(token_t **ptl); +token_t *token_funcbody(int bFlag); +token_t *token_defarg(void); +void token_funcbody_print(token_t *t); +void token_setlist(token_t *t); +void token_poplist(void); +void token_unget(void); +void token_markfree(token_t *t); +void token_setident(char *); +void token_semi(void); +Srcpos token_linnum(void); +enum_TK token_peek(); + +enum_TK rtoken(int); +#if SPP +#define stoken() rtoken(1) +#else +enum_TK stokenx(void); +inline enum_TK stoken() { return toklist ? stokenx() : rtoken(1); } +#endif + +void token_init(void); +void removext(void); +void __near comment(void); +void __near cppcomment(void); +char *combinestrings(targ_size_t *plen); +char *combinestrings(targ_size_t *plen, tym_t *pty); +void __near inident(void); +void inidentX(char *p); +unsigned comphash(const char *p); +int insertSpace(unsigned char xclast, unsigned char xcnext); +void panic(enum_TK ptok); +void chktok(enum_TK toknum , unsigned errnum); +void chktok(enum_TK toknum , unsigned errnum, const char *str); +void opttok(enum_TK toknum); +bool iswhite(int c); +void token_term(void); + +#define ptoken() rtoken(1) +#define token() rtoken(0) + +#if !MARS +/* from pragma.c */ +//enum_TK ptoken(void); +void pragma_process(); +int __near pragma_search(char *id); +macro_t * __near macfind(void); +void __near listident(void); +void pragma_term(void); +macro_t *defmac(const char *name , const char *text); +int pragma_defined(void); +#endif + +#if SPP && TX86 +#define token_linnum() getlinnum() +#endif + +// listing control +// Listings can be produce via -l and SCpre +// -l expand all characters not if'd out including +// comments +// SCpre list only characters to be compiled +// i.e. exclude comments and # preprocess lines + +#if SPP +#define SCPRE_LISTING_ON() expflag--; assert(expflag >= 0) +#define SCPRE_LISTING_OFF() assert(expflag >= 0); expflag++ +#define EXPANDED_LISTING_ON() expflag--; assert(expflag >= 0) +#define EXPANDED_LISTING_OFF() assert(expflag >= 0); expflag++ +#else +#define SCPRE_LISTING_OFF() +#define SCPRE_LISTING_ON() +#define EXPANDED_LISTING_ON() expflag--; assert(expflag >= 0) +#define EXPANDED_LISTING_OFF() assert(expflag >= 0); expflag++ +#endif + +#define EXPANDING_LISTING() (expflag == 0) +#define NOT_EXPANDING_LISTING() (expflag) +#endif + +/*********************************************** + * This is the token lookahead API, which enables us to + * look an arbitrary number of tokens ahead and then + * be able to 'unget' all of them. + */ + +struct Token_lookahead +{ + int inited; // 1 if initialized + token_t *toks; // list of tokens + token_t **pend; // pointer to end of that list + + void init() + { + toks = NULL; + pend = &toks; + inited = 1; + } + + enum_TK lookahead() + { + #ifdef DEBUG + //assert(inited == 1); + #endif + *pend = token_copy(); + (*pend)->TKflags |= TKFfree; + pend = &(*pend)->TKnext; + return stoken(); + } + + void term() + { +#ifdef DEBUG + //assert(inited == 1); +#endif + inited--; + if (toks) + { + token_unget(); + token_setlist(toks); + stoken(); + } + } + + void discard() + { + inited--; + token_free(toks); + } +}; + + +#endif /* TOKEN_H */ diff --git a/backend/ty.h b/backend/ty.h new file mode 100644 index 00000000..120c7933 --- /dev/null +++ b/backend/ty.h @@ -0,0 +1,377 @@ +// Copyright (C) 1983-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + + +#if __SC__ +#pragma once +#endif + +#ifndef TY_H +#define TY_H 1 + +//#define TYjhandle TYnptr // use for Jupiter handle + +/***************************************** + * Data types. + * (consists of basic type + modifier bits) + */ + +// Basic types. +// casttab[][] in exp2.c depends on the order of this +// typromo[] in cpp.c depends on the order too + +enum TYM +{ + TYbool = 0, + TYchar = 1, + TYschar = 2, // signed char + TYuchar = 3, // unsigned char + TYchar8 = 4, + TYchar16 = 5, + TYshort = 6, + TYwchar_t = 7, + TYushort = 8, // unsigned short + TYenum = 9, // enumeration value + TYint = 0xA, + TYuint = 0xB, // unsigned + TYlong = 0xC, + TYulong = 0xD, // unsigned long + TYdchar = 0xE, // 32 bit Unicode char + TYllong = 0xF, // 64 bit long + TYullong = 0x10, // 64 bit unsigned long + TYfloat = 0x11, // 32 bit real + TYdouble = 0x12, // 64 bit real + + // long double is mapped to either of the following at runtime: + TYdouble_alias = 0x13, // 64 bit real (but distinct for overload purposes) + TYldouble = 0x14, // 80 bit real + + // Add imaginary and complex types for D and C99 + TYifloat = 0x15, + TYidouble = 0x16, + TYildouble = 0x17, + TYcfloat = 0x18, + TYcdouble = 0x19, + TYcldouble = 0x1A, + + TYjhandle = 0x1B, // Jupiter handle type, equals TYnptr except + // that the debug type is different so the + // debugger can distinguish them + TYnullptr = 0x1C, + TYnptr = 0x1D, // data segment relative pointer + TYref = 0x24, // reference to another type + TYvoid = 0x25, + TYstruct = 0x26, // watch tyaggregate() + TYarray = 0x27, // watch tyaggregate() + TYnfunc = 0x28, // near C func + TYnpfunc = 0x2A, // near Cpp func + TYnsfunc = 0x2C, // near stdcall func + TYifunc = 0x2E, // interrupt func + TYptr = 0x33, // generic pointer type + TYmfunc = 0x37, // NT C++ member func + TYjfunc = 0x38, // LINKd D function + TYhfunc = 0x39, // C function with hidden parameter + TYnref = 0x3A, // near reference + + TYcent = 0x3C, // 128 bit signed integer + TYucent = 0x3D, // 128 bit unsigned integer + +#if TARGET_SEGMENTED + TYsptr = 0x1E, // stack segment relative pointer + TYcptr = 0x1F, // code segment relative pointer + TYf16ptr = 0x20, // special OS/2 far16 pointer + TYfptr = 0x21, // far pointer (has segment and offset) + TYhptr = 0x22, // huge pointer (has segment and offset) + TYvptr = 0x23, // __handle pointer (has segment and offset) + TYffunc = 0x29, // far C func + TYfpfunc = 0x2B, // far Cpp func + TYfsfunc = 0x2D, // far stdcall func + TYf16func = 0x34, // _far16 _pascal function + TYnsysfunc = 0x35, // near __syscall func + TYfsysfunc = 0x36, // far __syscall func + TYfref = 0x3B, // far reference +#endif + +#if !MARS + TYmemptr = 0x2F, // pointer to member + TYident = 0x30, // type-argument + TYtemplate = 0x31, // unexpanded class template + TYvtshape = 0x32, // virtual function table +#endif + + // SIMD vector types // D type + TYfloat4 = 0x3E, // float[4] + TYdouble2 = 0x3F, // double[2] + TYschar16 = 0x40, // byte[16] + TYuchar16 = 0x41, // ubyte[16] + TYshort8 = 0x42, // short[8] + TYushort8 = 0x43, // ushort[8] + TYlong4 = 0x44, // int[4] + TYulong4 = 0x45, // uint[4] + TYllong2 = 0x46, // long[2] + TYullong2 = 0x47, // ulong[2] + +#if MARS +#define TYaarray TYnptr +#define TYdelegate (I64 ? TYcent : TYllong) +#define TYdarray (I64 ? TYucent : TYullong) +#endif + + TYMAX = 0x48, +}; + +#define mTYbasic 0xFF /* bit mask for basic types */ +#define tybasic(ty) ((ty) & mTYbasic) + +#if TX86 +// These change depending on memory model +extern int TYptrdiff, TYsize, TYsize_t; + +/* Linkage type */ +#define mTYnear 0x0800 +#if TARGET_SEGMENTED +#define mTYfar 0x1000 +#define mTYcs 0x2000 // in code segment +#endif +#define mTYthread 0x4000 +#define mTYLINK 0x7800 // all linkage bits + +#define mTYloadds 0x08000 +#define mTYexport 0x10000 +#define mTYweak 0x00000 +#define mTYimport 0x20000 +#define mTYnaked 0x40000 +#define mTYMOD 0x78000 // all modifier bits + +#else +#define TYTARG 0x11 +#include "TGty.h" /* Target types */ +#endif + +/* Modifiers to basic types */ + +#ifdef JHANDLE +#define mTYarrayhandle 0x200 +#else +#define mTYarrayhandle 0x0 +#endif +#define mTYconst 0x100 +#define mTYvolatile 0x200 +#define mTYrestrict 0 // BUG: add for C99 +#define mTYmutable 0 // need to add support +#define mTYunaligned 0 // non-zero for PowerPC + +#define mTYimmutable 0x00080000 // immutable data +#define mTYshared 0x00100000 // shared data +#define mTYnothrow 0x00200000 // nothrow function + +#if !MARS +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define mTYnoret 0x01000000 // function has no return +#define mTYtransu 0x01000000 // transparent union +#else +#define mTYfar16 0x01000000 +#endif +#define mTYstdcall 0x02000000 +#define mTYfastcall 0x04000000 +#define mTYinterrupt 0x08000000 +#define mTYcdecl 0x10000000 +#define mTYpascal 0x20000000 +#define mTYsyscall 0x40000000 +#define mTYjava 0x80000000 + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define mTYTFF 0xFE000000 +#else +#define mTYTFF 0xFF000000 +#endif +#endif + +/* Flags in tytab[] array */ +extern unsigned tytab[]; +#define TYFLptr 1 +#define TYFLreal 2 +#define TYFLintegral 4 +#define TYFLcomplex 8 +#define TYFLimaginary 0x10 +#define TYFLuns 0x20 +#define TYFLmptr 0x40 +#define TYFLfv 0x80 /* TYfptr || TYvptr */ + +#if TX86 +#define TYFLfarfunc 0x100 +#define TYFLpascal 0x200 // callee cleans up stack +#define TYFLrevparam 0x400 // function parameters are reversed +#define TYFLxmmreg 0x10000 // can be put in XMM register +#else +#define TYFLcallstkc 0x100 // callee cleans up stack +#define TYFLrevparam 0x200 // function parameters are reversed +#endif +#define TYFLnullptr 0x800 +#define TYFLshort 0x1000 +#define TYFLaggregate 0x2000 +#define TYFLfunc 0x4000 +#define TYFLref 0x8000 + +/* Groupings of types */ + +#define tyintegral(ty) (tytab[(ty) & 0xFF] & TYFLintegral) + +#define tyarithmetic(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex)) + +#define tyaggregate(ty) (tytab[(ty) & 0xFF] & TYFLaggregate) + +#define tyscalar(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex | TYFLptr | TYFLmptr | TYFLnullptr)) + +#define tyfloating(ty) (tytab[(ty) & 0xFF] & (TYFLreal | TYFLimaginary | TYFLcomplex)) + +#define tyimaginary(ty) (tytab[(ty) & 0xFF] & TYFLimaginary) + +#define tycomplex(ty) (tytab[(ty) & 0xFF] & TYFLcomplex) + +#define tyreal(ty) (tytab[(ty) & 0xFF] & TYFLreal) + +// Fits into 64 bit register +#define ty64reg(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLptr) && tysize(ty) <= NPTRSIZE) + +// Can go in XMM floating point register +#define tyxmmreg(ty) (tytab[(ty) & 0xFF] & TYFLxmmreg) + +// Is a vector type +#define tyvector(ty) (tybasic(ty) >= TYfloat4 && tybasic(ty) <= TYullong2) + +#ifndef tyshort +/* Types that are chars or shorts */ +#define tyshort(ty) (tytab[(ty) & 0xFF] & TYFLshort) +#endif + +/* Detect TYlong or TYulong */ +#ifndef tylong +#define tylong(ty) (tybasic(ty) == TYlong || tybasic(ty) == TYulong) +#endif + +/* Use to detect a pointer type */ +#ifndef typtr +#define typtr(ty) (tytab[(ty) & 0xFF] & TYFLptr) +#endif + +/* Use to detect a reference type */ +#ifndef tyref +#define tyref(ty) (tytab[(ty) & 0xFF] & TYFLref) +#endif + +/* Use to detect a pointer type or a member pointer */ +#ifndef tymptr +#define tymptr(ty) (tytab[(ty) & 0xFF] & (TYFLptr | TYFLmptr)) +#endif + +// Use to detect a nullptr type or a member pointer +#ifndef tynullptr +#define tynullptr(ty) (tytab[(ty) & 0xFF] & TYFLnullptr) +#endif + +/* Detect TYfptr or TYvptr */ +#ifndef tyfv +#define tyfv(ty) (tytab[(ty) & 0xFF] & TYFLfv) +#endif + +/* Array to give the size in bytes of a type, -1 means error */ +extern signed char tysize[]; +extern signed char tyalignsize[]; + +// Give size of type +#define tysize(ty) tysize[(ty) & 0xFF] +#define tyalignsize(ty) tyalignsize[(ty) & 0xFF] + +/* All data types that fit in exactly 8 bits */ +#ifndef tybyte +#define tybyte(ty) (tysize(ty) == 1) +#endif + +/* Types that fit into a single machine register */ +#ifndef tyreg +#define tyreg(ty) (tysize(ty) <= REGSIZE) +#endif + +/* Detect function type */ +#ifndef tyfunc +#define tyfunc(ty) (tytab[(ty) & 0xFF] & TYFLfunc) +#endif + +/* Detect function type where parameters are pushed left to right */ +#ifndef tyrevfunc +#define tyrevfunc(ty) (tytab[(ty) & 0xFF] & TYFLrevparam) +#endif + +/* Detect unsigned types */ +#ifndef tyuns +#define tyuns(ty) (tytab[(ty) & 0xFF] & (TYFLuns | TYFLptr)) +#endif + +/* Target dependent info */ +#if TX86 +#define TYoffset TYuint /* offset to an address */ + +/* Detect cpp function type (callee cleans up stack) */ +#define typfunc(ty) (tytab[(ty) & 0xFF] & TYFLpascal) + +#else +/* Detect cpp function type (callee cleans up stack) */ +#ifndef typfunc +#define typfunc(ty) (tytab[(ty) & 0xFF] & TYFLcallstkc) +#endif +#endif + +/* Array to convert a type to its unsigned equivalent */ +extern const tym_t tytouns[]; +#ifndef touns +#define touns(ty) (tytouns[(ty) & 0xFF]) +#endif + +/* Determine if TYffunc or TYfpfunc (a far function) */ +#ifndef tyfarfunc +#define tyfarfunc(ty) (tytab[(ty) & 0xFF] & TYFLfarfunc) +#endif + +// Determine if parameter can go in register for TYjfunc +#ifndef tyjparam +#define tyjparam(ty) (tysize(ty) <= NPTRSIZE && !tyfloating(ty) && tybasic(ty) != TYstruct && tybasic(ty) != TYarray) +#endif + +/* Determine relaxed type */ +#ifndef tyrelax +#define tyrelax(ty) (_tyrelax[tybasic(ty)]) +#endif + +/* Array to give the 'relaxed' type for relaxed type checking */ +extern unsigned char _tyrelax[]; +#define type_relax (config.flags3 & CFG3relax) // !=0 if relaxed type checking +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#define type_semirelax (config.flags3 & CFG3semirelax) // !=0 if semi-relaxed type checking +#else +#define type_semirelax type_relax +#endif + +/* Determine functionally equivalent type */ +extern unsigned char tyequiv[]; + +/* Give an ascii string for a type */ +extern const char *tystring[]; + +#if TX86 +/* Debugger value for type */ +extern unsigned char dttab[]; +extern unsigned short dttab4[]; +#endif + +#endif /* TY_H */ + diff --git a/backend/type.c b/backend/type.c new file mode 100644 index 00000000..071ad7dc --- /dev/null +++ b/backend/type.c @@ -0,0 +1,1480 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if !SPP + +#include +#include +#include + +#include "cc.h" +#include "global.h" +#include "type.h" +#include "el.h" + +#if SCPP +#include "parser.h" +#endif + +#undef MEM_PH_MALLOC +#define MEM_PH_MALLOC mem_fmalloc + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +static type *type_list = NULL; // free list of types +static param_t *param_list = NULL; // free list of params + +#ifdef DEBUG +static int type_num,type_max; /* gather statistics on # of types */ +#endif + +typep_t tstypes[TYMAX]; +typep_t tsptr2types[TYMAX]; + +typep_t tstrace,tsclib,tsjlib,tsdlib, + tslogical; +typep_t tspvoid,tspcvoid; +typep_t tsptrdiff, tssize; + +/******************************* + * Compute size of type in bytes. + */ + +targ_size_t type_size(type *t) +{ targ_size_t s; + unsigned long u; + tym_t tyb; + + type_debug(t); + tyb = tybasic(t->Tty); +#ifdef DEBUG + if (tyb >= TYMAX) + /*type_print(t),*/ + dbg_printf("tyb = x%lx\n",(long)tyb); +#endif + assert(tyb < TYMAX); + s = tysize[tyb]; + if (s == (targ_size_t) -1) + { + switch (tyb) + { + // in case program plays games with function pointers +#if TARGET_SEGMENTED + case TYffunc: + case TYfpfunc: + case TYfsfunc: + case TYf16func: +#endif + case TYhfunc: + case TYnfunc: /* in case program plays games with function pointers */ + case TYnpfunc: + case TYnsfunc: + case TYifunc: + case TYjfunc: +#if SCPP + if (ANSI) + synerr(EM_unknown_size,"function"); /* size of function is not known */ +#endif + s = 1; + break; + case TYarray: + if (t->Tflags & TFsizeunknown) + { +#if SCPP + synerr(EM_unknown_size,"array"); /* size of array is unknown */ +#endif + t->Tflags &= ~TFsizeunknown; + } + if (t->Tflags & TFvla) + { + s = tysize[pointertype]; + break; + } + s = type_size(t->Tnext); + u = t->Tdim * (unsigned long) s; +#if TX86 && SCPP + type_chksize(u); +#endif + s = u; + break; + case TYstruct: + t = t->Ttag->Stype; /* find main instance */ + /* (for const struct X) */ + if (t->Tflags & TFsizeunknown) + { +#if SCPP + template_instantiate_forward(t->Ttag); + if (t->Tflags & TFsizeunknown) + synerr(EM_unknown_size,t->Tty & TYstruct ? prettyident(t->Ttag) : "struct"); + t->Tflags &= ~TFsizeunknown; +#endif + } + assert(t->Ttag); + s = t->Ttag->Sstruct->Sstructsize; + break; +#if SCPP + case TYenum: + if (t->Ttag->Senum->SEflags & SENforward) + synerr(EM_unknown_size, prettyident(t->Ttag)); + s = type_size(t->Tnext); + break; +#endif + case TYvoid: +#if SCPP && TARGET_WINDOS // GNUC allows it, so we will, too + synerr(EM_void_novalue); // voids have no value +#endif + s = 1; + break; +#if SCPP + case TYref: + case TYmemptr: + case TYvtshape: + s = tysize(tym_conv(t)); + break; + + case TYident: + synerr(EM_unknown_size, t->Tident); + s = 1; + break; +#endif +#if MARS + case TYref: + s = tysize(TYnptr); + break; +#endif + default: +#ifdef DEBUG + WRTYxx(t->Tty); +#endif + assert(0); + } + } + return s; +} + +/******************************** + * Return the size of a type for alignment purposes. + */ + +unsigned type_alignsize(type *t) +{ targ_size_t sz; + +L1: + type_debug(t); + + sz = tyalignsize(t->Tty); + if (sz == (targ_size_t)-1) + { + switch (tybasic(t->Tty)) + { + case TYarray: + if (t->Tflags & TFsizeunknown) + goto err1; + t = t->Tnext; + goto L1; + case TYstruct: + t = t->Ttag->Stype; // find main instance + // (for const struct X) + if (t->Tflags & TFsizeunknown) + goto err1; + sz = t->Ttag->Sstruct->Salignsize; + if (sz > t->Ttag->Sstruct->Sstructalign) + sz = t->Ttag->Sstruct->Sstructalign; + break; + + case TYldouble: + assert(0); + + default: + err1: // let type_size() handle error messages + sz = type_size(t); + break; + } + } + + //printf("type_alignsize() = %d\n", sz); + return sz; +} + +/***************************** + * Compute the size of parameters for function call. + * Used for stdcall name mangling. + * Note that hidden parameters do not contribute to size. + */ + +targ_size_t type_paramsize(type *t) +{ + targ_size_t sz = 0; + if (tyfunc(t->Tty)) + { + for (param_t *p = t->Tparamtypes; p; p = p->Pnext) + { + size_t n = type_size(p->Ptype); + n = align(REGSIZE,n); // align to REGSIZE boundary + sz += n; + } + } + return sz; +} + +/***************************** + * Create a type & initialize it. + * Input: + * ty = TYxxxx + * Returns: + * pointer to newly created type. + */ + +type *type_alloc(tym_t ty) +{ type *t; + static type tzero; + +#if TARGET_SEGMENTED + assert(tybasic(ty) != TYtemplate); +#endif + if (type_list) + { t = type_list; + type_list = t->Tnext; + } + else + t = (type *) mem_fmalloc(sizeof(type)); + tzero.Tty = ty; + *t = tzero; +#if SRCPOS_4TYPES + if (PARSER && config.fulltypes) + t->Tsrcpos = getlinnum(); +#endif +#ifdef DEBUG + t->id = IDtype; + type_num++; + if (type_num > type_max) + type_max = type_num; +#endif + //dbg_printf("type_alloc() = %p ",t); WRTYxx(t->Tty); dbg_printf("\n"); + //if (t == (type*)0xB6B744) *(char*)0=0; + return t; +} + +/************************************* + * Allocate a TYtemplate. + */ + +#if !MARS +type *type_alloc_template(symbol *s) +{ type *t; + + t = (type *) mem_fcalloc(sizeof(typetemp_t)); + t->Tty = TYtemplate; + if (s->Stemplate->TMprimary) + s = s->Stemplate->TMprimary; + ((typetemp_t *)t)->Tsym = s; +#if SRCPOS_4TYPES + if (PARSER && config.fulltypes) + t->Tsrcpos = getlinnum(); +#endif +#ifdef DEBUG + t->id = IDtype; + type_num++; + if (type_num > type_max) + type_max = type_num; + //dbg_printf("Alloc'ing template type %p ",t); WRTYxx(t->Tty); dbg_printf("\n"); +#endif + return t; +} +#endif + +/***************************** + * Fake a type & initialize it. + * Input: + * ty = TYxxxx + * Returns: + * pointer to newly created type. + */ + +type *type_fake(tym_t ty) +{ type *t; + +#if MARS + assert(ty != TYstruct); +#endif + t = type_alloc(ty); + if (typtr(ty) || tyfunc(ty)) + { t->Tnext = type_alloc(TYvoid); /* fake with pointer to void */ + t->Tnext->Tcount = 1; + } + return t; +} + +/***************************** + * Allocate a type of ty with a Tnext of tn. + */ + +type *type_allocn(tym_t ty,type *tn) +{ type *t; + + //printf("type_allocn(ty = x%x, tn = %p)\n", ty, tn); + assert(tn); + type_debug(tn); + t = type_alloc(ty); + t->Tnext = tn; + tn->Tcount++; + //printf("\tt = %p\n", t); + return t; +} + +/****************************** + * Allocate a TYmemptr type. + */ + +#if !MARS +type *type_allocmemptr(Classsym *stag,type *tn) +{ type *t; + + symbol_debug(stag); + assert(stag->Sclass == SCstruct || tybasic(stag->Stype->Tty) == TYident); + t = type_allocn(TYmemptr,tn); + t->Ttag = stag; + //printf("type_allocmemptr() = %p\n", t); + //type_print(t); + return t; +} +#endif + +/***************************** + * Free up data type. + */ + +void type_free(type *t) +{ type *tn; + tym_t ty; + + while (t) + { + //dbg_printf("type_free(%p, Tcount = %d)\n", t, t->Tcount); + type_debug(t); + assert((int)t->Tcount != -1); + if (--t->Tcount) /* if usage count doesn't go to 0 */ + break; + ty = tybasic(t->Tty); + if (tyfunc(ty)) + { param_free(&t->Tparamtypes); + list_free(&t->Texcspec, (list_free_fp)type_free); + } +#if !MARS + else if (ty == TYtemplate) + param_free(&t->Tparamtypes); + else if (ty == TYident) + MEM_PH_FREE(t->Tident); +#endif + else if (t->Tflags & TFvla && t->Tel) + el_free(t->Tel); +#if SCPP + else if (t->Talternate && typtr(ty)) + type_free(t->Talternate); +#endif +#if MARS + else if (t->Tkey && typtr(ty)) + type_free(t->Tkey); +#endif +#ifdef DEBUG + type_num--; + //dbg_printf("Free'ing type %p ",t); WRTYxx(t->Tty); dbg_printf("\n"); + t->id = 0; /* no longer a valid type */ +#endif + tn = t->Tnext; + t->Tnext = type_list; + type_list = t; /* link into free list */ + t = tn; + } +} + +#ifdef STATS +/* count number of free types available on type list */ +type_count_free() + { + type *t; + int count; + + for(t=type_list;t;t=t->Tnext) + count++; + dbg_printf("types on free list %d with max of %d\n",count,type_max); + } +#endif + +/********************************** + * Initialize type package. + */ + +STATIC type * __near type_allocbasic(tym_t ty) +{ type *t; + + t = type_alloc(ty); + t->Tmangle = mTYman_c; + t->Tcount = 1; /* so it is not inadvertantly free'd */ + return t; +} + +void type_init() +{ + tsbool = type_allocbasic(TYbool); + tswchar_t = type_allocbasic(TYwchar_t); + tsdchar = type_allocbasic(TYdchar); + tsvoid = type_allocbasic(TYvoid); + tsnullptr = type_allocbasic(TYnullptr); + tschar16 = type_allocbasic(TYchar16); + tsuchar = type_allocbasic(TYuchar); + tsschar = type_allocbasic(TYschar); + tschar = type_allocbasic(TYchar); + tsshort = type_allocbasic(TYshort); + tsushort = type_allocbasic(TYushort); + tsint = type_allocbasic(TYint); + tsuns = type_allocbasic(TYuint); + tslong = type_allocbasic(TYlong); + tsulong = type_allocbasic(TYulong); + tsllong = type_allocbasic(TYllong); + tsullong = type_allocbasic(TYullong); + tsfloat = type_allocbasic(TYfloat); + tsdouble = type_allocbasic(TYdouble); + tsreal64 = type_allocbasic(TYdouble_alias); + tsldouble = type_allocbasic(TYldouble); + tsifloat = type_allocbasic(TYifloat); + tsidouble = type_allocbasic(TYidouble); + tsildouble = type_allocbasic(TYildouble); + tscfloat = type_allocbasic(TYcfloat); + tscdouble = type_allocbasic(TYcdouble); + tscldouble = type_allocbasic(TYcldouble); + + if (I64) + { + TYptrdiff = TYllong; + TYsize = TYullong; + tsptrdiff = tsllong; + tssize = tsullong; + } + else + { + TYptrdiff = TYint; + TYsize = TYuint; + tsptrdiff = tsint; + tssize = tsuns; + } + + // Type of trace function +#if TARGET_SEGMENTED + tstrace = type_fake(I16 ? TYffunc : TYnfunc); +#else + tstrace = type_fake(TYnfunc); +#endif + tstrace->Tmangle = mTYman_c; + tstrace->Tcount++; + + chartype = (config.flags3 & CFG3ju) ? tsuchar : tschar; + + // Type of far library function +#if TARGET_SEGMENTED + tsclib = type_fake(LARGECODE ? TYfpfunc : TYnpfunc); +#else + tsclib = type_fake(TYnpfunc); +#endif + tsclib->Tmangle = mTYman_c; + tsclib->Tcount++; + + tspvoid = type_allocn(pointertype,tsvoid); + tspvoid->Tmangle = mTYman_c; + tspvoid->Tcount++; + + // Type of far library function + tsjlib = type_fake(TYjfunc); + tsjlib->Tmangle = mTYman_c; + tsjlib->Tcount++; + + tsdlib = tsjlib; + +#if SCPP + tspcvoid = type_alloc(mTYconst | TYvoid); + tspcvoid = newpointer(tspcvoid); + tspcvoid->Tmangle = mTYman_c; + tspcvoid->Tcount++; +#endif + + // Type of logical expression + tslogical = (config.flags4 & CFG4bool) ? tsbool : tsint; + + for (int i = 0; i < TYMAX; i++) + { + if (tstypes[i]) + { tsptr2types[i] = type_allocn(pointertype,tstypes[i]); + tsptr2types[i]->Tcount++; + } + } +} + +/********************************** + * Free type_list. + */ + +#if TERMCODE +void type_term() +{ type *tn; + param_t *pn; + int i; + + for (i = 0; i < arraysize(tstypes); i++) + { type *t = tsptr2types[i]; + + if (t) + { assert(!(t->Tty & (mTYconst | mTYvolatile | mTYimmutable | mTYshared))); + assert(!(t->Tflags)); + assert(!(t->Tmangle)); + type_free(t); + } + type_free(tstypes[i]); + } + + type_free(tsclib); + type_free(tspvoid); + type_free(tspcvoid); + type_free(tsjlib); + type_free(tstrace); + + while (type_list) + { tn = type_list->Tnext; + mem_ffree(type_list); + type_list = tn; + } + + while (param_list) + { pn = param_list->Pnext; + mem_ffree(param_list); + param_list = pn; + } + +#ifdef DEBUG + dbg_printf("Max # of types = %d\n",type_max); + if (type_num != 0) + dbg_printf("type_num = %d\n",type_num); +/* assert(type_num == 0);*/ +#endif +} +#endif // TERMCODE + +/******************************* + * Type type information. + */ + +/************************** + * Make copy of a type. + */ + +type *type_copy(type *t) +{ type *tn; + param_t *p; + + type_debug(t); +#if !MARS + if (tybasic(t->Tty) == TYtemplate) + { + tn = type_alloc_template(((typetemp_t *)t)->Tsym); + } + else +#endif + tn = type_alloc(t->Tty); + *tn = *t; + switch (tybasic(tn->Tty)) + { +#if !MARS + case TYtemplate: + ((typetemp_t *)tn)->Tsym = ((typetemp_t *)t)->Tsym; + goto L1; + + case TYident: + tn->Tident = (char *)MEM_PH_STRDUP(t->Tident); + break; +#endif + + case TYarray: + if (tn->Tflags & TFvla) + tn->Tel = el_copytree(tn->Tel); + break; + + default: + if (tyfunc(tn->Tty)) + { + L1: + tn->Tparamtypes = NULL; + for (p = t->Tparamtypes; p; p = p->Pnext) + { param_t *pn; + + pn = param_append_type(&tn->Tparamtypes,p->Ptype); + if (p->Pident) + { + pn->Pident = (char *)MEM_PH_STRDUP(p->Pident); + } + assert(!p->Pelem); + } + } +#if SCPP + else if (tn->Talternate && typtr(tn->Tty)) + tn->Talternate->Tcount++; +#endif +#if MARS + else if (tn->Tkey && typtr(tn->Tty)) + tn->Tkey->Tcount++; +#endif + break; + } + if (tn->Tnext) + { type_debug(tn->Tnext); + tn->Tnext->Tcount++; + } + tn->Tcount = 0; + return tn; +} + +/************************************ + */ + +#if SCPP + +elem *type_vla_fix(type **pt) +{ + type *t; + elem *e = NULL; + + for (t = *pt; t; t = t->Tnext) + { + type_debug(t); + if (tybasic(t->Tty) == TYarray && t->Tflags & TFvla && t->Tel) + { symbol *s; + elem *ec; + + s = symbol_genauto(tsuns); + ec = el_var(s); + ec = el_bint(OPeq, tsuns, ec, t->Tel); + e = el_combine(e, ec); + t->Tel = el_var(s); + } + } + return e; +} + +#endif + +/**************************** + * Modify the tym_t field of a type. + */ + +type *type_setty(type **pt,long newty) +{ type *t; + + t = *pt; + type_debug(t); + if ((tym_t)newty != t->Tty) + { if (t->Tcount > 1) /* if other people pointing at t */ + { type *tn; + + tn = type_copy(t); + tn->Tcount++; + type_free(t); + t = tn; + *pt = t; + } + t->Tty = newty; + } + return t; +} + +/****************************** + * Set type field of some object to t. + */ + +type *type_settype(type **pt, type *t) +{ + if (t) + { type_debug(t); + t->Tcount++; + } + type_free(*pt); + return *pt = t; +} + +/**************************** + * Modify the Tmangle field of a type. + */ + +type *type_setmangle(type **pt,mangle_t mangle) +{ type *t; + + t = *pt; + type_debug(t); + if (mangle != type_mangle(t)) + { + if (t->Tcount > 1) // if other people pointing at t + { type *tn; + + tn = type_copy(t); + tn->Tcount++; + type_free(t); + t = tn; + *pt = t; + } + t->Tmangle = mangle; + } + return t; +} + +/****************************** + * Set/clear const and volatile bits in *pt according to the settings + * in cv. + */ + +type *type_setcv(type **pt,tym_t cv) +{ unsigned long ty; + + type_debug(*pt); + ty = (*pt)->Tty & ~(mTYconst | mTYvolatile | mTYimmutable | mTYshared); + return type_setty(pt,ty | (cv & (mTYconst | mTYvolatile | mTYimmutable | mTYshared))); +} + +/***************************** + * Set dimension of array. + */ + +type *type_setdim(type **pt,targ_size_t dim) +{ type *t = *pt; + + type_debug(t); + if (t->Tcount > 1) /* if other people pointing at t */ + { type *tn; + + tn = type_copy(t); + tn->Tcount++; + type_free(t); + t = tn; + } + t->Tflags &= ~TFsizeunknown; /* we have determined its size */ + t->Tdim = dim; /* index of array */ + return *pt = t; +} + + +/***************************** + * Create a 'dependent' version of type t. + */ + +type *type_setdependent(type *t) +{ + type_debug(t); + if (t->Tcount > 0 && /* if other people pointing at t */ + !(t->Tflags & TFdependent)) + { + t = type_copy(t); + } + t->Tflags |= TFdependent; + return t; +} + +/************************************ + * Determine if type t is a dependent type. + */ + +int type_isdependent(type *t) +{ + Symbol *stempl; + type *tstart; + + //printf("type_isdependent(%p)\n", t); + //type_print(t); + for (tstart = t; t; t = t->Tnext) + { + type_debug(t); + if (t->Tflags & TFdependent) + goto Lisdependent; + if (tyfunc(t->Tty) +#if TARGET_SEGMENTED + || tybasic(t->Tty) == TYtemplate +#endif + ) + { + for (param_t *p = t->Tparamtypes; p; p = p->Pnext) + { + if (p->Ptype && type_isdependent(p->Ptype)) + goto Lisdependent; + if (p->Pelem && el_isdependent(p->Pelem)) + goto Lisdependent; + } + } + else if (type_struct(t) && + (stempl = t->Ttag->Sstruct->Stempsym) != NULL) + { + for (param_t *p = t->Ttag->Sstruct->Sarglist; p; p = p->Pnext) + { + if (p->Ptype && type_isdependent(p->Ptype)) + goto Lisdependent; + if (p->Pelem && el_isdependent(p->Pelem)) + goto Lisdependent; + } + } + } + //printf("\tis not dependent\n"); + return 0; + +Lisdependent: + //printf("\tis dependent\n"); + // Dependence on a dependent type makes this type dependent as well + tstart->Tflags |= TFdependent; + return 1; +} + + +/******************************* + * Recursively check if type u is embedded in type t. + * Returns: + * != 0 if embedded + */ + +int type_embed(type *t,type *u) +{ param_t *p; + + for (; t; t = t->Tnext) + { + type_debug(t); + if (t == u) + return 1; + if (tyfunc(t->Tty)) + { + for (p = t->Tparamtypes; p; p = p->Pnext) + if (type_embed(p->Ptype,u)) + return 1; + } + } + return 0; +} + + +/*********************************** + * Determine if type is a VLA. + */ + +int type_isvla(type *t) +{ + while (t) + { + if (tybasic(t->Tty) != TYarray) + break; + if (t->Tflags & TFvla) + return 1; + t = t->Tnext; + } + return 0; +} + +/************************************* + * Determine if type can be passed in a register. + */ + +int type_jparam(type *t) +{ + targ_size_t sz; + type_debug(t); + return tyjparam(t->Tty) || + + ((tybasic(t->Tty) == TYstruct || tybasic(t->Tty) == TYarray) && + (sz = type_size(t)) <= NPTRSIZE && + (sz == 1 || sz == 2 || sz == 4 || sz == 8)) || + + tybasic(t->Tty) == TYfloat4; +} + + +/********************************** + * Pretty-print a type. + */ + +#ifdef DEBUG + +void type_print(type *t) +{ + type_debug(t); + dbg_printf("Tty="); WRTYxx(t->Tty); + dbg_printf(" Tmangle=%d",t->Tmangle); + dbg_printf(" Tflags=x%x",t->Tflags); + dbg_printf(" Tcount=%d",t->Tcount); + if (!(t->Tflags & TFsizeunknown) && + tybasic(t->Tty) != TYvoid && +#if !MARS + tybasic(t->Tty) != TYident && + tybasic(t->Tty) != TYtemplate && +#endif + tybasic(t->Tty) != TYmfunc && + tybasic(t->Tty) != TYarray) + dbg_printf(" Tsize=%lld",(long long)type_size(t)); + dbg_printf(" Tnext=%p",t->Tnext); + switch (tybasic(t->Tty)) + { case TYstruct: +#if !MARS + case TYmemptr: +#endif + dbg_printf(" Ttag=%p,'%s'",t->Ttag,t->Ttag->Sident); + //dbg_printf(" Sfldlst=%p",t->Ttag->Sstruct->Sfldlst); + break; + case TYarray: + dbg_printf(" Tdim=%ld",(long)t->Tdim); + break; +#if !MARS + case TYident: + dbg_printf(" Tident='%s'",t->Tident); + break; + case TYtemplate: + dbg_printf(" Tsym='%s'",((typetemp_t *)t)->Tsym->Sident); + { param_t *p; + int i; + + i = 1; + for (p = t->Tparamtypes; p; p = p->Pnext) + { dbg_printf("\nTP%d (%p): ",i++,p); + fflush(stdout); + +dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Pnext=%p ",p->Pident,p->Ptype,p->Pelem,p->Pnext); + param_debug(p); + if (p->Pident) + printf("'%s' ", p->Pident); + if (p->Ptype) + type_print(p->Ptype); + if (p->Pelem) + elem_print(p->Pelem); + } + } + break; +#endif + default: + if (tyfunc(t->Tty)) + { param_t *p; + int i; + + i = 1; + for (p = t->Tparamtypes; p; p = p->Pnext) + { dbg_printf("\nP%d (%p): ",i++,p); + fflush(stdout); + +dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Pnext=%p ",p->Pident,p->Ptype,p->Pelem,p->Pnext); + param_debug(p); + if (p->Pident) + printf("'%s' ", p->Pident); + type_print(p->Ptype); + } + } + break; + } + dbg_printf("\n"); + if (t->Tnext) type_print(t->Tnext); +} + +/******************************* + * Pretty-print a param_t + */ + +void param_t::print() +{ + dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Psym=%p,Pnext=%p\n",Pident,Ptype,Pelem,Psym,Pnext); + if (Pident) + dbg_printf("\tPident = '%s'\n", Pident); + if (Ptype) + { dbg_printf("\tPtype =\n"); + type_print(Ptype); + } + if (Pelem) + { dbg_printf("\tPelem =\n"); + elem_print(Pelem); + } + if (Pdeftype) + { dbg_printf("\tPdeftype =\n"); + type_print(Pdeftype); + } + if (Psym) + { dbg_printf("\tPsym = '%s'\n", Psym->Sident); + } + if (Pptpl) + { dbg_printf("\tPptpl = %p\n", Pptpl); + } +} + +void param_t::print_list() +{ + for (param_t *p = this; p; p = p->Pnext) + p->print(); +} + +#endif /* DEBUG */ + +/********************************** + * Hydrate a type. + */ + +#if HYDRATE +void type_hydrate(type **pt) +{ + type *t; + + assert(pt); + while (isdehydrated(*pt)) + { + t = (type *) ph_hydrate(pt); + type_debug(t); + switch (tybasic(t->Tty)) + { + case TYstruct: + case TYenum: + case TYmemptr: + case TYvtshape: + // Cannot assume symbol is hydrated, because entire HX file + // may not have been hydrated. + Classsym_hydrate(&t->Ttag); + symbol_debug(t->Ttag); + break; + case TYident: + ph_hydrate(&t->Tident); + break; + case TYtemplate: + symbol_hydrate(&((typetemp_t *)t)->Tsym); + param_hydrate(&t->Tparamtypes); + break; + case TYarray: + if (t->Tflags & TFvla) + el_hydrate(&t->Tel); + break; + default: + if (tyfunc(t->Tty)) + { param_hydrate(&t->Tparamtypes); + list_hydrate(&t->Texcspec, (list_free_fp)type_hydrate); + } +#if SCPP + else if (t->Talternate && typtr(t->Tty)) + type_hydrate(&t->Talternate); +#endif +#if MARS + else if (t->Tkey && typtr(t->Tty)) + type_hydrate(&t->Tkey); +#endif + break; + } + pt = &t->Tnext; + } +} +#endif + +/********************************** + * Dehydrate a type. + */ + +#if DEHYDRATE +void type_dehydrate(type **pt) +{ + type *t; + + while ((t = *pt) != NULL && !isdehydrated(t)) + { + ph_dehydrate(pt); +#if DEBUG_XSYMGEN + /* don't dehydrate types in HEAD when creating XSYM */ + if (xsym_gen && (t->Tflags & TFhydrated)) + return; +#endif + type_debug(t); + switch (tybasic(t->Tty)) + { + case TYstruct: + case TYenum: + case TYmemptr: + case TYvtshape: + Classsym_dehydrate(&t->Ttag); + break; + case TYident: + ph_dehydrate(&t->Tident); + break; + case TYtemplate: + symbol_dehydrate(&((typetemp_t *)t)->Tsym); + param_dehydrate(&t->Tparamtypes); + break; + case TYarray: + if (t->Tflags & TFvla) + el_dehydrate(&t->Tel); + break; + default: + if (tyfunc(t->Tty)) + { param_dehydrate(&t->Tparamtypes); + list_dehydrate(&t->Texcspec, (list_free_fp)type_dehydrate); + } +#if SCPP + else if (t->Talternate && typtr(t->Tty)) + type_dehydrate(&t->Talternate); +#endif +#if MARS + else if (t->Tkey && typtr(t->Tty)) + type_dehydrate(&t->Tkey); +#endif + break; + } + pt = &t->Tnext; + } +} +#endif + +/**************************** + * Allocate a param_t. + */ + +param_t *param_calloc() +{ + static param_t pzero; + param_t *p; + +#if !TX86 + debug_assert(PARSER); +#endif + if (param_list) + { + p = param_list; + param_list = p->Pnext; + } + else + { + p = (param_t *) mem_fmalloc(sizeof(param_t)); + } + *p = pzero; +#ifdef DEBUG + p->id = IDparam; +#endif + return p; +} + +/*************************** + * Allocate a param_t of type t, and append it to parameter list. + */ + +param_t *param_append_type(param_t **pp,type *t) +{ param_t *p; + + p = param_calloc(); + while (*pp) + { param_debug(*pp); + pp = &((*pp)->Pnext); /* find end of list */ + } + *pp = p; /* append p to list */ + type_debug(t); + p->Ptype = t; + t->Tcount++; + return p; +} + +/************************ + * Version of param_free() suitable for list_free(). + */ + +void param_free_l(param_t *p) +{ + param_free(&p); +} + +/*********************** + * Free parameter list. + * Output: + * paramlst = NULL + */ + +void param_free(param_t **pparamlst) +{ param_t *p,*pn; + +#if !TX86 + debug_assert(PARSER); +#endif + for (p = *pparamlst; p; p = pn) + { param_debug(p); + pn = p->Pnext; + type_free(p->Ptype); + mem_free(p->Pident); + el_free(p->Pelem); + type_free(p->Pdeftype); + if (p->Pptpl) + param_free(&p->Pptpl); +#ifdef DEBUG + p->id = 0; +#endif + p->Pnext = param_list; + param_list = p; + } + *pparamlst = NULL; +} + +/*********************************** + * Compute number of parameters + */ + +unsigned param_t::length() +{ + unsigned nparams = 0; + param_t *p; + + for (p = this; p; p = p->Pnext) + nparams++; + return nparams; +} + +/************************************* + * Create template-argument-list blank from + * template-parameter-list + * Input: + * ptali initial template-argument-list + */ + +param_t *param_t::createTal(param_t *ptali) +{ +#if SCPP + param_t *ptalistart = ptali; +#endif + param_t *ptal = NULL; + param_t **pp = &ptal; + param_t *p; + + for (p = this; p; p = p->Pnext) + { + *pp = param_calloc(); + if (p->Pident) + { + // Should find a way to just point rather than dup + (*pp)->Pident = (char *)MEM_PH_STRDUP(p->Pident); + } + if (ptali) + { + if (ptali->Ptype) + { (*pp)->Ptype = ptali->Ptype; + (*pp)->Ptype->Tcount++; + } + if (ptali->Pelem) + { + elem *e = el_copytree(ptali->Pelem); +#if SCPP + if (p->Ptype) + { type *t = p->Ptype; + t = template_tyident(t, ptalistart, this, 1); + e = poptelem3(typechk(e, t)); + type_free(t); + } +#endif + (*pp)->Pelem = e; + } + (*pp)->Psym = ptali->Psym; + (*pp)->Pflags = ptali->Pflags; + assert(!ptali->Pptpl); + ptali = ptali->Pnext; + } + pp = &(*pp)->Pnext; + } + return ptal; +} + +/********************************** + * Look for Pident matching id + */ + +param_t *param_t::search(char *id) +{ param_t *p; + + for (p = this; p; p = p->Pnext) + { + if (p->Pident && strcmp(p->Pident, id) == 0) + break; + } + return p; +} + +/********************************** + * Look for Pident matching id + */ + +int param_t::searchn(char *id) +{ param_t *p; + int n = 0; + + for (p = this; p; p = p->Pnext) + { + if (p->Pident && strcmp(p->Pident, id) == 0) + return n; + n++; + } + return -1; +} + +/************************************* + * Search for member, create symbol as needed. + * Used for symbol tables for VLA's such as: + * void func(int n, int a[n]); + */ + +symbol *param_search(const char *name, param_t **pp) +{ symbol *s = NULL; + param_t *p; + + p = (*pp)->search((char *)name); + if (p) + { + s = p->Psym; + if (!s) + { + s = symbol_calloc(p->Pident); + s->Sclass = SCparameter; + s->Stype = p->Ptype; + s->Stype->Tcount++; +#if SOURCE_4PARAMS + s->Ssrcpos = p->Psrcpos; +#endif + p->Psym = s; + } + } + return s; +} + +/********************************** + * Hydrate/dehydrate a type. + */ + +#if HYDRATE +void param_hydrate(param_t **pp) +{ + param_t *p; + + assert(pp); + if (isdehydrated(*pp)) + { while (*pp) + { assert(isdehydrated(*pp)); + p = (param_t *) ph_hydrate(pp); +#if SOURCE_4PARAMS + p->Psrcpos.Sfilnum += File_Hydrate_Num; /* file number relative header build */ +#endif + param_debug(p); + + type_hydrate(&p->Ptype); + if (p->Ptype) + type_debug(p->Ptype); + ph_hydrate(&p->Pident); + if (CPP) + { + el_hydrate(&p->Pelem); + if (p->Pelem) + elem_debug(p->Pelem); + type_hydrate(&p->Pdeftype); + if (p->Pptpl) + param_hydrate(&p->Pptpl); + if (p->Psym) + symbol_hydrate(&p->Psym); + if (p->PelemToken) + token_hydrate(&p->PelemToken); + } + + pp = &p->Pnext; + } + } +} +#endif + +#if DEHYDRATE +void param_dehydrate(param_t **pp) +{ + param_t *p; + + assert(pp); + while ((p = *pp) != NULL && !isdehydrated(p)) + { param_debug(p); + + ph_dehydrate(pp); + if (p->Ptype && !isdehydrated(p->Ptype)) + type_debug(p->Ptype); + type_dehydrate(&p->Ptype); + ph_dehydrate(&p->Pident); + if (CPP) + { + el_dehydrate(&p->Pelem); + type_dehydrate(&p->Pdeftype); + if (p->Pptpl) + param_dehydrate(&p->Pptpl); + if (p->Psym) + symbol_dehydrate(&p->Psym); + if (p->PelemToken) + token_dehydrate(&p->PelemToken); + } + pp = &p->Pnext; + } +} +#endif + +#if MARS + +int typematch(type *t1, type *t2, int relax); + +// Return TRUE if type lists match. +static int paramlstmatch(param_t *p1,param_t *p2) +{ + return p1 == p2 || + p1 && p2 && typematch(p1->Ptype,p2->Ptype,0) && + paramlstmatch(p1->Pnext,p2->Pnext) + ; +} + +/************************************************* + * A cheap version of exp2.typematch() and exp2.paramlstmatch(), + * so that we can get cpp_mangle() to work for MARS. + * It's less complex because it doesn't do templates and + * can rely on strict typechecking. + * Returns: + * !=0 if types match. + */ + +int typematch(type *t1,type *t2,int relax) +{ tym_t t1ty, t2ty; + tym_t tym; + + tym = ~(mTYimport | mTYnaked); + + return t1 == t2 || + t1 && t2 && + + ( + /* ignore name mangling */ + (t1ty = (t1->Tty & tym)) == (t2ty = (t2->Tty & tym)) + ) + && + + (tybasic(t1ty) != TYarray || t1->Tdim == t2->Tdim || + t1->Tflags & TFsizeunknown || t2->Tflags & TFsizeunknown) + && + + (tybasic(t1ty) != TYstruct + && tybasic(t1ty) != TYenum +#if !MARS + && tybasic(t1ty) != TYmemptr +#endif + || t1->Ttag == t2->Ttag) + && + + typematch(t1->Tnext,t2->Tnext, 0) + && + + (!tyfunc(t1ty) || + ((t1->Tflags & TFfixed) == (t2->Tflags & TFfixed) && + paramlstmatch(t1->Tparamtypes,t2->Tparamtypes) )) + ; +} + +#endif + +#endif /* !SPP */ diff --git a/backend/type.h b/backend/type.h new file mode 100644 index 00000000..8f92566d --- /dev/null +++ b/backend/type.h @@ -0,0 +1,209 @@ +// Copyright (C) 1985-1994 by Symantec +// Copyright (C) 2000-2009 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#if __SC__ +#pragma once +#endif + +#ifndef __TYPE_H +#define __TYPE_H + +#include + +typedef unsigned char mangle_t; + +#define mTYman_c 1 // C mangling +#define mTYman_cpp 2 // C++ mangling +#define mTYman_pas 3 // Pascal mangling +#define mTYman_for 4 // FORTRAN mangling +#define mTYman_sys 5 // _syscall mangling +#define mTYman_std 6 // _stdcall mangling +#define mTYman_d 7 // D mangling + +/********************************* + * Data type. + */ + +#define list_type(tl) ((struct TYPE *) list_ptr(tl)) + +struct TYPE +{ +#ifdef DEBUG + unsigned short id; +#define IDtype 0x1234 +#define type_debug(t) assert((t)->id == IDtype) +#else +#define type_debug(t) +#endif + + tym_t Tty; /* mask (TYxxx) */ + unsigned short Tflags; // TFxxxxx + + mangle_t Tmangle; // name mangling +// Return name mangling of type +#define type_mangle(t) ((t)->Tmangle) + + unsigned Tcount; // # pointing to this type + struct TYPE *Tnext; // next in list + // TYenum: gives base type + union + { + targ_size_t Tdim; // TYarray: # of elements in array + struct elem *Tel; // TFvla: gives dimension (NULL if '*') + struct PARAM *Tparamtypes; // TYfunc, TYtemplate: types of function parameters + struct Classsym *Ttag; // TYstruct,TYmemptr: tag symbol + // TYenum,TYvtshape: tag symbol + char *Tident; // TYident: identifier +#if SCPP + struct TYPE *Talternate; // typtr: type of parameter before converting +#endif +#if MARS + struct TYPE *Tkey; // typtr: key type for associative arrays +#endif + }; + list_t Texcspec; // tyfunc(): list of types of exception specification +#if 0 + unsigned short Tstabidx; // Index into stab types +#endif +#if SOURCE_4TYPES + Srcpos Tsrcpos; /* position of type definition */ +#endif +#if HTOD + Symbol *Ttypedef; // if this type came from a typedef, this is + // the typedef symbol +#endif +}; + +typedef struct TYPETEMP +{ struct TYPE Ttype; + + /* Tsym should really be part of a derived class, as we only + allocate room for it if TYtemplate + */ + Symbol *Tsym; // primary class template symbol +} typetemp_t; + +/* Values for Tflags: */ +#define TFprototype 1 /* if this function is prototyped */ +#define TFfixed 2 /* if prototype has a fixed # of parameters */ +#define TFforward 8 // TYstruct: if forward reference of tag name +#define TFsizeunknown 0x10 // TYstruct,TYarray: if size of type is unknown + // TYmptr: the Stag is TYident type +#define TFfuncret 0x20 // C++,tyfunc(): overload based on function return value +#define TFfuncparam 0x20 // TYarray: top level function parameter +#define TFstatic 0x40 // TYarray: static dimension +#define TFvla 0x80 // TYarray: variable length array +#define TFemptyexc 0x100 // tyfunc(): empty exception specification + +// C +#define TFgenerated 4 // if we generated the prototype ourselves + +// CPP +#define TFdependent 4 // template dependent type + +#if DEHYDRATE +#define TFhydrated 0x20 // type data already hydrated +#endif + +/* Return !=0 if function type has a variable number of arguments */ +#define variadic(t) (((t)->Tflags & (TFprototype | TFfixed)) == TFprototype) + +/* Data */ + +typedef type *typep_t; + +extern typep_t tstypes[TYMAX]; +extern typep_t tsptr2types[TYMAX]; + +#define tsbool tstypes[TYbool] +#define tschar tstypes[TYchar] +#define tsschar tstypes[TYschar] +#define tsuchar tstypes[TYuchar] +#define tschar16 tstypes[TYchar16] +#define tsshort tstypes[TYshort] +#define tsushort tstypes[TYushort] +#define tswchar_t tstypes[TYwchar_t] +#define tsint tstypes[TYint] +#define tsuns tstypes[TYuint] +#define tslong tstypes[TYlong] +#define tsulong tstypes[TYulong] +#define tsdchar tstypes[TYdchar] +#define tsllong tstypes[TYllong] +#define tsullong tstypes[TYullong] +#define tsfloat tstypes[TYfloat] +#define tsdouble tstypes[TYdouble] +#define tsreal64 tstypes[TYdouble_alias] +#define tsldouble tstypes[TYldouble] +#define tsvoid tstypes[TYvoid] + +#define tsifloat tstypes[TYifloat] +#define tsidouble tstypes[TYidouble] +#define tsildouble tstypes[TYildouble] +#define tscfloat tstypes[TYcfloat] +#define tscdouble tstypes[TYcdouble] +#define tscldouble tstypes[TYcldouble] + +#define tsnullptr tstypes[TYnullptr] + +extern typep_t tslogical; +extern typep_t chartype; +extern typep_t tsclib; +extern typep_t tsdlib; +extern typep_t tspvoid,tspcvoid; +extern typep_t tsptrdiff, tssize; +extern typep_t tstrace; + +#define tserr tsint /* error type */ + +// Return !=0 if type is a struct, class or union +#define type_struct(t) (tybasic((t)->Tty) == TYstruct) + +/* Functions */ +void type_print(type *t); +void type_free(type *); +void type_init(void); +void type_term(void); +type *type_copy(type *); +elem *type_vla_fix(type **pt); +type *type_setdim(type **,targ_size_t); +type *type_setdependent(type *t); +int type_isdependent(type *t); +type *type_copy(type *); +void type_hydrate(type **); +void type_dehydrate(type **); + +targ_size_t type_size(type *); +unsigned type_alignsize(type *); +targ_size_t type_paramsize(type *t); +type *type_alloc(tym_t); +type *type_alloc_template(symbol *s); +type *type_allocn(tym_t,type *tn); +type *type_allocmemptr(Classsym *stag,type *tn); +type *type_fake(tym_t); +type *type_setty(type **,long); +type *type_settype(type **pt, type *t); +type *type_setmangle(type **pt,mangle_t mangle); +type *type_setcv(type **pt,tym_t cv); +int type_embed(type *t,type *u); +int type_isvla(type *t); +int type_jparam(type *t); + +param_t *param_calloc(void); +param_t *param_append_type(param_t **,type *); +void param_free_l(param_t *); +void param_free(param_t **); +symbol *param_search(const char *name, param_t **pp); +void param_hydrate(param_t **); +void param_dehydrate(param_t **); +int typematch(type *t1, type *t2, int relax); + +#endif diff --git a/backend/var.c b/backend/var.c new file mode 100644 index 00000000..b4f81f99 --- /dev/null +++ b/backend/var.c @@ -0,0 +1,235 @@ +// Copyright (C) 1985-1998 by Symantec +// Copyright (C) 2000-2010 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * or /dm/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +/* Global variables for PARSER */ + +#include +#include + +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "type.h" +#include "go.h" +#include "ty.h" + +#include "optab.c" +#include "tytab.c" + +#if __SC__ && _MSDOS +#if __INTSIZE == 4 +unsigned __cdecl _stack = 100000; // set default stack size +#else +unsigned __cdecl _stack = 60000; // set default stack size +#endif +#endif + +/* Global flags: + */ + +char PARSER; // indicate we're in the parser +char OPTIMIZER; // indicate we're in the optimizer +int structalign; /* alignment for members of structures */ +char dbcs; // current double byte character set + +int TYptrdiff = TYint; +int TYsize = TYuint; +int TYsize_t = TYuint; + +#ifdef DEBUG +char debuga,debugb,debugc,debugd,debuge,debugf,debugr,debugs,debugt,debugu,debugw,debugx,debugy; +#endif + +#if !MARS +linkage_t linkage; +int linkage_spec = 0; /* using the default */ + +/* Function types */ +/* LINK_MAXDIM = C,C++,Pascal,FORTRAN,syscall,stdcall,Jupiter */ +#if MEMMODELS == 1 +tym_t functypetab[LINK_MAXDIM] = +{ +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + TYnfunc, + TYnpfunc, + TYnpfunc, + TYnfunc, +#endif +}; +#else +tym_t functypetab[LINK_MAXDIM][MEMMODELS] = +{ + TYnfunc, TYffunc, TYnfunc, TYffunc, TYffunc, +#if VBTABLES + TYnfunc, TYffunc, TYnfunc, TYffunc, TYffunc, +#else + TYnpfunc, TYfpfunc, TYnpfunc, TYfpfunc, TYfpfunc, +#endif + TYnpfunc, TYfpfunc, TYnpfunc, TYfpfunc, TYfpfunc, + TYnpfunc, TYfpfunc, TYnpfunc, TYfpfunc, TYfpfunc, + TYnfunc, TYffunc, TYnfunc, TYffunc, TYffunc, + TYnsfunc, TYfsfunc, TYnsfunc, TYfsfunc, TYfsfunc, + TYjfunc, TYfpfunc, TYnpfunc, TYfpfunc, TYfpfunc, +}; +#endif + +/* Function mangling */ +/* LINK_MAXDIM = C,C++,Pascal,FORTRAN,syscall,stdcall */ +mangle_t funcmangletab[LINK_MAXDIM] = +{ + mTYman_c, + mTYman_cpp, + mTYman_pas, + mTYman_for, + mTYman_sys, + mTYman_std, + mTYman_d, +}; + +/* Name mangling for global variables */ +mangle_t varmangletab[LINK_MAXDIM] = +{ + mTYman_c, +#if NEWMANGLE + mTYman_cpp, +#else + mTYman_c, +#endif + mTYman_pas,mTYman_for,mTYman_sys,mTYman_std,mTYman_d +}; +#endif + +targ_size_t dsout = 0; /* # of bytes actually output to data */ + /* segment, used to pad for alignment */ + +/* File variables: */ + +char *argv0; // argv[0] (program name) +FILE *fdep = NULL; // dependency file stream pointer +FILE *flst = NULL; // list file stream pointer +FILE *fin = NULL; // input file +#if SPP +FILE *fout; +#endif +#if HTOD +char *fdmodulename = NULL; +FILE *fdmodule = NULL; +#endif +char *foutdir = NULL, // directory to place output files in + *finname = NULL, + *foutname = NULL, + *fsymname = NULL, + *fphreadname = NULL, + *ftdbname = NULL, + *fdepname = NULL, + *flstname = NULL; /* the filename strings */ + +list_t pathlist; /* include paths */ +list_t headers; /* pre-include files */ + +/* Data from lexical analyzer: */ + +unsigned idhash = 0; // hash value of identifier +int xc = ' '; // character last read + +/* Data for pragma processor: + */ + +int colnumber = 0; /* current column number */ + +/* Other variables: */ + +int level = 0; /* declaration level */ + /* 0: top level */ + /* 1: function parameter declarations */ + /* 2: function local declarations */ + /* 3+: compound statement decls */ + +param_t *paramlst = NULL; /* function parameter list */ +tym_t pointertype = TYnptr; /* default data pointer type */ + +/************************ + * Bit masks + */ + +const unsigned mask[32] = + {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,0x8000, + 0x10000,0x20000,0x40000,0x80000,0x100000,0x200000,0x400000,0x800000, + 0x1000000,0x2000000,0x4000000,0x8000000, + 0x10000000,0x20000000,0x40000000,0x80000000}; + +#if 0 +const unsigned long maskl[32] = + {1,2,4,8,0x10,0x20,0x40,0x80, + 0x100,0x200,0x400,0x800,0x1000,0x2000,0x4000,0x8000, + 0x10000,0x20000,0x40000,0x80000,0x100000,0x200000,0x400000,0x800000, + 0x1000000,0x2000000,0x4000000,0x8000000, + 0x10000000,0x20000000,0x40000000,0x80000000}; +#endif + +/* From util.c */ + +/***************************** + * SCxxxx types. + */ + +#if !SPP + +char sytab[SCMAX] = +{ + #define X(a,b) b, + ENUMSCMAC + #undef X +}; + +#endif /* !SPP */ +volatile int controlc_saw; /* a control C was seen */ +symtab_t globsym; /* global symbol table */ +Pstate pstate; // parser state +Cstate cstate; // compiler state + +/* From go.c */ +mftype mfoptim = 0; // mask of optimizations to perform + +unsigned changes; // # of optimizations performed +struct DN *defnod = NULL; // array of definition elems + +elem **expnod = NULL; /* array of expression elems */ +block **expblk = NULL; /* parallel array of block pointers */ + +unsigned + maxblks = 0, /* array max for all block stuff */ + /* dfoblks <= numblks <= maxblks */ + numcse, /* number of common subexpressions */ + deftop = 0, /* # of entries in defnod[] */ + exptop = 0; /* top of expnod[] */ + +vec_t defkill = NULL, /* vector of AEs killed by an ambiguous */ + /* definition */ + starkill = NULL, /* vector of AEs killed by a definition */ + /* of something that somebody could be */ + /* pointing to */ + vptrkill = NULL; /* vector of AEs killed by an access */ + /* to a vptr */ + +/* From debug.c */ +#if DEBUG +const char *regstring[32] = {"AX","CX","DX","BX","SP","BP","SI","DI", + "R8","R9","R10","R11","R12","R13","R14","R15", + "XMM0","XMM1","XMM2","XMM3","XMM4","XMM5","XMM6","XMM7", + "ES","PSW","STACK","ST0","ST01","NOREG","RMload","RMstore"}; +#endif + +/* From nwc.c */ + +type *chartype; /* default 'char' type */ + diff --git a/backend/xmm.h b/backend/xmm.h new file mode 100644 index 00000000..5dcd10c1 --- /dev/null +++ b/backend/xmm.h @@ -0,0 +1,314 @@ +// XMM opcodes + +enum +{ + ADDSS = 0xF30F58, + ADDSD = 0xF20F58, + ADDPS = 0x000F58, + ADDPD = 0x660F58, + PADDB = 0x660FFC, + PADDW = 0x660FFD, + PADDD = 0x660FFE, + PADDQ = 0x660FD4, + + SUBSS = 0xF30F5C, + SUBSD = 0xF20F5C, + SUBPS = 0x000F5C, + SUBPD = 0x660F5C, + PSUBB = 0x660FF8, + PSUBW = 0x660FF9, + PSUBD = 0x660FFA, + PSUBQ = 0x660FFB, + + MULSS = 0xF30F59, + MULSD = 0xF20F59, + MULPS = 0x000F59, + MULPD = 0x660F59, + PMULLW = 0x660FD5, + + DIVSS = 0xF30F5E, + DIVSD = 0xF20F5E, + DIVPS = 0x000F5E, + DIVPD = 0x660F5E, + + PAND = 0x660FDB, + POR = 0x660FEB, + + UCOMISS = 0x000F2E, + UCOMISD = 0x660F2E, + + XORPS = 0x000F57, + XORPD = 0x660F57, + + // Use STO and LOD instead of MOV to distinguish the direction + STOSS = 0xF30F11, // MOVSS + STOSD = 0xF20F11, + STOAPS = 0x000F29, + STOAPD = 0x660F29, + STODQA = 0x660F7F, + STOD = 0x660F7E, + STOQ = 0x660FD6, + + LODSS = 0xF30F10, // MOVSS + LODSD = 0xF20F10, + LODAPS = 0x000F28, + LODAPD = 0x660F28, + LODDQA = 0x660F6F, + LODD = 0x660F6E, + LODQ = 0xF30F7E, + + LODDQU = 0xF30F6F, + STODQU = 0xF30F7F, + MOVDQ2Q = 0xF20FD6, + MOVHLPS = 0x0F12, + LODHPD = 0x660F16, + STOHPD = 0x660F17, + LODHPS = 0x0F16, + STOHPS = 0x0F17, + MOVLHPS = 0x0F16, + LODLPD = 0x660F12, + STOLPD = 0x660F13, + LODLPS = 0x0F12, + STOLPS = 0x0F13, + MOVMSKPD = 0x660F50, + MOVMSKPS = 0x0F50, + MOVNTDQ = 0x660FE7, + MOVNTI = 0x0FC3, + MOVNTPD = 0x660F2B, + MOVNTPS = 0x0F2B, + MOVNTQ = 0x0FE7, + MOVQ2DQ = 0xF30FD6, + LODUPD = 0x660F10, + STOUPD = 0x660F11, + LODUPS = 0x0F10, + STOUPS = 0x0F11, + + PACKSSDW = 0x660F6B, + PACKSSWB = 0x660F63, + PACKUSWB = 0x660F67, + PADDSB = 0x660FEC, + PADDSW = 0x660FED, + PADDUSB = 0x660FDC, + PADDUSW = 0x660FDD, + PANDN = 0x660FDF, + PCMPEQB = 0x660F74, + PCMPEQD = 0x660F76, + PCMPEQW = 0x660F75, + PCMPGTB = 0x660F64, + PCMPGTD = 0x660F66, + PCMPGTW = 0x660F65, + PMADDWD = 0x660FF5, + PSLLW = 0x660FF1, + PSLLD = 0x660FF2, + PSLLQ = 0x660FF3, + PSRAW = 0x660FE1, + PSRAD = 0x660FE2, + PSRLW = 0x660FD1, + PSRLD = 0x660FD2, + PSRLQ = 0x660FD3, + PSUBSB = 0x660FE8, + PSUBSW = 0x660FE9, + PSUBUSB = 0x660FD8, + PSUBUSW = 0x660FD9, + PUNPCKHBW = 0x660F68, + PUNPCKHDQ = 0x660F6A, + PUNPCKHWD = 0x660F69, + PUNPCKLBW = 0x660F60, + PUNPCKLDQ = 0x660F62, + PUNPCKLWD = 0x660F61, + PXOR = 0x660FEF, + ANDPD = 0x660F54, + ANDPS = 0x0F54, + ANDNPD = 0x660F55, + ANDNPS = 0x0F55, + CMPPS = 0x0FC2, + CMPPD = 0x660FC2, + CMPSD = 0xF20FC2, + CMPSS = 0xF30FC2, + COMISD = 0x660F2F, + COMISS = 0x0F2F, + CVTDQ2PD = 0xF30FE6, + CVTDQ2PS = 0x0F5B, + CVTPD2DQ = 0xF20FE6, + CVTPD2PI = 0x660F2D, + CVTPD2PS = 0x660F5A, + CVTPI2PD = 0x660F2A, + CVTPI2PS = 0x0F2A, + CVTPS2DQ = 0x660F5B, + CVTPS2PD = 0x0F5A, + CVTPS2PI = 0x0F2D, + CVTSD2SI = 0xF20F2D, + CVTSD2SS = 0xF20F5A, + CVTSI2SD = 0xF20F2A, + CVTSI2SS = 0xF30F2A, + CVTSS2SD = 0xF30F5A, + CVTSS2SI = 0xF30F2D, + CVTTPD2PI = 0x660F2C, + CVTTPD2DQ = 0x660FE6, + CVTTPS2DQ = 0xF30F5B, + CVTTPS2PI = 0x0F2C, + CVTTSD2SI = 0xF20F2C, + CVTTSS2SI = 0xF30F2C, + MASKMOVDQU = 0x660FF7, + MASKMOVQ = 0x0FF7, + MAXPD = 0x660F5F, + MAXPS = 0x0F5F, + MAXSD = 0xF20F5F, + MAXSS = 0xF30F5F, + MINPD = 0x660F5D, + MINPS = 0x0F5D, + MINSD = 0xF20F5D, + MINSS = 0xF30F5D, + ORPD = 0x660F56, + ORPS = 0x0F56, + PAVGB = 0x660FE0, + PAVGW = 0x660FE3, + PMAXSW = 0x660FEE, + PINSRW = 0x660FC4, + PMAXUB = 0x660FDE, + PMINSW = 0x660FEA, + PMINUB = 0x660FDA, + PMOVMSKB = 0x660FD7, + PMULHUW = 0x660FE4, + PMULHW = 0x660FE5, + PMULUDQ = 0x660FF4, + PSADBW = 0x660FF6, + PUNPCKHQDQ = 0x660F6D, + PUNPCKLQDQ = 0x660F6C, + RCPPS = 0x0F53, + RCPSS = 0xF30F53, + RSQRTPS = 0x0F52, + RSQRTSS = 0xF30F52, + SQRTPD = 0x660F51, + SHUFPD = 0x660FC6, + SHUFPS = 0x0FC6, + SQRTPS = 0x0F51, + SQRTSD = 0xF20F51, + SQRTSS = 0xF30F51, + UNPCKHPD = 0x660F15, + UNPCKHPS = 0x0F15, + UNPCKLPD = 0x660F14, + UNPCKLPS = 0x0F14, + + PSHUFD = 0x660F70, + PSHUFHW = 0xF30F70, + PSHUFLW = 0xF20F70, + PSHUFW = 0x0F70, + PSLLDQ = 0x660F73, + PSRLDQ = 0x660F73, + + PREFETCH = 0x0F18, + +// SSE3 Pentium 4 (Prescott) + + ADDSUBPD = 0x660FD0, + ADDSUBPS = 0xF20FD0, + HADDPD = 0x660F7C, + HADDPS = 0xF20F7C, + HSUBPD = 0x660F7D, + HSUBPS = 0xF20F7D, + MOVDDUP = 0xF20F12, + MOVSHDUP = 0xF30F16, + MOVSLDUP = 0xF30F12, + LDDQU = 0xF20FF0, + MONITOR = 0x0F01C8, + MWAIT = 0x0F01C9, + +// SSSE3 + PALIGNR = 0x660F3A0F, + PHADDD = 0x660F3802, + PHADDW = 0x660F3801, + PHADDSW = 0x660F3803, + PABSB = 0x660F381C, + PABSD = 0x660F381E, + PABSW = 0x660F381D, + PSIGNB = 0x660F3808, + PSIGND = 0x660F380A, + PSIGNW = 0x660F3809, + PSHUFB = 0x660F3800, + PMADDUBSW = 0x660F3804, + PMULHRSW = 0x660F380B, + PHSUBD = 0x660F3806, + PHSUBW = 0x660F3805, + PHSUBSW = 0x660F3807, + +// SSE4.1 + + BLENDPD = 0x660F3A0D, + BLENDPS = 0x660F3A0C, + BLENDVPD = 0x660F3815, + BLENDVPS = 0x660F3814, + DPPD = 0x660F3A41, + DPPS = 0x660F3A40, + EXTRACTPS = 0x660F3A17, + INSERTPS = 0x660F3A21, + MPSADBW = 0x660F3A42, + PBLENDVB = 0x660F3810, + PBLENDW = 0x660F3A0E, + PEXTRD = 0x660F3A16, + PEXTRQ = 0x660F3A16, + PINSRB = 0x660F3A20, + PINSRD = 0x660F3A22, + PINSRQ = 0x660F3A22, + + MOVNTDQA = 0x660F382A, + PACKUSDW = 0x660F382B, + PCMPEQQ = 0x660F3829, + PEXTRB = 0x660F3A14, + PHMINPOSUW = 0x660F3841, + PMAXSB = 0x660F383C, + PMAXSD = 0x660F383D, + PMAXUD = 0x660F383F, + PMAXUW = 0x660F383E, + PMINSB = 0x660F3838, + PMINSD = 0x660F3839, + PMINUD = 0x660F383B, + PMINUW = 0x660F383A, + PMOVSXBW = 0x660F3820, + PMOVSXBD = 0x660F3821, + PMOVSXBQ = 0x660F3822, + PMOVSXWD = 0x660F3823, + PMOVSXWQ = 0x660F3824, + PMOVSXDQ = 0x660F3825, + PMOVZXBW = 0x660F3830, + PMOVZXBD = 0x660F3831, + PMOVZXBQ = 0x660F3832, + PMOVZXWD = 0x660F3833, + PMOVZXWQ = 0x660F3834, + PMOVZXDQ = 0x660F3835, + PMULDQ = 0x660F3828, + PMULLD = 0x660F3840, + PTEST = 0x660F3817, + + ROUNDPD = 0x660F3A09, + ROUNDPS = 0x660F3A08, + ROUNDSD = 0x660F3A0B, + ROUNDSS = 0x660F3A0A, + +// SSE4.2 + PCMPESTRI = 0x660F3A61, + PCMPESTRM = 0x660F3A60, + PCMPISTRI = 0x660F3A63, + PCMPISTRM = 0x660F3A62, + PCMPGTQ = 0x660F3837, + // CRC32 + +// SSE4a (AMD only) + // EXTRQ,INSERTQ,MOVNTSD,MOVNTSS + +// POPCNT and LZCNT (have their own CPUID bits) + POPCNT = 0xF30FB8, + // LZCNT + +// AVX + XGETBV = 0x0F01D0, + XSETBV = 0x0F01D1, + +// AES + AESENC = 0x660F38DC, + AESENCLAST = 0x660F38DD, + AESDEC = 0x660F38DE, + AESDECLAST = 0x660F38DF, + AESIMC = 0x660F38DB, + AESKEYGENASSIST = 0x660F3ADF, +}; diff --git a/backendlicense.txt b/backendlicense.txt new file mode 100644 index 00000000..bdb69f49 --- /dev/null +++ b/backendlicense.txt @@ -0,0 +1,42 @@ + +The Software is not generally available software. It has not undergone +testing and may contain errors. The Software was not designed to operate +after December 31, 1999. It may be incomplete and it may not function +properly. No support or maintenance is provided with this Software. Do +not install or distribute the Software if +you are not accustomed to using or distributing experimental software. +Do not use this software for life critical applications, or applications +that could cause significant harm or property damage. + +Digital Mars licenses the Software to you on an "AS IS" basis, without +warranty of any kind. DIGITAL MARS AND SYMANTEC HEREBY EXPRESSLY DISCLAIM +ALL WARRANTIES AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OR CONDITIONS OF MERCHANTABILITY, +NONINFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. You are solely +responsible for determining the appropriateness of using this Software and +assume all risks associated with the use of this Software, including but not +limited to the risks of program errors, damage +to or loss of data, programs or equipment, unavailability or interruption of +operations and third party claims. You agree to defend, indemnify and hold +Digital Mars and Symantec, its subsidiaries, affiliates, directors, officers, +employees and agents harmless from all claims or demands made against them +(and any related losses, damages, expenses +and costs) arising out of your use of the Software. DIGITAL MARS AND SYMANTEC +WILL NOT BE LIABLE FOR ANY DIRECT DAMAGES OR FOR ANY SPECIAL, INCIDENTAL, OR +INDIRECT DAMAGES OR FOR ANY ECONOMIC CONSEQUENTIAL DAMAGES (INCLUDING +LOST PROFITS OR SAVINGS), EVEN IF DIGITAL MARS OR SYMANTEC HAS BEEN ADVISED +OF THE POSSIBILITY OF SUCH DAMAGES. +Digital Mars and Symantec will not be liable for the loss of, or damage to, +your records or data, the records or +data of any third party, or any damages claimed by you based on a third party +claim. + +If you send any messages to Digital Mars, on either the Digital Mars +newsgroups, the Digital Mars mailing list, or via email, you agree not +to make any claims of intellectual +property rights over the contents of those messages. + +The Software is copyrighted and comes with a single user license, +and may not be redistributed. If you wish to obtain a redistribution license, +please contact Digital Mars. + diff --git a/builtin.c b/builtin.c new file mode 100644 index 00000000..4cfee71f --- /dev/null +++ b/builtin.c @@ -0,0 +1,234 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#if __FreeBSD__ +extern "C" +{ + long double sinl(long double); + long double cosl(long double); + long double tanl(long double); + long double sqrtl(long double); +} +#endif + +#include "mars.h" +#include "declaration.h" +#include "attrib.h" +#include "expression.h" +#include "scope.h" +#include "mtype.h" +#include "aggregate.h" +#include "identifier.h" +#include "id.h" +#include "module.h" + +#if DMDV2 + +/********************************** + * Determine if function is a builtin one that we can + * evaluate at compile time. + */ +enum BUILTIN FuncDeclaration::isBuiltin() +{ + static const char FeZe [] = "FNaNbNfeZe"; // @safe pure nothrow real function(real) + static const char FeZe2[] = "FNaNbNeeZe"; // @trusted pure nothrow real function(real) + static const char FuintZint[] = "FNaNbkZi"; // pure nothrow int function(uint) + static const char FuintZuint[] = "FNaNbkZk"; // pure nothrow uint function(uint) + static const char FulongZulong[] = "FNaNbkZk"; // pure nothrow int function(ulong) + static const char FulongZint[] = "FNaNbmZi"; // pure nothrow int function(uint) + static const char FrealrealZreal [] = "FNaNbNfeeZe"; // @safe pure nothrow real function(real, real) + static const char FrealZlong [] = "FNaNbNfeZl"; // @safe pure nothrow long function(real) + + //printf("FuncDeclaration::isBuiltin() %s, %d\n", toChars(), builtin); + if (builtin == BUILTINunknown) + { + builtin = BUILTINnot; + if (parent && parent->isModule()) + { + // If it's in the std.math package + if (parent->ident == Id::math && + parent->parent && (parent->parent->ident == Id::std || parent->parent->ident == Id::core) && + !parent->parent->parent) + { + //printf("deco = %s\n", type->deco); + if (strcmp(type->deco, FeZe) == 0 || strcmp(type->deco, FeZe2) == 0) + { + if (ident == Id::sin) + builtin = BUILTINsin; + else if (ident == Id::cos) + builtin = BUILTINcos; + else if (ident == Id::tan) + builtin = BUILTINtan; + else if (ident == Id::_sqrt) + builtin = BUILTINsqrt; + else if (ident == Id::fabs) + builtin = BUILTINfabs; + else if (ident == Id::expm1) + builtin = BUILTINexpm1; + else if (ident == Id::exp2) + builtin = BUILTINexp2; + //printf("builtin = %d\n", builtin); + } + // if float or double versions + else if (strcmp(type->deco, "FNaNbNfdZd") == 0 || + strcmp(type->deco, "FNaNbNffZf") == 0) + { + if (ident == Id::_sqrt) + builtin = BUILTINsqrt; + } + else if (strcmp(type->deco, FrealrealZreal) == 0) + { + if (ident == Id::atan2) + builtin = BUILTINatan2; + else if (ident == Id::yl2x) + builtin = BUILTINyl2x; + else if (ident == Id::yl2xp1) + builtin = BUILTINyl2xp1; + } + else if (strcmp(type->deco, FrealZlong) == 0 && ident == Id::rndtol) + builtin = BUILTINrndtol; + } + if (parent->ident == Id::bitop && + parent->parent && parent->parent->ident == Id::core && + !parent->parent->parent) + { + //printf("deco = %s\n", type->deco); + if (strcmp(type->deco, FuintZint) == 0 || strcmp(type->deco, FulongZint) == 0) + { + if (ident == Id::bsf) + builtin = BUILTINbsf; + else if (ident == Id::bsr) + builtin = BUILTINbsr; + } + else if (strcmp(type->deco, FuintZuint) == 0) + { + if (ident == Id::bswap) + builtin = BUILTINbswap; + } + } + } + } + return builtin; +} + +int eval_bsf(uinteger_t n) +{ + n = (n ^ (n - 1)) >> 1; // convert trailing 0s to 1, and zero rest + int k = 0; + while( n ) + { ++k; + n >>=1; + } + return k; +} + +int eval_bsr(uinteger_t n) +{ int k= 0; + while(n>>=1) + { + ++k; + } + return k; +} + +uinteger_t eval_bswap(Expression *arg0) +{ uinteger_t n = arg0->toInteger(); + #define BYTEMASK 0x00FF00FF00FF00FFLL + #define SHORTMASK 0x0000FFFF0000FFFFLL + #define INTMASK 0x0000FFFF0000FFFFLL + // swap adjacent ubytes + n = ((n >> 8 ) & BYTEMASK) | ((n & BYTEMASK) << 8 ); + // swap adjacent ushorts + n = ((n >> 16) & SHORTMASK) | ((n & SHORTMASK) << 16); + TY ty = arg0->type->toBasetype()->ty; + // If 64 bits, we need to swap high and low uints + if (ty == Tint64 || ty == Tuns64) + n = ((n >> 32) & INTMASK) | ((n & INTMASK) << 32); + return n; +} + +/************************************** + * Evaluate builtin function. + * Return result; NULL if cannot evaluate it. + */ + +Expression *eval_builtin(Loc loc, enum BUILTIN builtin, Expressions *arguments) +{ + assert(arguments && arguments->dim); + Expression *arg0 = arguments->tdata()[0]; + Expression *e = NULL; + switch (builtin) + { + case BUILTINsin: + if (arg0->op == TOKfloat64) + e = new RealExp(0, sinl(arg0->toReal()), arg0->type); + break; + + case BUILTINcos: + if (arg0->op == TOKfloat64) + e = new RealExp(0, cosl(arg0->toReal()), arg0->type); + break; + + case BUILTINtan: + if (arg0->op == TOKfloat64) + e = new RealExp(0, tanl(arg0->toReal()), arg0->type); + break; + + case BUILTINsqrt: + if (arg0->op == TOKfloat64) + e = new RealExp(0, sqrtl(arg0->toReal()), arg0->type); + break; + + case BUILTINfabs: + if (arg0->op == TOKfloat64) + e = new RealExp(0, fabsl(arg0->toReal()), arg0->type); + break; + // These math intrinsics are not yet implemented + case BUILTINatan2: + break; + case BUILTINrndtol: + break; + case BUILTINexpm1: + break; + case BUILTINexp2: + break; + case BUILTINyl2x: + break; + case BUILTINyl2xp1: + break; + case BUILTINbsf: + if (arg0->op == TOKint64) + { if (arg0->toInteger()==0) + error(loc, "bsf(0) is undefined"); + else + e = new IntegerExp(loc, eval_bsf(arg0->toInteger()), Type::tint32); + } + break; + case BUILTINbsr: + if (arg0->op == TOKint64) + { if (arg0->toInteger()==0) + error(loc, "bsr(0) is undefined"); + else + e = new IntegerExp(loc, eval_bsr(arg0->toInteger()), Type::tint32); + } + break; + case BUILTINbswap: + if (arg0->op == TOKint64) + e = new IntegerExp(loc, eval_bswap(arg0), arg0->type); + break; + } + return e; +} + +#endif diff --git a/canthrow.c b/canthrow.c new file mode 100644 index 00000000..885b241a --- /dev/null +++ b/canthrow.c @@ -0,0 +1,189 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "init.h" +#include "expression.h" +#include "template.h" +#include "statement.h" +#include "mtype.h" +#include "utf.h" +#include "declaration.h" +#include "aggregate.h" +#include "scope.h" +#include "attrib.h" + +int Dsymbol_canThrow(Dsymbol *s, bool mustNotThrow); +int lambdaCanThrow(Expression *e, void *param); + +/******************************************** + * Convert from expression to delegate that returns the expression, + * i.e. convert: + * expr + * to: + * t delegate() { return expr; } + */ + +struct CanThrow +{ + bool can; + bool mustnot; +}; + +int Expression::canThrow(bool mustNotThrow) +{ + CanThrow ct; + ct.can = FALSE; + ct.mustnot = mustNotThrow; + apply(&lambdaCanThrow, &ct); + return ct.can; +} + +int lambdaCanThrow(Expression *e, void *param) +{ + CanThrow *pct = (CanThrow *)param; + switch (e->op) + { + case TOKdeclaration: + { DeclarationExp *de = (DeclarationExp *)e; + pct->can = Dsymbol_canThrow(de->declaration, pct->mustnot); + break; + } + + case TOKcall: + { CallExp *ce = (CallExp *)e; + + if (global.errors && !ce->e1->type) + break; // error recovery + + /* If calling a function or delegate that is typed as nothrow, + * then this expression cannot throw. + * Note that pure functions can throw. + */ + Type *t = ce->e1->type->toBasetype(); + if (t->ty == Tfunction && ((TypeFunction *)t)->isnothrow) + ; + else if (t->ty == Tdelegate && ((TypeFunction *)((TypeDelegate *)t)->next)->isnothrow) + ; + else + { + if (pct->mustnot) + e->error("%s is not nothrow", ce->e1->toChars()); + pct->can = TRUE; + } + break; + } + + case TOKnew: + { NewExp *ne = (NewExp *)e; + if (ne->member) + { + // See if constructor call can throw + Type *t = ne->member->type->toBasetype(); + if (t->ty == Tfunction && !((TypeFunction *)t)->isnothrow) + { + if (pct->mustnot) + e->error("constructor %s is not nothrow", ne->member->toChars()); + pct->can = TRUE; + } + } + // regard storage allocation failures as not recoverable + break; + } + + case TOKnewanonclass: + assert(0); // should have been lowered by semantic() + break; + + default: + break; + } + return pct->can; // stop walking if we determine this expression can throw +} + +/************************************** + * Does symbol, when initialized, throw? + * Mirrors logic in Dsymbol_toElem(). + */ + +int Dsymbol_canThrow(Dsymbol *s, bool mustNotThrow) +{ + AttribDeclaration *ad; + VarDeclaration *vd; + TemplateMixin *tm; + TupleDeclaration *td; + + //printf("Dsymbol_toElem() %s\n", s->toChars()); + ad = s->isAttribDeclaration(); + if (ad) + { + Dsymbols *decl = ad->include(NULL, NULL); + if (decl && decl->dim) + { + for (size_t i = 0; i < decl->dim; i++) + { + s = decl->tdata()[i]; + if (Dsymbol_canThrow(s, mustNotThrow)) + return 1; + } + } + } + else if ((vd = s->isVarDeclaration()) != NULL) + { + s = s->toAlias(); + if (s != vd) + return Dsymbol_canThrow(s, mustNotThrow); + if (vd->storage_class & STCmanifest) + ; + else if (vd->isStatic() || vd->storage_class & (STCextern | STCtls | STCgshared)) + ; + else + { + if (vd->init) + { ExpInitializer *ie = vd->init->isExpInitializer(); + if (ie && ie->exp->canThrow(mustNotThrow)) + return 1; + } + if (vd->edtor && !vd->noscope) + return vd->edtor->canThrow(mustNotThrow); + } + } + else if ((tm = s->isTemplateMixin()) != NULL) + { + //printf("%s\n", tm->toChars()); + if (tm->members) + { + for (size_t i = 0; i < tm->members->dim; i++) + { + Dsymbol *sm = tm->members->tdata()[i]; + if (Dsymbol_canThrow(sm, mustNotThrow)) + return 1; + } + } + } + else if ((td = s->isTupleDeclaration()) != NULL) + { + for (size_t i = 0; i < td->objects->dim; i++) + { Object *o = td->objects->tdata()[i]; + if (o->dyncast() == DYNCAST_EXPRESSION) + { Expression *eo = (Expression *)o; + if (eo->op == TOKdsymbol) + { DsymbolExp *se = (DsymbolExp *)eo; + if (Dsymbol_canThrow(se->s, mustNotThrow)) + return 1; + } + } + } + } + return 0; +} diff --git a/cast.c b/cast.c new file mode 100644 index 00000000..74c67f92 --- /dev/null +++ b/cast.c @@ -0,0 +1,2574 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "rmem.h" + +#include "expression.h" +#include "mtype.h" +#include "utf.h" +#include "declaration.h" +#include "aggregate.h" +#include "scope.h" + +//#define DUMP .dump(__PRETTY_FUNCTION__, this) +#define DUMP + +/* ==================== implicitCast ====================== */ + +/************************************** + * Do an implicit cast. + * Issue error if it can't be done. + */ + +Expression *Expression::implicitCastTo(Scope *sc, Type *t) +{ + //printf("Expression::implicitCastTo(%s of type %s) => %s\n", toChars(), type->toChars(), t->toChars()); + + MATCH match = implicitConvTo(t); + if (match) + { TY tyfrom = type->toBasetype()->ty; + TY tyto = t->toBasetype()->ty; +#if DMDV1 + if (global.params.warnings && + Type::impcnvWarn[tyfrom][tyto] && + op != TOKint64) + { + Expression *e = optimize(WANTflags | WANTvalue); + + if (e->op == TOKint64) + return e->implicitCastTo(sc, t); + if (tyfrom == Tint32 && + (op == TOKadd || op == TOKmin || + op == TOKand || op == TOKor || op == TOKxor) + ) + { + /* This is really only a semi-kludge fix, + * we really should look at the operands of op + * and see if they are narrower types. + * For example, b=b|b and b=b|7 and s=b+b should be allowed, + * but b=b|i should be an error. + */ + ; + } + else + { + warning("implicit conversion of expression (%s) of type %s to %s can cause loss of data", + toChars(), type->toChars(), t->toChars()); + } + } +#endif +#if DMDV2 + if (match == MATCHconst && t == type->constOf()) + { + Expression *e = copy(); + e->type = t; + return e; + } +#endif + return castTo(sc, t); + } + + Expression *e = optimize(WANTflags | WANTvalue); + if (e != this) + return e->implicitCastTo(sc, t); + +#if 0 +printf("ty = %d\n", type->ty); +print(); +type->print(); +printf("to:\n"); +t->print(); +printf("%p %p type: %s to: %s\n", type->deco, t->deco, type->deco, t->deco); +//printf("%p %p %p\n", type->nextOf()->arrayOf(), type, t); +fflush(stdout); +#endif + if (t->ty != Terror && type->ty != Terror) + { + if (!t->deco) + { /* Can happen with: + * enum E { One } + * class A + * { static void fork(EDG dg) { dg(E.One); } + * alias void delegate(E) EDG; + * } + * Should eventually make it work. + */ + error("forward reference to type %s", t->toChars()); + } + else if (t->reliesOnTident()) + error("forward reference to type %s", t->reliesOnTident()->toChars()); + + error("cannot implicitly convert expression (%s) of type %s to %s", + toChars(), type->toChars(), t->toChars()); + } + return new ErrorExp(); +} + +Expression *StringExp::implicitCastTo(Scope *sc, Type *t) +{ + //printf("StringExp::implicitCastTo(%s of type %s) => %s\n", toChars(), type->toChars(), t->toChars()); + unsigned char committed = this->committed; + Expression *e = Expression::implicitCastTo(sc, t); + if (e->op == TOKstring) + { + // Retain polysemous nature if it started out that way + ((StringExp *)e)->committed = committed; + } + return e; +} + +Expression *ErrorExp::implicitCastTo(Scope *sc, Type *t) +{ + return this; +} + +/******************************************* + * Return !=0 if we can implicitly convert this to type t. + * Don't do the actual cast. + */ + +MATCH Expression::implicitConvTo(Type *t) +{ +#if 0 + printf("Expression::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + //static int nest; if (++nest == 10) halt(); + if (t == Type::terror) + return MATCHnomatch; + if (!type) + { error("%s is not an expression", toChars()); + type = Type::terror; + } + Expression *e = optimize(WANTvalue | WANTflags); + if (e->type == t) + return MATCHexact; + if (e != this) + { //printf("\toptimized to %s of type %s\n", e->toChars(), e->type->toChars()); + return e->implicitConvTo(t); + } + MATCH match = type->implicitConvTo(t); + if (match != MATCHnomatch) + return match; + + /* See if we can do integral narrowing conversions + */ + if (type->isintegral() && t->isintegral() && + type->isTypeBasic() && t->isTypeBasic()) + { IntRange src = this->getIntRange() DUMP; + IntRange targetUnsigned = IntRange::fromType(t, /*isUnsigned*/true) DUMP; + IntRange targetSigned = IntRange::fromType(t, /*isUnsigned*/false) DUMP; + if (targetUnsigned.contains(src) || targetSigned.contains(src)) + return MATCHconvert; + } + +#if 0 + Type *tb = t->toBasetype(); + if (tb->ty == Tdelegate) + { TypeDelegate *td = (TypeDelegate *)tb; + TypeFunction *tf = (TypeFunction *)td->nextOf(); + + if (!tf->varargs && + !(tf->arguments && tf->arguments->dim) + ) + { + match = type->implicitConvTo(tf->nextOf()); + if (match) + return match; + if (tf->nextOf()->toBasetype()->ty == Tvoid) + return MATCHconvert; + } + } +#endif + return MATCHnomatch; +} + + +MATCH IntegerExp::implicitConvTo(Type *t) +{ +#if 0 + printf("IntegerExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH m = type->implicitConvTo(t); + if (m >= MATCHconst) + return m; + + TY ty = type->toBasetype()->ty; + TY toty = t->toBasetype()->ty; + + if (m == MATCHnomatch && t->ty == Tenum) + goto Lno; + + if (t->ty == Tvector) + { TypeVector *tv = (TypeVector *)t; + TypeBasic *tb = tv->elementType(); + toty = tb->ty; + } + + switch (ty) + { + case Tbool: + value &= 1; + ty = Tint32; + break; + + case Tint8: + value = (signed char)value; + ty = Tint32; + break; + + case Tchar: + case Tuns8: + value &= 0xFF; + ty = Tint32; + break; + + case Tint16: + value = (short)value; + ty = Tint32; + break; + + case Tuns16: + case Twchar: + value &= 0xFFFF; + ty = Tint32; + break; + + case Tint32: + value = (int)value; + break; + + case Tuns32: + case Tdchar: + value &= 0xFFFFFFFF; + ty = Tuns32; + break; + + default: + break; + } + + // Only allow conversion if no change in value + switch (toty) + { + case Tbool: + if ((value & 1) != value) + goto Lno; + goto Lyes; + + case Tint8: + if ((signed char)value != value) + goto Lno; + goto Lyes; + + case Tchar: + case Tuns8: + //printf("value = %llu %llu\n", (dinteger_t)(unsigned char)value, value); + if ((unsigned char)value != value) + goto Lno; + goto Lyes; + + case Tint16: + if ((short)value != value) + goto Lno; + goto Lyes; + + case Tuns16: + if ((unsigned short)value != value) + goto Lno; + goto Lyes; + + case Tint32: + if (ty == Tuns32) + { + } + else if ((int)value != value) + goto Lno; + goto Lyes; + + case Tuns32: + if (ty == Tint32) + { + } + else if ((unsigned)value != value) + goto Lno; + goto Lyes; + + case Tdchar: + if (value > 0x10FFFFUL) + goto Lno; + goto Lyes; + + case Twchar: + if ((unsigned short)value != value) + goto Lno; + goto Lyes; + + case Tfloat32: + { + volatile float f; + if (type->isunsigned()) + { + f = (float)value; + if (f != value) + goto Lno; + } + else + { + f = (float)(long long)value; + if (f != (long long)value) + goto Lno; + } + goto Lyes; + } + + case Tfloat64: + { + volatile double f; + if (type->isunsigned()) + { + f = (double)value; + if (f != value) + goto Lno; + } + else + { + f = (double)(long long)value; + if (f != (long long)value) + goto Lno; + } + goto Lyes; + } + + case Tfloat80: + { + volatile long double f; + if (type->isunsigned()) + { + f = (long double)value; + if (f != value) + goto Lno; + } + else + { + f = (long double)(long long)value; + if (f != (long long)value) + goto Lno; + } + goto Lyes; + } + + case Tpointer: +//printf("type = %s\n", type->toBasetype()->toChars()); +//printf("t = %s\n", t->toBasetype()->toChars()); + if (ty == Tpointer && + type->toBasetype()->nextOf()->ty == t->toBasetype()->nextOf()->ty) + { /* Allow things like: + * const char* P = cast(char *)3; + * char* q = P; + */ + goto Lyes; + } + break; + } + return Expression::implicitConvTo(t); + +Lyes: + //printf("MATCHconvert\n"); + return MATCHconvert; + +Lno: + //printf("MATCHnomatch\n"); + return MATCHnomatch; +} + +MATCH NullExp::implicitConvTo(Type *t) +{ +#if 0 + printf("NullExp::implicitConvTo(this=%s, type=%s, t=%s, committed = %d)\n", + toChars(), type->toChars(), t->toChars(), committed); +#endif + if (this->type->equals(t)) + return MATCHexact; + + /* Allow implicit conversions from immutable to mutable|const, + * and mutable to immutable. It works because, after all, a null + * doesn't actually point to anything. + */ + if (t->invariantOf()->equals(type->invariantOf())) + return MATCHconst; + + return Expression::implicitConvTo(t); +} + +#if DMDV2 +MATCH StructLiteralExp::implicitConvTo(Type *t) +{ +#if 0 + printf("StructLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH m = Expression::implicitConvTo(t); + if (m != MATCHnomatch) + return m; + if (type->ty == t->ty && type->ty == Tstruct && + ((TypeStruct *)type)->sym == ((TypeStruct *)t)->sym) + { + m = MATCHconst; + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = (*elements)[i]; + Type *te = e->type; + te = te->castMod(t->mod); + MATCH m2 = e->implicitConvTo(te); + //printf("\t%s => %s, match = %d\n", e->toChars(), te->toChars(), m2); + if (m2 < m) + m = m2; + } + } + return m; +} +#endif + +MATCH StringExp::implicitConvTo(Type *t) +{ +#if 0 + printf("StringExp::implicitConvTo(this=%s, committed=%d, type=%s, t=%s)\n", + toChars(), committed, type->toChars(), t->toChars()); +#endif + if (!committed && t->ty == Tpointer && t->nextOf()->ty == Tvoid) + { + return MATCHnomatch; + } + if (type->ty == Tsarray || type->ty == Tarray || type->ty == Tpointer) + { + TY tyn = type->nextOf()->ty; + if (tyn == Tchar || tyn == Twchar || tyn == Tdchar) + { Type *tn; + MATCH m; + + switch (t->ty) + { + case Tsarray: + if (type->ty == Tsarray) + { + if (((TypeSArray *)type)->dim->toInteger() != + ((TypeSArray *)t)->dim->toInteger()) + return MATCHnomatch; + TY tynto = t->nextOf()->ty; + if (tynto == tyn) + return MATCHexact; + if (!committed && (tynto == Tchar || tynto == Twchar || tynto == Tdchar)) + return MATCHexact; + } + else if (type->ty == Tarray) + { + if (length() > + ((TypeSArray *)t)->dim->toInteger()) + return MATCHnomatch; + TY tynto = t->nextOf()->ty; + if (tynto == tyn) + return MATCHexact; + if (!committed && (tynto == Tchar || tynto == Twchar || tynto == Tdchar)) + return MATCHexact; + } + case Tarray: + case Tpointer: + tn = t->nextOf(); + m = MATCHexact; + if (type->nextOf()->mod != tn->mod) + { if (!tn->isConst()) + return MATCHnomatch; + m = MATCHconst; + } + switch (tn->ty) + { + case Tchar: + case Twchar: + case Tdchar: + if (!committed) + return m; + break; + } + break; + } + } + } + return Expression::implicitConvTo(t); +#if 0 + m = (MATCH)type->implicitConvTo(t); + if (m) + { + return m; + } + + return MATCHnomatch; +#endif +} + +MATCH ArrayLiteralExp::implicitConvTo(Type *t) +{ MATCH result = MATCHexact; + +#if 0 + printf("ArrayLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + Type *typeb = type->toBasetype(); + Type *tb = t->toBasetype(); + if ((tb->ty == Tarray || tb->ty == Tsarray) && + (typeb->ty == Tarray || typeb->ty == Tsarray)) + { + if (tb->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)tb; + if (elements->dim != tsa->dim->toInteger()) + result = MATCHnomatch; + } + + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = (*elements)[i]; + MATCH m = (MATCH)e->implicitConvTo(tb->nextOf()); + if (m < result) + result = m; // remember worst match + if (result == MATCHnomatch) + break; // no need to check for worse + } + + if (!result) + result = type->implicitConvTo(t); + + return result; + } + else + return Expression::implicitConvTo(t); +} + +MATCH AssocArrayLiteralExp::implicitConvTo(Type *t) +{ MATCH result = MATCHexact; + + Type *typeb = type->toBasetype(); + Type *tb = t->toBasetype(); + if (tb->ty == Taarray && typeb->ty == Taarray) + { + for (size_t i = 0; i < keys->dim; i++) + { Expression *e = keys->tdata()[i]; + MATCH m = (MATCH)e->implicitConvTo(((TypeAArray *)tb)->index); + if (m < result) + result = m; // remember worst match + if (result == MATCHnomatch) + break; // no need to check for worse + e = values->tdata()[i]; + m = (MATCH)e->implicitConvTo(tb->nextOf()); + if (m < result) + result = m; // remember worst match + if (result == MATCHnomatch) + break; // no need to check for worse + } + return result; + } + else + return Expression::implicitConvTo(t); +} + +MATCH CallExp::implicitConvTo(Type *t) +{ +#if 0 + printf("CalLExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + + MATCH m = Expression::implicitConvTo(t); + if (m) + return m; + + /* Allow the result of strongly pure functions to + * convert to immutable + */ + if (f && f->isPure() == PUREstrong && !f->type->hasWild()) + return type->invariantOf()->implicitConvTo(t); + + return MATCHnomatch; +} + +MATCH AddrExp::implicitConvTo(Type *t) +{ +#if 0 + printf("AddrExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH result; + + result = type->implicitConvTo(t); + //printf("\tresult = %d\n", result); + + if (result == MATCHnomatch) + { + // Look for pointers to functions where the functions are overloaded. + + t = t->toBasetype(); + + if (e1->op == TOKoverloadset && + (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) + { OverExp *eo = (OverExp *)e1; + FuncDeclaration *f = NULL; + for (size_t i = 0; i < eo->vars->a.dim; i++) + { Dsymbol *s = eo->vars->a[i]; + FuncDeclaration *f2 = s->isFuncDeclaration(); + assert(f2); + if (f2->overloadExactMatch(t->nextOf())) + { if (f) + /* Error if match in more than one overload set, + * even if one is a 'better' match than the other. + */ + ScopeDsymbol::multiplyDefined(loc, f, f2); + else + f = f2; + result = MATCHexact; + } + } + } + + if (type->ty == Tpointer && type->nextOf()->ty == Tfunction && + t->ty == Tpointer && t->nextOf()->ty == Tfunction && + e1->op == TOKvar) + { + /* I don't think this can ever happen - + * it should have been + * converted to a SymOffExp. + */ + assert(0); + VarExp *ve = (VarExp *)e1; + FuncDeclaration *f = ve->var->isFuncDeclaration(); + if (f && f->overloadExactMatch(t->nextOf())) + result = MATCHexact; + } + } + //printf("\tresult = %d\n", result); + return result; +} + +MATCH SymOffExp::implicitConvTo(Type *t) +{ +#if 0 + printf("SymOffExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH result; + + result = type->implicitConvTo(t); + //printf("\tresult = %d\n", result); + + if (result == MATCHnomatch) + { + // Look for pointers to functions where the functions are overloaded. + FuncDeclaration *f; + + t = t->toBasetype(); + if (type->ty == Tpointer && type->nextOf()->ty == Tfunction && + (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) + { + f = var->isFuncDeclaration(); + if (f) + { f = f->overloadExactMatch(t->nextOf()); + if (f) + { if ((t->ty == Tdelegate && (f->needThis() || f->isNested())) || + (t->ty == Tpointer && !(f->needThis() || f->isNested()))) + { + result = MATCHexact; + } + } + } + } + } + //printf("\tresult = %d\n", result); + return result; +} + +MATCH DelegateExp::implicitConvTo(Type *t) +{ +#if 0 + printf("DelegateExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH result; + + result = type->implicitConvTo(t); + + if (result == MATCHnomatch) + { + // Look for pointers to functions where the functions are overloaded. + + t = t->toBasetype(); + if (type->ty == Tdelegate && + t->ty == Tdelegate) + { + if (func && func->overloadExactMatch(t->nextOf())) + result = MATCHexact; + } + } + return result; +} + +MATCH FuncExp::implicitConvTo(Type *t) +{ + //printf("FuncExp::implicitCastTo type = %p %s, t = %s\n", type, type ? type->toChars() : NULL, t->toChars()); + if (type && type != Type::tvoid && tok == TOKreserved && type->ty == Tpointer + && (t->ty == Tpointer || t->ty == Tdelegate)) + { // Allow implicit function to delegate conversion + if (type->nextOf()->covariant(t->nextOf()) == 1) + return t->ty == Tpointer ? MATCHconst : MATCHconvert; + } + return Expression::implicitConvTo(t); +} + +MATCH OrExp::implicitConvTo(Type *t) +{ + MATCH result = Expression::implicitConvTo(t); + + if (result == MATCHnomatch) + { + MATCH m1 = e1->implicitConvTo(t); + MATCH m2 = e2->implicitConvTo(t); + + // Pick the worst match + result = (m1 < m2) ? m1 : m2; + } + return result; +} + +MATCH XorExp::implicitConvTo(Type *t) +{ + MATCH result = Expression::implicitConvTo(t); + + if (result == MATCHnomatch) + { + MATCH m1 = e1->implicitConvTo(t); + MATCH m2 = e2->implicitConvTo(t); + + // Pick the worst match + result = (m1 < m2) ? m1 : m2; + } + return result; +} + +MATCH CondExp::implicitConvTo(Type *t) +{ + MATCH m1 = e1->implicitConvTo(t); + MATCH m2 = e2->implicitConvTo(t); + //printf("CondExp: m1 %d m2 %d\n", m1, m2); + + // Pick the worst match + return (m1 < m2) ? m1 : m2; +} + +MATCH CommaExp::implicitConvTo(Type *t) +{ + return e2->implicitConvTo(t); +} + +MATCH CastExp::implicitConvTo(Type *t) +{ +#if 0 + printf("CastExp::implicitConvTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + MATCH result; + + result = type->implicitConvTo(t); + + if (result == MATCHnomatch) + { + if (t->isintegral() && + e1->type->isintegral() && + e1->implicitConvTo(t) != MATCHnomatch) + result = MATCHconvert; + else + result = Expression::implicitConvTo(t); + } + return result; +} + +/* ==================== castTo ====================== */ + +/************************************** + * Do an explicit cast. + */ + +Expression *Expression::castTo(Scope *sc, Type *t) +{ + //printf("Expression::castTo(this=%s, t=%s)\n", toChars(), t->toChars()); +#if 0 + printf("Expression::castTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + if (type == t) + return this; + Expression *e = this; + Type *tb = t->toBasetype(); + Type *typeb = type->toBasetype(); + if (tb != typeb) + { + // Do (type *) cast of (type [dim]) + if (tb->ty == Tpointer && + typeb->ty == Tsarray + ) + { + //printf("Converting [dim] to *\n"); + + if (typeb->size(loc) == 0) + e = new NullExp(loc); + else + e = new AddrExp(loc, e); + } +#if 0 + else if (tb->ty == Tdelegate && type->ty != Tdelegate) + { + TypeDelegate *td = (TypeDelegate *)tb; + TypeFunction *tf = (TypeFunction *)td->nextOf(); + return toDelegate(sc, tf->nextOf()); + } +#endif + else + { + if (typeb->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)typeb; + if (!(tb->ty == Tstruct && ts->sym == ((TypeStruct *)tb)->sym) && + ts->sym->aliasthis) + { /* Forward the cast to our alias this member, rewrite to: + * cast(to)e1.aliasthis + */ + Expression *e1 = new DotIdExp(loc, this, ts->sym->aliasthis->ident); + Expression *e2 = new CastExp(loc, e1, tb); + e2 = e2->semantic(sc); + return e2; + } + } + else if (typeb->ty == Tclass) + { TypeClass *ts = (TypeClass *)typeb; + if (ts->sym->aliasthis) + { + if (tb->ty == Tclass) + { + ClassDeclaration *cdfrom = typeb->isClassHandle(); + ClassDeclaration *cdto = tb->isClassHandle(); + int offset; + if (cdto->isBaseOf(cdfrom, &offset)) + goto L1; + } + /* Forward the cast to our alias this member, rewrite to: + * cast(to)e1.aliasthis + */ + Expression *e1 = new DotIdExp(loc, this, ts->sym->aliasthis->ident); + Expression *e2 = new CastExp(loc, e1, tb); + e2 = e2->semantic(sc); + return e2; + } + L1: ; + } + else if (tb->ty == Tvector && typeb->ty != Tvector) + { + e = new VectorExp(loc, e, tb); + e = e->semantic(sc); + return e; + } + e = new CastExp(loc, e, tb); + } + } + else + { + e = e->copy(); // because of COW for assignment to e->type + } + assert(e != this); + e->type = t; + //printf("Returning: %s\n", e->toChars()); + return e; +} + + +Expression *ErrorExp::castTo(Scope *sc, Type *t) +{ + return this; +} + + +Expression *RealExp::castTo(Scope *sc, Type *t) +{ Expression *e = this; + if (type != t) + { + if ((type->isreal() && t->isreal()) || + (type->isimaginary() && t->isimaginary()) + ) + { e = copy(); + e->type = t; + } + else + e = Expression::castTo(sc, t); + } + return e; +} + + +Expression *ComplexExp::castTo(Scope *sc, Type *t) +{ Expression *e = this; + if (type != t) + { + if (type->iscomplex() && t->iscomplex()) + { e = copy(); + e->type = t; + } + else + e = Expression::castTo(sc, t); + } + return e; +} + + +Expression *NullExp::castTo(Scope *sc, Type *t) +{ + //printf("NullExp::castTo(t = %p)\n", t); + if (type == t) + { + committed = 1; + return this; + } + + NullExp *e = (NullExp *)copy(); + e->committed = 1; + Type *tb = t->toBasetype(); +#if 0 + e->type = type->toBasetype(); + if (tb != e->type) + { + // NULL implicitly converts to any pointer type or dynamic array + if (e->type->ty == Tpointer && e->type->nextOf()->ty == Tvoid && + (tb->ty == Tpointer || tb->ty == Tarray || tb->ty == Taarray || + tb->ty == Tdelegate)) + { + if (tb->ty == Tdelegate) + { TypeDelegate *td = (TypeDelegate *)tb; + TypeFunction *tf = (TypeFunction *)td->nextOf(); + + if (!tf->varargs && + !(tf->arguments && tf->arguments->dim) + ) + { + return Expression::castTo(sc, t); + } + } + } + else + { + //return e->Expression::castTo(sc, t); + } + } +#else + if (tb->ty == Tvoid) + { + e->type = type->toBasetype(); + return e->Expression::castTo(sc, t); + } +#endif + e->type = t; + return e; +} + +Expression *StringExp::castTo(Scope *sc, Type *t) +{ + /* This follows copy-on-write; any changes to 'this' + * will result in a copy. + * The this->string member is considered immutable. + */ + int copied = 0; + + //printf("StringExp::castTo(t = %s), '%s' committed = %d\n", t->toChars(), toChars(), committed); + + if (!committed && t->ty == Tpointer && t->nextOf()->ty == Tvoid) + { + error("cannot convert string literal to void*"); + return new ErrorExp(); + } + + StringExp *se = this; + if (!committed) + { se = (StringExp *)copy(); + se->committed = 1; + copied = 1; + } + + if (type == t) + { + return se; + } + + Type *tb = t->toBasetype(); + //printf("\ttype = %s\n", type->toChars()); + if (tb->ty == Tdelegate && type->toBasetype()->ty != Tdelegate) + return Expression::castTo(sc, t); + + Type *typeb = type->toBasetype(); + if (typeb == tb) + { + if (!copied) + { se = (StringExp *)copy(); + copied = 1; + } + se->type = t; + return se; + } + + if (committed && tb->ty == Tsarray && typeb->ty == Tarray) + { + se = (StringExp *)copy(); + d_uns64 szx = tb->nextOf()->size(); + assert(szx <= 255); + se->sz = (unsigned char)szx; + se->len = (len * sz) / se->sz; + se->committed = 1; + se->type = t; + return se; + } + + if (tb->ty != Tsarray && tb->ty != Tarray && tb->ty != Tpointer) + { if (!copied) + { se = (StringExp *)copy(); + copied = 1; + } + goto Lcast; + } + if (typeb->ty != Tsarray && typeb->ty != Tarray && typeb->ty != Tpointer) + { if (!copied) + { se = (StringExp *)copy(); + copied = 1; + } + goto Lcast; + } + + if (typeb->nextOf()->size() == tb->nextOf()->size()) + { + if (!copied) + { se = (StringExp *)copy(); + copied = 1; + } + if (tb->ty == Tsarray) + goto L2; // handle possible change in static array dimension + se->type = t; + return se; + } + + if (committed) + goto Lcast; + +#define X(tf,tt) ((tf) * 256 + (tt)) + { + OutBuffer buffer; + size_t newlen = 0; + int tfty = typeb->nextOf()->toBasetype()->ty; + int ttty = tb->nextOf()->toBasetype()->ty; + switch (X(tfty, ttty)) + { + case X(Tchar, Tchar): + case X(Twchar,Twchar): + case X(Tdchar,Tdchar): + break; + + case X(Tchar, Twchar): + for (size_t u = 0; u < len;) + { unsigned c; + const char *p = utf_decodeChar((unsigned char *)se->string, len, &u, &c); + if (p) + error("%s", p); + else + buffer.writeUTF16(c); + } + newlen = buffer.offset / 2; + buffer.writeUTF16(0); + goto L1; + + case X(Tchar, Tdchar): + for (size_t u = 0; u < len;) + { unsigned c; + const char *p = utf_decodeChar((unsigned char *)se->string, len, &u, &c); + if (p) + error("%s", p); + buffer.write4(c); + newlen++; + } + buffer.write4(0); + goto L1; + + case X(Twchar,Tchar): + for (size_t u = 0; u < len;) + { unsigned c; + const char *p = utf_decodeWchar((unsigned short *)se->string, len, &u, &c); + if (p) + error("%s", p); + else + buffer.writeUTF8(c); + } + newlen = buffer.offset; + buffer.writeUTF8(0); + goto L1; + + case X(Twchar,Tdchar): + for (size_t u = 0; u < len;) + { unsigned c; + const char *p = utf_decodeWchar((unsigned short *)se->string, len, &u, &c); + if (p) + error("%s", p); + buffer.write4(c); + newlen++; + } + buffer.write4(0); + goto L1; + + case X(Tdchar,Tchar): + for (size_t u = 0; u < len; u++) + { + unsigned c = ((unsigned *)se->string)[u]; + if (!utf_isValidDchar(c)) + error("invalid UCS-32 char \\U%08x", c); + else + buffer.writeUTF8(c); + newlen++; + } + newlen = buffer.offset; + buffer.writeUTF8(0); + goto L1; + + case X(Tdchar,Twchar): + for (size_t u = 0; u < len; u++) + { + unsigned c = ((unsigned *)se->string)[u]; + if (!utf_isValidDchar(c)) + error("invalid UCS-32 char \\U%08x", c); + else + buffer.writeUTF16(c); + newlen++; + } + newlen = buffer.offset / 2; + buffer.writeUTF16(0); + goto L1; + + L1: + if (!copied) + { se = (StringExp *)copy(); + copied = 1; + } + se->string = buffer.extractData(); + se->len = newlen; + + { + d_uns64 szx = tb->nextOf()->size(); + assert(szx <= 255); + se->sz = (unsigned char)szx; + } + break; + + default: + assert(typeb->nextOf()->size() != tb->nextOf()->size()); + goto Lcast; + } + } +#undef X +L2: + assert(copied); + + // See if need to truncate or extend the literal + if (tb->ty == Tsarray) + { + dinteger_t dim2 = ((TypeSArray *)tb)->dim->toInteger(); + + //printf("dim from = %d, to = %d\n", (int)se->len, (int)dim2); + + // Changing dimensions + if (dim2 != se->len) + { + // Copy when changing the string literal + unsigned newsz = se->sz; + void *s; + int d; + + d = (dim2 < se->len) ? dim2 : se->len; + s = (unsigned char *)mem.malloc((dim2 + 1) * newsz); + memcpy(s, se->string, d * newsz); + // Extend with 0, add terminating 0 + memset((char *)s + d * newsz, 0, (dim2 + 1 - d) * newsz); + se->string = s; + se->len = dim2; + } + } + se->type = t; + return se; + +Lcast: + Expression *e = new CastExp(loc, se, t); + e->type = t; // so semantic() won't be run on e + return e; +} + +Expression *AddrExp::castTo(Scope *sc, Type *t) +{ + Type *tb; + +#if 0 + printf("AddrExp::castTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + Expression *e = this; + + tb = t->toBasetype(); + type = type->toBasetype(); + if (tb != type) + { + // Look for pointers to functions where the functions are overloaded. + + if (e1->op == TOKoverloadset && + (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) + { OverExp *eo = (OverExp *)e1; + FuncDeclaration *f = NULL; + for (size_t i = 0; i < eo->vars->a.dim; i++) + { Dsymbol *s = eo->vars->a[i]; + FuncDeclaration *f2 = s->isFuncDeclaration(); + assert(f2); + if (f2->overloadExactMatch(t->nextOf())) + { if (f) + /* Error if match in more than one overload set, + * even if one is a 'better' match than the other. + */ + ScopeDsymbol::multiplyDefined(loc, f, f2); + else + f = f2; + } + } + if (f) + { f->tookAddressOf++; + SymOffExp *se = new SymOffExp(loc, f, 0, 0); + se->semantic(sc); + // Let SymOffExp::castTo() do the heavy lifting + return se->castTo(sc, t); + } + } + + + if (type->ty == Tpointer && type->nextOf()->ty == Tfunction && + tb->ty == Tpointer && tb->nextOf()->ty == Tfunction && + e1->op == TOKvar) + { + VarExp *ve = (VarExp *)e1; + FuncDeclaration *f = ve->var->isFuncDeclaration(); + if (f) + { + assert(0); // should be SymOffExp instead + f = f->overloadExactMatch(tb->nextOf()); + if (f) + { + e = new VarExp(loc, f); + e->type = f->type; + e = new AddrExp(loc, e); + e->type = t; + return e; + } + } + } + e = Expression::castTo(sc, t); + } + e->type = t; + return e; +} + + +Expression *TupleExp::castTo(Scope *sc, Type *t) +{ TupleExp *e = (TupleExp *)copy(); + e->exps = (Expressions *)exps->copy(); + for (size_t i = 0; i < e->exps->dim; i++) + { Expression *ex = e->exps->tdata()[i]; + ex = ex->castTo(sc, t); + e->exps->tdata()[i] = ex; + } + return e; +} + + +Expression *ArrayLiteralExp::castTo(Scope *sc, Type *t) +{ +#if 0 + printf("ArrayLiteralExp::castTo(this=%s, type=%s, => %s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + if (type == t) + return this; + ArrayLiteralExp *e = this; + Type *typeb = type->toBasetype(); + Type *tb = t->toBasetype(); + if ((tb->ty == Tarray || tb->ty == Tsarray) && + (typeb->ty == Tarray || typeb->ty == Tsarray) && + // Not trying to convert non-void[] to void[] + !(tb->nextOf()->toBasetype()->ty == Tvoid && typeb->nextOf()->toBasetype()->ty != Tvoid)) + { + if (tb->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)tb; + if (elements->dim != tsa->dim->toInteger()) + goto L1; + } + + e = (ArrayLiteralExp *)copy(); + e->elements = (Expressions *)elements->copy(); + for (size_t i = 0; i < elements->dim; i++) + { Expression *ex = (*elements)[i]; + ex = ex->castTo(sc, tb->nextOf()); + (*e->elements)[i] = ex; + } + e->type = t; + return e; + } + if (tb->ty == Tpointer && typeb->ty == Tsarray) + { + Type *tp = typeb->nextOf()->pointerTo(); + if (!tp->equals(e->type)) + { e = (ArrayLiteralExp *)copy(); + e->type = tp; + } + } +L1: + return e->Expression::castTo(sc, t); +} + +Expression *AssocArrayLiteralExp::castTo(Scope *sc, Type *t) +{ + if (type == t) + return this; + AssocArrayLiteralExp *e = this; + Type *typeb = type->toBasetype(); + Type *tb = t->toBasetype(); + if (tb->ty == Taarray && typeb->ty == Taarray && + tb->nextOf()->toBasetype()->ty != Tvoid) + { + e = (AssocArrayLiteralExp *)copy(); + e->keys = (Expressions *)keys->copy(); + e->values = (Expressions *)values->copy(); + assert(keys->dim == values->dim); + for (size_t i = 0; i < keys->dim; i++) + { Expression *ex = values->tdata()[i]; + ex = ex->castTo(sc, tb->nextOf()); + e->values->tdata()[i] = ex; + + ex = keys->tdata()[i]; + ex = ex->castTo(sc, ((TypeAArray *)tb)->index); + e->keys->tdata()[i] = ex; + } + e->type = t; + return e; + } + return e->Expression::castTo(sc, t); +} + +Expression *SymOffExp::castTo(Scope *sc, Type *t) +{ +#if 0 + printf("SymOffExp::castTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + if (type == t && hasOverloads == 0) + return this; + Expression *e; + Type *tb = t->toBasetype(); + Type *typeb = type->toBasetype(); + if (tb != typeb) + { + // Look for pointers to functions where the functions are overloaded. + FuncDeclaration *f; + + if (hasOverloads && + typeb->ty == Tpointer && typeb->nextOf()->ty == Tfunction && + (tb->ty == Tpointer || tb->ty == Tdelegate) && tb->nextOf()->ty == Tfunction) + { + f = var->isFuncDeclaration(); + if (f) + { + f = f->overloadExactMatch(tb->nextOf()); + if (f) + { + if (tb->ty == Tdelegate) + { + if (f->needThis() && hasThis(sc)) + { + e = new DelegateExp(loc, new ThisExp(loc), f); + e = e->semantic(sc); + } + else if (f->isNested()) + { + e = new DelegateExp(loc, new IntegerExp(0), f); + e = e->semantic(sc); + } + else if (f->needThis()) + { error("no 'this' to create delegate for %s", f->toChars()); + return new ErrorExp(); + } + else + { error("cannot cast from function pointer to delegate"); + return new ErrorExp(); + } + } + else + { + e = new SymOffExp(loc, f, 0); + e->type = t; + } +#if DMDV2 + f->tookAddressOf++; +#endif + return e; + } + } + } + e = Expression::castTo(sc, t); + } + else + { e = copy(); + e->type = t; + ((SymOffExp *)e)->hasOverloads = 0; + } + return e; +} + +Expression *DelegateExp::castTo(Scope *sc, Type *t) +{ +#if 0 + printf("DelegateExp::castTo(this=%s, type=%s, t=%s)\n", + toChars(), type->toChars(), t->toChars()); +#endif + static char msg[] = "cannot form delegate due to covariant return type"; + + Expression *e = this; + Type *tb = t->toBasetype(); + Type *typeb = type->toBasetype(); + if (tb != typeb) + { + // Look for delegates to functions where the functions are overloaded. + FuncDeclaration *f; + + if (typeb->ty == Tdelegate && + tb->ty == Tdelegate) + { + if (func) + { + f = func->overloadExactMatch(tb->nextOf()); + if (f) + { int offset; + if (f->tintro && f->tintro->nextOf()->isBaseOf(f->type->nextOf(), &offset) && offset) + error("%s", msg); + f->tookAddressOf++; + e = new DelegateExp(loc, e1, f); + e->type = t; + return e; + } + if (func->tintro) + error("%s", msg); + } + } + e = Expression::castTo(sc, t); + } + else + { int offset; + + func->tookAddressOf++; + if (func->tintro && func->tintro->nextOf()->isBaseOf(func->type->nextOf(), &offset) && offset) + error("%s", msg); + e = copy(); + e->type = t; + } + return e; +} + +Expression *FuncExp::castTo(Scope *sc, Type *t) +{ + //printf("FuncExp::castTo type = %s, t = %s\n", type->toChars(), t->toChars()); + if (tok == TOKreserved) + { assert(type && type != Type::tvoid); + if (type->ty == Tpointer && t->ty == Tdelegate) + { + Expression *e = copy(); + e->type = new TypeDelegate(fd->type); + e->type = e->type->semantic(loc, sc); + return e; + } + } + return Expression::castTo(sc, t); +} + +Expression *CondExp::castTo(Scope *sc, Type *t) +{ + Expression *e = this; + + if (type != t) + { + if (1 || e1->op == TOKstring || e2->op == TOKstring) + { e = new CondExp(loc, econd, e1->castTo(sc, t), e2->castTo(sc, t)); + e->type = t; + } + else + e = Expression::castTo(sc, t); + } + return e; +} + +Expression *CommaExp::castTo(Scope *sc, Type *t) +{ + Expression *e2c = e2->castTo(sc, t); + Expression *e; + + if (e2c != e2) + { + e = new CommaExp(loc, e1, e2c); + e->type = e2c->type; + } + else + { e = this; + e->type = e2->type; + } + return e; +} + +/* ==================== ====================== */ + +/**************************************** + * Scale addition/subtraction to/from pointer. + */ + +Expression *BinExp::scaleFactor(Scope *sc) +{ + if (sc->func && !sc->intypeof) + { + if (sc->func->setUnsafe()) + { + error("pointer arithmetic not allowed in @safe functions"); + return new ErrorExp(); + } + } + + d_uns64 stride; + Type *t1b = e1->type->toBasetype(); + Type *t2b = e2->type->toBasetype(); + + if (t1b->ty == Tpointer && t2b->isintegral()) + { // Need to adjust operator by the stride + // Replace (ptr + int) with (ptr + (int * stride)) + Type *t = Type::tptrdiff_t; + + stride = t1b->nextOf()->size(loc); + if (!t->equals(t2b)) + e2 = e2->castTo(sc, t); + e2 = new MulExp(loc, e2, new IntegerExp(0, stride, t)); + e2->type = t; + type = e1->type; + } + else if (t2b->ty == Tpointer && t1b->isintegral()) + { // Need to adjust operator by the stride + // Replace (int + ptr) with (ptr + (int * stride)) + Type *t = Type::tptrdiff_t; + Expression *e; + + stride = t2b->nextOf()->size(loc); + if (!t->equals(t1b)) + e = e1->castTo(sc, t); + else + e = e1; + e = new MulExp(loc, e, new IntegerExp(0, stride, t)); + e->type = t; + type = e2->type; + e1 = e2; + e2 = e; + } + return this; +} + +/************************************** + * Return true if e is an empty array literal with dimensionality + * equal to or less than type of other array. + * [], [[]], [[[]]], etc. + * I.e., make sure that [1,2] is compatible with [], + * [[1,2]] is compatible with [[]], etc. + */ +bool isVoidArrayLiteral(Expression *e, Type *other) +{ + while (e->op == TOKarrayliteral && e->type->ty == Tarray + && (((ArrayLiteralExp *)e)->elements->dim == 1)) + { + e = ((ArrayLiteralExp *)e)->elements->tdata()[0]; + if (other->ty == Tsarray || other->ty == Tarray) + other = other->nextOf(); + else + return false; + } + if (other->ty != Tsarray && other->ty != Tarray) + return false; + Type *t = e->type; + return (e->op == TOKarrayliteral && t->ty == Tarray && + t->nextOf()->ty == Tvoid && + ((ArrayLiteralExp *)e)->elements->dim == 0); +} + + +/************************************** + * Combine types. + * Output: + * *pt merged type, if *pt is not NULL + * *pe1 rewritten e1 + * *pe2 rewritten e2 + * Returns: + * !=0 success + * 0 failed + */ + +int typeMerge(Scope *sc, Expression *e, Type **pt, Expression **pe1, Expression **pe2) +{ + //printf("typeMerge() %s op %s\n", (*pe1)->toChars(), (*pe2)->toChars()); + //e->dump(0); + + Expression *e1 = *pe1; + Expression *e2 = *pe2; + + if (e->op != TOKquestion || + e1->type->toBasetype()->ty != e2->type->toBasetype()->ty) + { + e1 = e1->integralPromotions(sc); + e2 = e2->integralPromotions(sc); + } + + Type *t1 = e1->type; + Type *t2 = e2->type; + assert(t1); + Type *t = t1; + + //if (t1) printf("\tt1 = %s\n", t1->toChars()); + //if (t2) printf("\tt2 = %s\n", t2->toChars()); +#ifdef DEBUG + if (!t2) printf("\te2 = '%s'\n", e2->toChars()); +#endif + assert(t2); + + Type *t1b = t1->toBasetype(); + Type *t2b = t2->toBasetype(); + + TY ty = (TY)Type::impcnvResult[t1b->ty][t2b->ty]; + if (ty != Terror) + { + TY ty1 = (TY)Type::impcnvType1[t1b->ty][t2b->ty]; + TY ty2 = (TY)Type::impcnvType2[t1b->ty][t2b->ty]; + + if (t1b->ty == ty1) // if no promotions + { + if (t1 == t2) + { + t = t1; + goto Lret; + } + + if (t1b == t2b) + { + t = t1b; + goto Lret; + } + } + + t = Type::basic[ty]; + + t1 = Type::basic[ty1]; + t2 = Type::basic[ty2]; + e1 = e1->castTo(sc, t1); + e2 = e2->castTo(sc, t2); + //printf("after typeCombine():\n"); + //dump(0); + //printf("ty = %d, ty1 = %d, ty2 = %d\n", ty, ty1, ty2); + goto Lret; + } + + t1 = t1b; + t2 = t2b; + +Lagain: + if (t1 == t2) + { + } + else if ((t1->ty == Tpointer && t2->ty == Tpointer) || + (t1->ty == Tdelegate && t2->ty == Tdelegate)) + { + // Bring pointers to compatible type + Type *t1n = t1->nextOf(); + Type *t2n = t2->nextOf(); + + if (t1n == t2n) + ; + else if (t1n->ty == Tvoid) // pointers to void are always compatible + t = t2; + else if (t2n->ty == Tvoid) + ; + else if (t1->implicitConvTo(t2)) + { + goto Lt2; + } + else if (t2->implicitConvTo(t1)) + { + goto Lt1; + } + else if (t1n->ty == Tfunction && t2n->ty == Tfunction) + { + TypeFunction *tf1 = (TypeFunction *)t1n; + TypeFunction *tf2 = (TypeFunction *)t2n; + TypeFunction *d = (TypeFunction *)tf1->syntaxCopy(); + + if (tf1->purity != tf2->purity) + d->purity = PUREimpure; + assert(d->purity != PUREfwdref); + + d->isnothrow = (tf1->isnothrow && tf2->isnothrow); + + if (tf1->trust == tf2->trust) + d->trust = tf1->trust; + else if (tf1->trust <= TRUSTsystem || tf2->trust <= TRUSTsystem) + d->trust = TRUSTsystem; + else + d->trust = TRUSTtrusted; + + Type *tx = NULL; + if (t1->ty == Tdelegate) + { + tx = new TypeDelegate(d); + tx = tx->merge(); + } + else + tx = d->pointerTo(); + + if (t1->implicitConvTo(tx) && t2->implicitConvTo(tx)) + { + t = tx; + e1 = e1->castTo(sc, t); + e2 = e2->castTo(sc, t); + goto Lret; + } + goto Lincompatible; + } + else if (t1n->mod != t2n->mod) + { + if (!t1n->isImmutable() && !t2n->isImmutable() && t1n->isShared() != t2n->isShared()) + goto Lincompatible; + unsigned char mod = MODmerge(t1n->mod, t2n->mod); + t1 = t1n->castMod(mod)->pointerTo(); + t2 = t2n->castMod(mod)->pointerTo(); + t = t1; + goto Lagain; + } + else if (t1n->ty == Tclass && t2n->ty == Tclass) + { ClassDeclaration *cd1 = t1n->isClassHandle(); + ClassDeclaration *cd2 = t2n->isClassHandle(); + int offset; + + if (cd1->isBaseOf(cd2, &offset)) + { + if (offset) + e2 = e2->castTo(sc, t); + } + else if (cd2->isBaseOf(cd1, &offset)) + { + t = t2; + if (offset) + e1 = e1->castTo(sc, t); + } + else + goto Lincompatible; + } + else + { + t1 = t1n->constOf()->pointerTo(); + t2 = t2n->constOf()->pointerTo(); + if (t1->implicitConvTo(t2)) + { + goto Lt2; + } + else if (t2->implicitConvTo(t1)) + { + goto Lt1; + } + goto Lincompatible; + } + } + else if ((t1->ty == Tsarray || t1->ty == Tarray) && + (e2->op == TOKnull && t2->ty == Tpointer && t2->nextOf()->ty == Tvoid || + // if e2 is void[] + e2->op == TOKarrayliteral && t2->ty == Tsarray && t2->nextOf()->ty == Tvoid && ((TypeSArray *)t2)->dim->toInteger() == 0 || + isVoidArrayLiteral(e2, t1)) + ) + { /* (T[n] op void*) => T[] + * (T[] op void*) => T[] + * (T[n] op void[0]) => T[] + * (T[] op void[0]) => T[] + * (T[n] op void[]) => T[] + * (T[] op void[]) => T[] + */ + goto Lx1; + } + else if ((t2->ty == Tsarray || t2->ty == Tarray) && + (e1->op == TOKnull && t1->ty == Tpointer && t1->nextOf()->ty == Tvoid || + e1->op == TOKarrayliteral && t1->ty == Tsarray && t1->nextOf()->ty == Tvoid && ((TypeSArray *)t1)->dim->toInteger() == 0 || + isVoidArrayLiteral(e1, t2)) + ) + { /* (void* op T[n]) => T[] + * (void* op T[]) => T[] + * (void[0] op T[n]) => T[] + * (void[0] op T[]) => T[] + * (void[] op T[n]) => T[] + * (void[] op T[]) => T[] + */ + goto Lx2; + } + else if ((t1->ty == Tsarray || t1->ty == Tarray) && t1->implicitConvTo(t2)) + { + if (t1->ty == Tsarray && e2->op == TOKarrayliteral) + goto Lt1; + goto Lt2; + } + else if ((t2->ty == Tsarray || t2->ty == Tarray) && t2->implicitConvTo(t1)) + { + if (t2->ty == Tsarray && e1->op == TOKarrayliteral) + goto Lt2; + goto Lt1; + } + /* If one is mutable and the other invariant, then retry + * with both of them as const + */ + else if ((t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Tpointer) && + (t2->ty == Tsarray || t2->ty == Tarray || t2->ty == Tpointer) && + t1->nextOf()->mod != t2->nextOf()->mod + ) + { + Type *t1n = t1->nextOf(); + Type *t2n = t2->nextOf(); + unsigned char mod; + if (e1->op == TOKnull && e2->op != TOKnull) + mod = t2n->mod; + else if (e1->op != TOKnull && e2->op == TOKnull) + mod = t1n->mod; + else if (!t1n->isImmutable() && !t2n->isImmutable() && t1n->isShared() != t2n->isShared()) + goto Lincompatible; + else + mod = MODmerge(t1n->mod, t2n->mod); + + if (t1->ty == Tpointer) + t1 = t1n->castMod(mod)->pointerTo(); + else + t1 = t1n->castMod(mod)->arrayOf(); + + if (t2->ty == Tpointer) + t2 = t2n->castMod(mod)->pointerTo(); + else + t2 = t2n->castMod(mod)->arrayOf(); + t = t1; + goto Lagain; + } + else if (t1->ty == Tclass && t2->ty == Tclass) + { + if (t1->mod != t2->mod) + { + unsigned char mod; + if (e1->op == TOKnull && e2->op != TOKnull) + mod = t2->mod; + else if (e1->op != TOKnull && e2->op == TOKnull) + mod = t1->mod; + else if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) + goto Lincompatible; + else + mod = MODmerge(t1->mod, t2->mod); + t1 = t1->castMod(mod); + t2 = t2->castMod(mod); + t = t1; + goto Lagain; + } + goto Lcc; + } + else if (t1->ty == Tclass || t2->ty == Tclass) + { +Lcc: + while (1) + { + int i1 = e2->implicitConvTo(t1); + int i2 = e1->implicitConvTo(t2); + + if (i1 && i2) + { + // We have the case of class vs. void*, so pick class + if (t1->ty == Tpointer) + i1 = 0; + else if (t2->ty == Tpointer) + i2 = 0; + } + + if (i2) + { + goto Lt2; + } + else if (i1) + { + goto Lt1; + } + else if (t1->ty == Tclass && t2->ty == Tclass) + { TypeClass *tc1 = (TypeClass *)t1; + TypeClass *tc2 = (TypeClass *)t2; + + /* Pick 'tightest' type + */ + ClassDeclaration *cd1 = tc1->sym->baseClass; + ClassDeclaration *cd2 = tc2->sym->baseClass; + + if (cd1 && cd2) + { t1 = cd1->type; + t2 = cd2->type; + } + else if (cd1) + t1 = cd1->type; + else if (cd2) + t2 = cd2->type; + else + goto Lincompatible; + } + else if (t1->ty == Tstruct && ((TypeStruct *)t1)->sym->aliasthis) + { + e1 = new DotIdExp(e1->loc, e1, ((TypeStruct *)t1)->sym->aliasthis->ident); + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + t1 = e1->type; + continue; + } + else if (t2->ty == Tstruct && ((TypeStruct *)t2)->sym->aliasthis) + { + e2 = new DotIdExp(e2->loc, e2, ((TypeStruct *)t2)->sym->aliasthis->ident); + e2 = e2->semantic(sc); + e2 = resolveProperties(sc, e2); + t2 = e2->type; + continue; + } + else + goto Lincompatible; + } + } + else if (t1->ty == Tstruct && t2->ty == Tstruct) + { + if (t1->mod != t2->mod) + { + if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) + goto Lincompatible; + unsigned char mod = MODmerge(t1->mod, t2->mod); + t1 = t1->castMod(mod); + t2 = t2->castMod(mod); + t = t1; + goto Lagain; + } + + TypeStruct *ts1 = (TypeStruct *)t1; + TypeStruct *ts2 = (TypeStruct *)t2; + if (ts1->sym != ts2->sym) + { + if (!ts1->sym->aliasthis && !ts2->sym->aliasthis) + goto Lincompatible; + + int i1 = 0; + int i2 = 0; + + Expression *e1b = NULL; + Expression *e2b = NULL; + if (ts2->sym->aliasthis) + { + e2b = new DotIdExp(e2->loc, e2, ts2->sym->aliasthis->ident); + e2b = e2b->semantic(sc); + e2b = resolveProperties(sc, e2b); + i1 = e2b->implicitConvTo(t1); + } + if (ts1->sym->aliasthis) + { + e1b = new DotIdExp(e1->loc, e1, ts1->sym->aliasthis->ident); + e1b = e1b->semantic(sc); + e1b = resolveProperties(sc, e1b); + i2 = e1b->implicitConvTo(t2); + } + if (i1 && i2) + goto Lincompatible; + + if (i1) + goto Lt1; + else if (i2) + goto Lt2; + + if (e1b) + { e1 = e1b; + t1 = e1b->type->toBasetype(); + } + if (e2b) + { e2 = e2b; + t2 = e2b->type->toBasetype(); + } + t = t1; + goto Lagain; + } + } + else if (t1->ty == Tstruct || t2->ty == Tstruct) + { + if (t1->ty == Tstruct && ((TypeStruct *)t1)->sym->aliasthis) + { + e1 = new DotIdExp(e1->loc, e1, ((TypeStruct *)t1)->sym->aliasthis->ident); + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + t1 = e1->type; + t = t1; + goto Lagain; + } + if (t2->ty == Tstruct && ((TypeStruct *)t2)->sym->aliasthis) + { + e2 = new DotIdExp(e2->loc, e2, ((TypeStruct *)t2)->sym->aliasthis->ident); + e2 = e2->semantic(sc); + e2 = resolveProperties(sc, e2); + t2 = e2->type; + t = t2; + goto Lagain; + } + goto Lincompatible; + } + else if ((e1->op == TOKstring || e1->op == TOKnull) && e1->implicitConvTo(t2)) + { + goto Lt2; + } + else if ((e2->op == TOKstring || e2->op == TOKnull) && e2->implicitConvTo(t1)) + { + goto Lt1; + } + else if (t1->ty == Tsarray && t2->ty == Tsarray && + e2->implicitConvTo(t1->nextOf()->arrayOf())) + { + Lx1: + t = t1->nextOf()->arrayOf(); // T[] + e1 = e1->castTo(sc, t); + e2 = e2->castTo(sc, t); + } + else if (t1->ty == Tsarray && t2->ty == Tsarray && + e1->implicitConvTo(t2->nextOf()->arrayOf())) + { + Lx2: + t = t2->nextOf()->arrayOf(); + e1 = e1->castTo(sc, t); + e2 = e2->castTo(sc, t); + } + else if (t1->ty == Tvector && t2->ty != Tvector && + e2->implicitConvTo(t1)) + { + e2 = e2->castTo(sc, t1); + t2 = t1; + goto Lagain; + } + else if (t2->ty == Tvector && t1->ty != Tvector && + e1->implicitConvTo(t2)) + { + e1 = e1->castTo(sc, t2); + t1 = t2; + goto Lagain; + } + else if (t1->isintegral() && t2->isintegral()) + { + assert(t1->ty == t2->ty); + if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) + goto Lincompatible; + unsigned char mod = MODmerge(t1->mod, t2->mod); + + t1 = t1->castMod(mod); + t2 = t2->castMod(mod); + t = t1; + e1 = e1->castTo(sc, t); + e2 = e2->castTo(sc, t); + goto Lagain; + } + else if (e1->isArrayOperand() && t1->ty == Tarray && + e2->implicitConvTo(t1->nextOf())) + { // T[] op T + e2 = e2->castTo(sc, t1->nextOf()); + t = t1->nextOf()->arrayOf(); + } + else if (e2->isArrayOperand() && t2->ty == Tarray && + e1->implicitConvTo(t2->nextOf())) + { // T op T[] + e1 = e1->castTo(sc, t2->nextOf()); + t = t2->nextOf()->arrayOf(); + + //printf("test %s\n", e->toChars()); + e1 = e1->optimize(WANTvalue); + if (e && e->isCommutative() && e1->isConst()) + { /* Swap operands to minimize number of functions generated + */ + //printf("swap %s\n", e->toChars()); + Expression *tmp = e1; + e1 = e2; + e2 = tmp; + } + } + else + { + Lincompatible: + return 0; + } +Lret: + if (!*pt) + *pt = t; + *pe1 = e1; + *pe2 = e2; +#if 0 + printf("-typeMerge() %s op %s\n", e1->toChars(), e2->toChars()); + if (e1->type) printf("\tt1 = %s\n", e1->type->toChars()); + if (e2->type) printf("\tt2 = %s\n", e2->type->toChars()); + printf("\ttype = %s\n", t->toChars()); +#endif + //dump(0); + return 1; + + +Lt1: + e2 = e2->castTo(sc, t1); + t = t1; + goto Lret; + +Lt2: + e1 = e1->castTo(sc, t2); + t = t2; + goto Lret; +} + +/************************************ + * Bring leaves to common type. + */ + +Expression *BinExp::typeCombine(Scope *sc) +{ + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + + if (op == TOKmin || op == TOKadd) + { + // struct+struct, and class+class are errors + if (t1->ty == Tstruct && t2->ty == Tstruct) + goto Lerror; + else if (t1->ty == Tclass && t2->ty == Tclass) + goto Lerror; + } + + if (!typeMerge(sc, this, &type, &e1, &e2)) + goto Lerror; + return this; + +Lerror: + incompatibleTypes(); + type = Type::terror; + e1 = new ErrorExp(); + e2 = new ErrorExp(); + return new ErrorExp(); +} + +/*********************************** + * Do integral promotions (convertchk). + * Don't convert to + */ + +Expression *Expression::integralPromotions(Scope *sc) +{ + Expression *e = this; + + //printf("integralPromotions %s %s\n", e->toChars(), e->type->toChars()); + switch (type->toBasetype()->ty) + { + case Tvoid: + error("void has no value"); + return new ErrorExp(); + + case Tint8: + case Tuns8: + case Tint16: + case Tuns16: + case Tbool: + case Tchar: + case Twchar: + e = e->castTo(sc, Type::tint32); + break; + + case Tdchar: + e = e->castTo(sc, Type::tuns32); + break; + } + return e; +} + +/*********************************** + * See if both types are arrays that can be compared + * for equality. Return !=0 if so. + * If they are arrays, but incompatible, issue error. + * This is to enable comparing things like an immutable + * array with a mutable one. + */ + +int arrayTypeCompatible(Loc loc, Type *t1, Type *t2) +{ + t1 = t1->toBasetype(); + t2 = t2->toBasetype(); + + if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && + (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer)) + { + if (t1->nextOf()->implicitConvTo(t2->nextOf()) < MATCHconst && + t2->nextOf()->implicitConvTo(t1->nextOf()) < MATCHconst && + (t1->nextOf()->ty != Tvoid && t2->nextOf()->ty != Tvoid)) + { + error(loc, "array equality comparison type mismatch, %s vs %s", t1->toChars(), t2->toChars()); + } + return 1; + } + return 0; +} + +/*********************************** + * See if both types are arrays that can be compared + * for equality without any casting. Return !=0 if so. + * This is to enable comparing things like an immutable + * array with a mutable one. + */ +int arrayTypeCompatibleWithoutCasting(Loc loc, Type *t1, Type *t2) +{ + t1 = t1->toBasetype(); + t2 = t2->toBasetype(); + + if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && + t2->ty == t1->ty) + { + if (t1->nextOf()->implicitConvTo(t2->nextOf()) >= MATCHconst || + t2->nextOf()->implicitConvTo(t1->nextOf()) >= MATCHconst) + return 1; + } + return 0; +} + + +/******************************************************************/ + +/* Determine the integral ranges of an expression. + * This is used to determine if implicit narrowing conversions will + * be allowed. + */ + +uinteger_t getMask(uinteger_t v) +{ + // Ref: http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v |= v >> 32; + return v /* | 0xff*/; +} +IntRange Expression::getIntRange() +{ + return IntRange::fromType(type) DUMP; +} + +IntRange IntegerExp::getIntRange() +{ + return IntRange(value).cast(type) DUMP; +} + +IntRange CastExp::getIntRange() +{ + return e1->getIntRange().cast(type) DUMP; +} + +IntRange AddExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + return IntRange(ir1.imin + ir2.imin, ir1.imax + ir2.imax).cast(type) DUMP; +} + +IntRange MinExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + return IntRange(ir1.imin - ir2.imax, ir1.imax - ir2.imin).cast(type) DUMP; +} + +IntRange DivExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + // Should we ignore the possibility of div-by-0??? + if (ir2.containsZero()) + return Expression::getIntRange() DUMP; + + // [a,b] / [c,d] = [min (a/c, a/d, b/c, b/d), max (a/c, a/d, b/c, b/d)] + SignExtendedNumber bdy[4] = { + ir1.imin / ir2.imin, + ir1.imin / ir2.imax, + ir1.imax / ir2.imin, + ir1.imax / ir2.imax + }; + return IntRange::fromNumbers4(bdy).cast(type) DUMP; +} + +IntRange MulExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + // [a,b] * [c,d] = [min (ac, ad, bc, bd), max (ac, ad, bc, bd)] + SignExtendedNumber bdy[4] = { + ir1.imin * ir2.imin, + ir1.imin * ir2.imax, + ir1.imax * ir2.imin, + ir1.imax * ir2.imax + }; + return IntRange::fromNumbers4(bdy).cast(type) DUMP; +} + +IntRange ModExp::getIntRange() +{ + IntRange irNum = e1->getIntRange(); + IntRange irDen = e2->getIntRange().absNeg(); + + /* + due to the rules of D (C)'s % operator, we need to consider the cases + separately in different range of signs. + + case 1. [500, 1700] % [7, 23] (numerator is always positive) + = [0, 22] + case 2. [-500, 1700] % [7, 23] (numerator can be negative) + = [-22, 22] + case 3. [-1700, -500] % [7, 23] (numerator is always negative) + = [-22, 0] + + the number 22 is the maximum absolute value in the denomator's range. We + don't care about divide by zero. + */ + + // Modding on 0 is invalid anyway. + if (!irDen.imin.negative) + return Expression::getIntRange() DUMP; + + ++ irDen.imin; + irDen.imax = -irDen.imin; + + if (!irNum.imin.negative) + irNum.imin.value = 0; + else if (irNum.imin < irDen.imin) + irNum.imin = irDen.imin; + + if (irNum.imax.negative) + { + irNum.imax.negative = false; + irNum.imax.value = 0; + } + else if (irNum.imax > irDen.imax) + irNum.imax = irDen.imax; + + return irNum.cast(type) DUMP; +} + +// The algorithms for &, |, ^ are not yet the best! Sometimes they will produce +// not the tightest bound. See +// https://github.com/D-Programming-Language/dmd/pull/116 +// for detail. +static IntRange unsignedBitwiseAnd(const IntRange& a, const IntRange& b) +{ + // the DiffMasks stores the mask of bits which are variable in the range. + uinteger_t aDiffMask = getMask(a.imin.value ^ a.imax.value); + uinteger_t bDiffMask = getMask(b.imin.value ^ b.imax.value); + // Since '&' computes the digitwise-minimum, the we could set all varying + // digits to 0 to get a lower bound, and set all varying digits to 1 to get + // an upper bound. + IntRange result; + result.imin.value = (a.imin.value & ~aDiffMask) & (b.imin.value & ~bDiffMask); + result.imax.value = (a.imax.value | aDiffMask) & (b.imax.value | bDiffMask); + // Sometimes the upper bound is overestimated. The upper bound will never + // exceed the input. + if (result.imax.value > a.imax.value) + result.imax.value = a.imax.value; + if (result.imax.value > b.imax.value) + result.imax.value = b.imax.value; + result.imin.negative = result.imax.negative = a.imin.negative && b.imin.negative; + return result; +} +static IntRange unsignedBitwiseOr(const IntRange& a, const IntRange& b) +{ + // the DiffMasks stores the mask of bits which are variable in the range. + uinteger_t aDiffMask = getMask(a.imin.value ^ a.imax.value); + uinteger_t bDiffMask = getMask(b.imin.value ^ b.imax.value); + // The imax algorithm by Adam D. Ruppe. + // http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D&artnum=108796 + IntRange result; + result.imin.value = (a.imin.value & ~aDiffMask) | (b.imin.value & ~bDiffMask); + result.imax.value = a.imax.value | b.imax.value | getMask(a.imax.value & b.imax.value); + // Sometimes the lower bound is underestimated. The lower bound will never + // less than the input. + if (result.imin.value < a.imin.value) + result.imin.value = a.imin.value; + if (result.imin.value < b.imin.value) + result.imin.value = b.imin.value; + result.imin.negative = result.imax.negative = a.imin.negative || b.imin.negative; + return result; +} +static IntRange unsignedBitwiseXor(const IntRange& a, const IntRange& b) +{ + // the DiffMasks stores the mask of bits which are variable in the range. + uinteger_t aDiffMask = getMask(a.imin.value ^ a.imax.value); + uinteger_t bDiffMask = getMask(b.imin.value ^ b.imax.value); + IntRange result; + result.imin.value = (a.imin.value ^ b.imin.value) & ~(aDiffMask | bDiffMask); + result.imax.value = (a.imax.value ^ b.imax.value) | (aDiffMask | bDiffMask); + result.imin.negative = result.imax.negative = a.imin.negative != b.imin.negative; + return result; +} + + +IntRange AndExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + IntRange ir1neg, ir1pos, ir2neg, ir2pos; + bool has1neg, has1pos, has2neg, has2pos; + + ir1.splitBySign(ir1neg, has1neg, ir1pos, has1pos); + ir2.splitBySign(ir2neg, has2neg, ir2pos, has2pos); + + IntRange result; + bool hasResult = false; + if (has1pos && has2pos) + result.unionOrAssign(unsignedBitwiseAnd(ir1pos, ir2pos), /*ref*/hasResult); + if (has1pos && has2neg) + result.unionOrAssign(unsignedBitwiseAnd(ir1pos, ir2neg), /*ref*/hasResult); + if (has1neg && has2pos) + result.unionOrAssign(unsignedBitwiseAnd(ir1neg, ir2pos), /*ref*/hasResult); + if (has1neg && has2neg) + result.unionOrAssign(unsignedBitwiseAnd(ir1neg, ir2neg), /*ref*/hasResult); + assert(hasResult); + return result.cast(type) DUMP; +} + +IntRange OrExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + IntRange ir1neg, ir1pos, ir2neg, ir2pos; + bool has1neg, has1pos, has2neg, has2pos; + + ir1.splitBySign(ir1neg, has1neg, ir1pos, has1pos); + ir2.splitBySign(ir2neg, has2neg, ir2pos, has2pos); + + IntRange result; + bool hasResult = false; + if (has1pos && has2pos) + result.unionOrAssign(unsignedBitwiseOr(ir1pos, ir2pos), /*ref*/hasResult); + if (has1pos && has2neg) + result.unionOrAssign(unsignedBitwiseOr(ir1pos, ir2neg), /*ref*/hasResult); + if (has1neg && has2pos) + result.unionOrAssign(unsignedBitwiseOr(ir1neg, ir2pos), /*ref*/hasResult); + if (has1neg && has2neg) + result.unionOrAssign(unsignedBitwiseOr(ir1neg, ir2neg), /*ref*/hasResult); + + assert(hasResult); + return result.cast(type) DUMP; +} + +IntRange XorExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + IntRange ir1neg, ir1pos, ir2neg, ir2pos; + bool has1neg, has1pos, has2neg, has2pos; + + ir1.splitBySign(ir1neg, has1neg, ir1pos, has1pos); + ir2.splitBySign(ir2neg, has2neg, ir2pos, has2pos); + + IntRange result; + bool hasResult = false; + if (has1pos && has2pos) + result.unionOrAssign(unsignedBitwiseXor(ir1pos, ir2pos), /*ref*/hasResult); + if (has1pos && has2neg) + result.unionOrAssign(unsignedBitwiseXor(ir1pos, ir2neg), /*ref*/hasResult); + if (has1neg && has2pos) + result.unionOrAssign(unsignedBitwiseXor(ir1neg, ir2pos), /*ref*/hasResult); + if (has1neg && has2neg) + result.unionOrAssign(unsignedBitwiseXor(ir1neg, ir2neg), /*ref*/hasResult); + + assert(hasResult); + return result.cast(type) DUMP; +} + +IntRange ShlExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + if (ir2.imin.negative) + ir2 = IntRange(SignExtendedNumber(0), SignExtendedNumber(64)); + + SignExtendedNumber lower = ir1.imin << (ir1.imin.negative ? ir2.imax : ir2.imin); + SignExtendedNumber upper = ir1.imax << (ir1.imax.negative ? ir2.imin : ir2.imax); + + return IntRange(lower, upper).cast(type) DUMP; +} + +IntRange ShrExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange(); + IntRange ir2 = e2->getIntRange(); + + if (ir2.imin.negative) + ir2 = IntRange(SignExtendedNumber(0), SignExtendedNumber(64)); + + SignExtendedNumber lower = ir1.imin >> (ir1.imin.negative ? ir2.imin : ir2.imax); + SignExtendedNumber upper = ir1.imax >> (ir1.imax.negative ? ir2.imax : ir2.imin); + + return IntRange(lower, upper).cast(type) DUMP; +} + +IntRange UshrExp::getIntRange() +{ + IntRange ir1 = e1->getIntRange().castUnsigned(e1->type); + IntRange ir2 = e2->getIntRange(); + + if (ir2.imin.negative) + ir2 = IntRange(SignExtendedNumber(0), SignExtendedNumber(64)); + + return IntRange(ir1.imin >> ir2.imax, ir1.imax >> ir2.imin).cast(type) DUMP; + +} + +IntRange CommaExp::getIntRange() +{ + return e2->getIntRange() DUMP; +} + +IntRange ComExp::getIntRange() +{ + IntRange ir = e1->getIntRange(); + return IntRange(SignExtendedNumber(~ir.imax.value, !ir.imax.negative), + SignExtendedNumber(~ir.imin.value, !ir.imin.negative)).cast(type) DUMP; +} + +IntRange NegExp::getIntRange() +{ + IntRange ir = e1->getIntRange(); + return IntRange(-ir.imax, -ir.imin).cast(type) DUMP; +} + diff --git a/class.c b/class.c new file mode 100644 index 00000000..4121946d --- /dev/null +++ b/class.c @@ -0,0 +1,1648 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "root.h" +#include "rmem.h" + +#include "enum.h" +#include "init.h" +#include "attrib.h" +#include "declaration.h" +#include "aggregate.h" +#include "id.h" +#include "mtype.h" +#include "scope.h" +#include "module.h" +#include "expression.h" +#include "statement.h" + +/********************************* ClassDeclaration ****************************/ + +ClassDeclaration *ClassDeclaration::classinfo; +ClassDeclaration *ClassDeclaration::object; +ClassDeclaration *ClassDeclaration::throwable; +ClassDeclaration *ClassDeclaration::exception; +ClassDeclaration *ClassDeclaration::errorException; + +ClassDeclaration::ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses) + : AggregateDeclaration(loc, id) +{ + static char msg[] = "only object.d can define this reserved class name"; + + if (baseclasses) + // Actually, this is a transfer + this->baseclasses = baseclasses; + else + this->baseclasses = new BaseClasses(); + baseClass = NULL; + + interfaces_dim = 0; + interfaces = NULL; + + vtblInterfaces = NULL; + + //printf("ClassDeclaration(%s), dim = %d\n", id->toChars(), this->baseclasses->dim); + + // For forward references + type = new TypeClass(this); + handle = type; + + staticCtor = NULL; + staticDtor = NULL; + + vtblsym = NULL; + vclassinfo = NULL; + + if (id) + { // Look for special class names + + if (id == Id::__sizeof || id == Id::__xalignof || id == Id::mangleof) + error("illegal class name"); + + // BUG: What if this is the wrong TypeInfo, i.e. it is nested? + if (id->toChars()[0] == 'T') + { + if (id == Id::TypeInfo) + { if (Type::typeinfo) + Type::typeinfo->error("%s", msg); + Type::typeinfo = this; + } + + if (id == Id::TypeInfo_Class) + { if (Type::typeinfoclass) + Type::typeinfoclass->error("%s", msg); + Type::typeinfoclass = this; + } + + if (id == Id::TypeInfo_Interface) + { if (Type::typeinfointerface) + Type::typeinfointerface->error("%s", msg); + Type::typeinfointerface = this; + } + + if (id == Id::TypeInfo_Struct) + { if (Type::typeinfostruct) + Type::typeinfostruct->error("%s", msg); + Type::typeinfostruct = this; + } + + if (id == Id::TypeInfo_Typedef) + { if (Type::typeinfotypedef) + Type::typeinfotypedef->error("%s", msg); + Type::typeinfotypedef = this; + } + + if (id == Id::TypeInfo_Pointer) + { if (Type::typeinfopointer) + Type::typeinfopointer->error("%s", msg); + Type::typeinfopointer = this; + } + + if (id == Id::TypeInfo_Array) + { if (Type::typeinfoarray) + Type::typeinfoarray->error("%s", msg); + Type::typeinfoarray = this; + } + + if (id == Id::TypeInfo_StaticArray) + { //if (Type::typeinfostaticarray) + //Type::typeinfostaticarray->error("%s", msg); + Type::typeinfostaticarray = this; + } + + if (id == Id::TypeInfo_AssociativeArray) + { if (Type::typeinfoassociativearray) + Type::typeinfoassociativearray->error("%s", msg); + Type::typeinfoassociativearray = this; + } + + if (id == Id::TypeInfo_Enum) + { if (Type::typeinfoenum) + Type::typeinfoenum->error("%s", msg); + Type::typeinfoenum = this; + } + + if (id == Id::TypeInfo_Function) + { if (Type::typeinfofunction) + Type::typeinfofunction->error("%s", msg); + Type::typeinfofunction = this; + } + + if (id == Id::TypeInfo_Delegate) + { if (Type::typeinfodelegate) + Type::typeinfodelegate->error("%s", msg); + Type::typeinfodelegate = this; + } + + if (id == Id::TypeInfo_Tuple) + { if (Type::typeinfotypelist) + Type::typeinfotypelist->error("%s", msg); + Type::typeinfotypelist = this; + } + +#if DMDV2 + if (id == Id::TypeInfo_Const) + { if (Type::typeinfoconst) + Type::typeinfoconst->error("%s", msg); + Type::typeinfoconst = this; + } + + if (id == Id::TypeInfo_Invariant) + { if (Type::typeinfoinvariant) + Type::typeinfoinvariant->error("%s", msg); + Type::typeinfoinvariant = this; + } + + if (id == Id::TypeInfo_Shared) + { if (Type::typeinfoshared) + Type::typeinfoshared->error("%s", msg); + Type::typeinfoshared = this; + } + + if (id == Id::TypeInfo_Wild) + { if (Type::typeinfowild) + Type::typeinfowild->error("%s", msg); + Type::typeinfowild = this; + } +#endif + } + + if (id == Id::Object) + { if (object) + object->error("%s", msg); + object = this; + } + + if (id == Id::Throwable) + { if (throwable) + throwable->error("%s", msg); + throwable = this; + } + + if (id == Id::Exception) + { if (exception) + exception->error("%s", msg); + exception = this; + } + + if (id == Id::Error) + { if (errorException) + errorException->error("%s", msg); + errorException = this; + } + + //if (id == Id::ClassInfo) + if (id == Id::TypeInfo_Class) + { if (classinfo) + classinfo->error("%s", msg); + classinfo = this; + } + + if (id == Id::ModuleInfo) + { if (Module::moduleinfo) + Module::moduleinfo->error("%s", msg); + Module::moduleinfo = this; + } + } + + com = 0; + isscope = 0; + isabstract = 0; + inuse = 0; +} + +Dsymbol *ClassDeclaration::syntaxCopy(Dsymbol *s) +{ + ClassDeclaration *cd; + + //printf("ClassDeclaration::syntaxCopy('%s')\n", toChars()); + if (s) + cd = (ClassDeclaration *)s; + else + cd = new ClassDeclaration(loc, ident, NULL); + + cd->storage_class |= storage_class; + + cd->baseclasses->setDim(this->baseclasses->dim); + for (size_t i = 0; i < cd->baseclasses->dim; i++) + { + BaseClass *b = this->baseclasses->tdata()[i]; + BaseClass *b2 = new BaseClass(b->type->syntaxCopy(), b->protection); + cd->baseclasses->tdata()[i] = b2; + } + + ScopeDsymbol::syntaxCopy(cd); + return cd; +} + +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 + methods.setDim(0); +#endif + + int errors = global.gaggedErrors; + + if (sc->stc & STCdeprecated) + { + isdeprecated = true; + } + + 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->tdata()[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->tdata()[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 = 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 == 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 = baseclasses->tdata()[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 = true; + + tc->checkDeprecated(loc, sc); + } + } + + // Check for duplicate interfaces + for (size_t j = (baseClass ? 1 : 0); j < i; j++) + { + BaseClass *b2 = baseclasses->tdata()[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 = 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 == 0) + { + interfaceSemantic(sc); + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[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 = 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; + + if (storage_class & STCimmutable) + type = type->addMod(MODimmutable); + if (storage_class & STCconst) + type = type->addMod(MODconst); + if (storage_class & STCshared) + type = type->addMod(MODshared); + + 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 _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 = members->tdata()[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 = members->tdata()[i]; + s->semantic(sc); + } + + if (global.gag && global.gaggedErrors != errors) + { // The type is no good, yet the error messages were gagged. + type = Type::terror; + } + + if (sizeok == 2) // failed due to forward references + { // semantic() failed due to 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()); + Type *tf = new TypeFunction(NULL, NULL, 0, LINKd, 0); + CtorDeclaration *ctor = new CtorDeclaration(loc, 0, 0, tf); + 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 = vtblInterfaces->tdata()[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 = vtblInterfaces->tdata()[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); + } +} + +void ClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (!isAnonymous()) + { + buf->printf("%s ", kind()); + buf->writestring(toChars()); + if (baseclasses->dim) + buf->writestring(" : "); + } + for (size_t i = 0; i < baseclasses->dim; i++) + { + BaseClass *b = baseclasses->tdata()[i]; + + if (i) + buf->writeByte(','); + //buf->writestring(b->base->ident->toChars()); + b->type->toCBuffer(buf, NULL, hgs); + } + if (members) + { + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + + buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + buf->writestring("}"); + } + else + buf->writeByte(';'); + buf->writenl(); +} + +#if 0 +void ClassDeclaration::defineRef(Dsymbol *s) +{ + ClassDeclaration *cd; + + AggregateDeclaration::defineRef(s); + cd = s->isClassDeclaration(); + baseType = cd->baseType; + cd->baseType = NULL; +} +#endif + +/********************************************* + * Determine if 'this' is a base class of cd. + * This is used to detect circular inheritance only. + */ + +int ClassDeclaration::isBaseOf2(ClassDeclaration *cd) +{ + if (!cd) + return 0; + //printf("ClassDeclaration::isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd->toChars()); + for (size_t i = 0; i < cd->baseclasses->dim; i++) + { BaseClass *b = cd->baseclasses->tdata()[i]; + + if (b->base == this || isBaseOf2(b->base)) + return 1; + } + return 0; +} + +/******************************************* + * Determine if 'this' is a base class of cd. + */ + +int ClassDeclaration::isBaseOf(ClassDeclaration *cd, int *poffset) +{ + //printf("ClassDeclaration::isBaseOf(this = '%s', cd = '%s')\n", toChars(), cd->toChars()); + if (poffset) + *poffset = 0; + while (cd) + { + /* cd->baseClass might not be set if cd is forward referenced. + */ + if (!cd->baseClass && cd->baseclasses->dim && !cd->isInterfaceDeclaration()) + { + cd->semantic(NULL); + if (!cd->baseClass) + cd->error("base class is forward referenced by %s", toChars()); + } + + if (this == cd->baseClass) + return 1; + + cd = cd->baseClass; + } + return 0; +} + +/********************************************* + * Determine if 'this' has complete base class information. + * This is used to detect forward references in covariant overloads. + */ + +int ClassDeclaration::isBaseInfoComplete() +{ + if (!baseClass) + return ident == Id::Object; + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *b = baseclasses->tdata()[i]; + if (!b->base || !b->base->isBaseInfoComplete()) + return 0; + } + return 1; +} + +Dsymbol *ClassDeclaration::search(Loc loc, Identifier *ident, int flags) +{ + Dsymbol *s; + //printf("%s.ClassDeclaration::search('%s')\n", toChars(), ident->toChars()); + + if (scope && !symtab) + { Scope *sc = scope; + sc->mustsemantic++; + semantic(sc); + sc->mustsemantic--; + } + + if (!members || !symtab) + { + error("is forward referenced when looking for '%s'", ident->toChars()); + //*(char*)0=0; + return NULL; + } + + s = ScopeDsymbol::search(loc, ident, flags); + if (!s) + { + // Search bases classes in depth-first, left to right order + + for (size_t i = 0; i < baseclasses->dim; i++) + { + BaseClass *b = baseclasses->tdata()[i]; + + if (b->base) + { + if (!b->base->symtab) + error("base %s is forward referenced", b->base->ident->toChars()); + else + { + s = b->base->search(loc, ident, flags); + if (s == this) // happens if s is nested in this and derives from this + s = NULL; + else if (s) + break; + } + } + } + } + return s; +} + +Dsymbol *ClassDeclaration::searchBase(Loc loc, Identifier *ident) +{ + // Search bases classes in depth-first, left to right order + + for (size_t i = 0; i < baseclasses->dim; i++) + { + BaseClass *b = (*baseclasses)[i]; + Dsymbol *cdb = b->type->isClassHandle(); + if (cdb->ident->equals(ident)) + return cdb; + cdb = ((ClassDeclaration *)cdb)->searchBase(loc, ident); + if (cdb) + return cdb; + } + return NULL; +} + +/********************************************************** + * fd is in the vtbl[] for this class. + * Return 1 if function is hidden (not findable through search). + */ + +#if DMDV2 +int isf(void *param, FuncDeclaration *fd) +{ + //printf("param = %p, fd = %p %s\n", param, fd, fd->toChars()); + return param == fd; +} + +int ClassDeclaration::isFuncHidden(FuncDeclaration *fd) +{ + //printf("ClassDeclaration::isFuncHidden(class = %s, fd = %s)\n", toChars(), fd->toChars()); + Dsymbol *s = search(0, fd->ident, 4|2); + if (!s) + { //printf("not found\n"); + /* Because, due to a hack, if there are multiple definitions + * of fd->ident, NULL is returned. + */ + return 0; + } + s = s->toAlias(); + OverloadSet *os = s->isOverloadSet(); + if (os) + { + for (size_t i = 0; i < os->a.dim; i++) + { Dsymbol *s2 = os->a.tdata()[i]; + FuncDeclaration *f2 = s2->isFuncDeclaration(); + if (f2 && overloadApply(f2, &isf, fd)) + return 0; + } + return 1; + } + else + { + FuncDeclaration *fdstart = s->isFuncDeclaration(); + //printf("%s fdstart = %p\n", s->kind(), fdstart); + if (overloadApply(fdstart, &isf, fd)) + return 0; + + return !fd->parent->isTemplateMixin(); + } +} +#endif + +/**************** + * Find virtual function matching identifier and type. + * Used to build virtual function tables for interface implementations. + */ + +FuncDeclaration *ClassDeclaration::findFunc(Identifier *ident, TypeFunction *tf) +{ + //printf("ClassDeclaration::findFunc(%s, %s) %s\n", ident->toChars(), tf->toChars(), toChars()); + FuncDeclaration *fdmatch = NULL; + FuncDeclaration *fdambig = NULL; + + ClassDeclaration *cd = this; + Dsymbols *vtbl = &cd->vtbl; + while (1) + { + for (size_t i = 0; i < vtbl->dim; i++) + { + FuncDeclaration *fd = vtbl->tdata()[i]->isFuncDeclaration(); + if (!fd) + continue; // the first entry might be a ClassInfo + + //printf("\t[%d] = %s\n", i, fd->toChars()); + if (ident == fd->ident && + fd->type->covariant(tf) == 1) + { //printf("fd->parent->isClassDeclaration() = %p", fd->parent->isClassDeclaration()); + if (!fdmatch) + goto Lfd; + + { + // Function type matcing: exact > covariant + int m1 = tf->equals(fd ->type) ? MATCHexact : MATCHnomatch; + int m2 = tf->equals(fdmatch->type) ? MATCHexact : MATCHnomatch; + if (m1 > m2) + goto Lfd; + else if (m1 < m2) + goto Lfdmatch; + } + + { + // The way of definition: non-mixin > mixin + int m1 = fd ->parent->isClassDeclaration() ? MATCHexact : MATCHnomatch; + int m2 = fdmatch->parent->isClassDeclaration() ? MATCHexact : MATCHnomatch; + if (m1 > m2) + goto Lfd; + else if (m1 < m2) + goto Lfdmatch; + } + + Lambig: + fdambig = fd; + //printf("Lambig fdambig = %s %s [%s]\n", fdambig->toChars(), fdambig->type->toChars(), fdambig->loc.toChars()); + continue; + + Lfd: + fdmatch = fd, fdambig = NULL; + //printf("Lfd fdmatch = %s %s [%s]\n", fdmatch->toChars(), fdmatch->type->toChars(), fdmatch->loc.toChars()); + continue; + + Lfdmatch: + continue; + } + //else printf("\t\t%d\n", fd->type->covariant(tf)); + } + if (!cd) + break; + vtbl = &cd->vtblFinal; + cd = cd->baseClass; + } + + if (fdambig) + error("ambiguous virtual function %s", fdambig->toChars()); + return fdmatch; +} + +void ClassDeclaration::interfaceSemantic(Scope *sc) +{ + InterfaceDeclaration *id = isInterfaceDeclaration(); + + vtblInterfaces = new BaseClasses(); + vtblInterfaces->reserve(interfaces_dim); + + for (size_t i = 0; i < interfaces_dim; i++) + { + BaseClass *b = interfaces[i]; + + // If this is an interface, and it derives from a COM interface, + // then this is a COM interface too. + if (b->base->isCOMinterface()) + com = 1; + + if (b->base->isCPPinterface() && id) + id->cpp = 1; + + vtblInterfaces->push(b); + b->copyBaseInterfaces(vtblInterfaces); + } +} + +/**************************************** + */ + +int ClassDeclaration::isCOMclass() +{ + return com; +} + +int ClassDeclaration::isCOMinterface() +{ + return 0; +} + +#if DMDV2 +int ClassDeclaration::isCPPinterface() +{ + return 0; +} +#endif + + +/**************************************** + */ + +int ClassDeclaration::isAbstract() +{ + if (isabstract) + return TRUE; + for (size_t i = 1; i < vtbl.dim; i++) + { + FuncDeclaration *fd = vtbl.tdata()[i]->isFuncDeclaration(); + + //printf("\tvtbl[%d] = %p\n", i, fd); + if (!fd || fd->isAbstract()) + { + isabstract |= 1; + return TRUE; + } + } + return FALSE; +} + + +/**************************************** + * Determine if slot 0 of the vtbl[] is reserved for something else. + * For class objects, yes, this is where the classinfo ptr goes. + * For COM interfaces, no. + * For non-COM interfaces, yes, this is where the Interface ptr goes. + */ + +int ClassDeclaration::vtblOffset() +{ + return 1; +} + +/**************************************** + */ + +const char *ClassDeclaration::kind() +{ + return "class"; +} + +/**************************************** + */ + +void ClassDeclaration::addLocalClass(ClassDeclarations *aclasses) +{ + aclasses->push(this); +} + +/********************************* InterfaceDeclaration ****************************/ + +InterfaceDeclaration::InterfaceDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses) + : ClassDeclaration(loc, id, baseclasses) +{ + com = 0; + cpp = 0; + if (id == Id::IUnknown) // IUnknown is the root of all COM interfaces + { com = 1; + cpp = 1; // IUnknown is also a C++ interface + } +} + +Dsymbol *InterfaceDeclaration::syntaxCopy(Dsymbol *s) +{ + InterfaceDeclaration *id; + + if (s) + id = (InterfaceDeclaration *)s; + else + id = new InterfaceDeclaration(loc, ident, NULL); + + ClassDeclaration::syntaxCopy(id); + return id; +} + +void InterfaceDeclaration::semantic(Scope *sc) +{ + //printf("InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type); + if (inuse) + return; + + 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("\tinterface '%s' is forward referenced\n", toChars()); + return; + } + if (symtab) // if already done + { if (!scope) + return; + } + else + symtab = new DsymbolTable(); + + Scope *scx = NULL; + if (scope) + { sc = scope; + scx = scope; // save so we don't make redundant copies + scope = NULL; + } + + int errors = global.gaggedErrors; + + if (sc->stc & STCdeprecated) + { + isdeprecated = true; + } + + // Expand any tuples in baseclasses[] + for (size_t i = 0; i < baseclasses->dim; ) + { BaseClass *b = baseclasses->tdata()[0]; + 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++; + } + + if (!baseclasses->dim && sc->linkage == LINKcpp) + cpp = 1; + + // Check for errors, handle forward references + for (size_t i = 0; i < baseclasses->dim; ) + { TypeClass *tc; + BaseClass *b; + Type *tb; + + b = baseclasses->tdata()[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 + { + // Check for duplicate interfaces + for (size_t j = 0; j < i; j++) + { + BaseClass *b2 = baseclasses->tdata()[j]; + if (b2->base == tc->sym) + error("inherits from duplicate interface %s", b2->base->toChars()); + } + + b->base = tc->sym; + if (b->base == this || isBaseOf2(b->base)) + { + error("circular inheritance of interface"); + baseclasses->remove(i); + continue; + } + if (!b->base->symtab) + { // Try to resolve forward reference + if (sc->mustsemantic && b->base->scope) + b->base->semantic(NULL); + } + if (!b->base->symtab || b->base->scope || b->base->inuse) + { + //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", b->base->toChars()); + scope = scx ? scx : new Scope(*sc); + scope->setNoFree(); + scope->module->addDeferredSemantic(this); + return; + } + } +#if 0 + // Inherit const/invariant from base class + storage_class |= b->base->storage_class & STC_TYPECTOR; +#endif + i++; + } + + interfaces_dim = baseclasses->dim; + interfaces = baseclasses->tdata(); + + interfaceSemantic(sc); + + if (vtblOffset()) + vtbl.push(this); // leave room at vtbl[0] for classinfo + + // Cat together the vtbl[]'s from base interfaces + for (size_t i = 0; i < interfaces_dim; i++) + { BaseClass *b = interfaces[i]; + + // Skip if b has already appeared + for (int k = 0; k < i; k++) + { + if (b == interfaces[k]) + goto Lcontinue; + } + + // Copy vtbl[] from base class + if (b->base->vtblOffset()) + { int d = b->base->vtbl.dim; + if (d > 1) + { + vtbl.reserve(d - 1); + for (int j = 1; j < d; j++) + vtbl.push(b->base->vtbl.tdata()[j]); + } + } + else + { + vtbl.append(&b->base->vtbl); + } + + Lcontinue: + ; + } + + protection = sc->protection; + storage_class |= sc->stc & STC_TYPECTOR; + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->addMember(sc, this, 1); + } + + sc = sc->push(this); + sc->stc &= STCsafe | STCtrusted | STCsystem; + sc->parent = this; + if (isCOMinterface()) + sc->linkage = LINKwindows; + else if (isCPPinterface()) + sc->linkage = LINKcpp; + sc->structalign = 8; + sc->protection = PROTpublic; + sc->explicitProtection = 0; + structalign = sc->structalign; + sc->offset = PTRSIZE * 2; + inuse++; + + /* 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)) + { + //printf("setScope %s %s\n", s->kind(), s->toChars()); + s->setScope(sc); + } + } + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic(sc); + } + + if (global.gag && global.gaggedErrors != errors) + { // The type is no good, yet the error messages were gagged. + type = Type::terror; + } + + inuse--; + //members->print(); + sc->pop(); + //printf("-InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type); +} + + +/******************************************* + * Determine if 'this' is a base class of cd. + * (Actually, if it is an interface supported by cd) + * Output: + * *poffset offset to start of class + * OFFSET_RUNTIME must determine offset at runtime + * Returns: + * 0 not a base + * 1 is a base + */ + +int InterfaceDeclaration::isBaseOf(ClassDeclaration *cd, int *poffset) +{ + unsigned j; + + //printf("%s.InterfaceDeclaration::isBaseOf(cd = '%s')\n", toChars(), cd->toChars()); + assert(!baseClass); + for (j = 0; j < cd->interfaces_dim; j++) + { + BaseClass *b = cd->interfaces[j]; + + //printf("\tbase %s\n", b->base->toChars()); + if (this == b->base) + { + //printf("\tfound at offset %d\n", b->offset); + if (poffset) + { *poffset = b->offset; + if (j && cd->isInterfaceDeclaration()) + *poffset = OFFSET_RUNTIME; + } + return 1; + } + if (isBaseOf(b, poffset)) + { if (j && poffset && cd->isInterfaceDeclaration()) + *poffset = OFFSET_RUNTIME; + return 1; + } + } + + if (cd->baseClass && isBaseOf(cd->baseClass, poffset)) + return 1; + + if (poffset) + *poffset = 0; + return 0; +} + + +int InterfaceDeclaration::isBaseOf(BaseClass *bc, int *poffset) +{ + //printf("%s.InterfaceDeclaration::isBaseOf(bc = '%s')\n", toChars(), bc->base->toChars()); + for (unsigned j = 0; j < bc->baseInterfaces_dim; j++) + { + BaseClass *b = &bc->baseInterfaces[j]; + + if (this == b->base) + { + if (poffset) + { *poffset = b->offset; + if (j && bc->base->isInterfaceDeclaration()) + *poffset = OFFSET_RUNTIME; + } + return 1; + } + if (isBaseOf(b, poffset)) + { if (j && poffset && bc->base->isInterfaceDeclaration()) + *poffset = OFFSET_RUNTIME; + return 1; + } + } + if (poffset) + *poffset = 0; + return 0; +} + +/********************************************* + * Determine if 'this' has clomplete base class information. + * This is used to detect forward references in covariant overloads. + */ + +int InterfaceDeclaration::isBaseInfoComplete() +{ + assert(!baseClass); + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *b = baseclasses->tdata()[i]; + if (!b->base || !b->base->isBaseInfoComplete ()) + return 0; + } + return 1; +} + +/**************************************** + * Determine if slot 0 of the vtbl[] is reserved for something else. + * For class objects, yes, this is where the ClassInfo ptr goes. + * For COM interfaces, no. + * For non-COM interfaces, yes, this is where the Interface ptr goes. + */ + +int InterfaceDeclaration::vtblOffset() +{ + if (isCOMinterface() || isCPPinterface()) + return 0; + return 1; +} + +int InterfaceDeclaration::isCOMinterface() +{ + return com; +} + +#if DMDV2 +int InterfaceDeclaration::isCPPinterface() +{ + return cpp; +} +#endif + +/******************************************* + */ + +const char *InterfaceDeclaration::kind() +{ + return "interface"; +} + + +/******************************** BaseClass *****************************/ + +BaseClass::BaseClass() +{ + memset(this, 0, sizeof(BaseClass)); +} + +BaseClass::BaseClass(Type *type, enum PROT protection) +{ + //printf("BaseClass(this = %p, '%s')\n", this, type->toChars()); + this->type = type; + this->protection = protection; + base = NULL; + offset = 0; + + baseInterfaces_dim = 0; + baseInterfaces = NULL; +} + +/**************************************** + * Fill in vtbl[] for base class based on member functions of class cd. + * Input: + * vtbl if !=NULL, fill it in + * newinstance !=0 means all entries must be filled in by members + * of cd, not members of any base classes of cd. + * Returns: + * !=0 if any entries were filled in by members of cd (not exclusively + * by base classes) + */ + +int BaseClass::fillVtbl(ClassDeclaration *cd, FuncDeclarations *vtbl, int newinstance) +{ + ClassDeclaration *id = base; + int result = 0; + + //printf("BaseClass::fillVtbl(this='%s', cd='%s')\n", base->toChars(), cd->toChars()); + if (vtbl) + vtbl->setDim(base->vtbl.dim); + + // first entry is ClassInfo reference + for (size_t j = base->vtblOffset(); j < base->vtbl.dim; j++) + { + FuncDeclaration *ifd = base->vtbl.tdata()[j]->isFuncDeclaration(); + FuncDeclaration *fd; + TypeFunction *tf; + + //printf(" vtbl[%d] is '%s'\n", j, ifd ? ifd->toChars() : "null"); + + assert(ifd); + // Find corresponding function in this class + tf = (ifd->type->ty == Tfunction) ? (TypeFunction *)(ifd->type) : NULL; + fd = cd->findFunc(ifd->ident, tf); + if (fd && !fd->isAbstract()) + { + //printf(" found\n"); + // Check that calling conventions match + if (fd->linkage != ifd->linkage) + fd->error("linkage doesn't match interface function"); + + // Check that it is current + if (newinstance && + fd->toParent() != cd && + ifd->toParent() == base) + cd->error("interface function %s.%s is not implemented", + id->toChars(), ifd->ident->toChars()); + + if (fd->toParent() == cd) + result = 1; + } + else + { + //printf(" not found\n"); + // BUG: should mark this class as abstract? + if (!cd->isAbstract()) + cd->error("interface function %s.%s isn't implemented", + id->toChars(), ifd->ident->toChars()); + fd = NULL; + } + if (vtbl) + vtbl->tdata()[j] = fd; + } + + return result; +} + +void BaseClass::copyBaseInterfaces(BaseClasses *vtblInterfaces) +{ + //printf("+copyBaseInterfaces(), %s\n", base->toChars()); +// if (baseInterfaces_dim) +// return; + + baseInterfaces_dim = base->interfaces_dim; + baseInterfaces = (BaseClass *)mem.calloc(baseInterfaces_dim, sizeof(BaseClass)); + + //printf("%s.copyBaseInterfaces()\n", base->toChars()); + for (int i = 0; i < baseInterfaces_dim; i++) + { + BaseClass *b = &baseInterfaces[i]; + BaseClass *b2 = base->interfaces[i]; + + assert(b2->vtbl.dim == 0); // should not be filled yet + memcpy(b, b2, sizeof(BaseClass)); + + if (i) // single inheritance is i==0 + vtblInterfaces->push(b); // only need for M.I. + b->copyBaseInterfaces(vtblInterfaces); + } + //printf("-copyBaseInterfaces\n"); +} diff --git a/clone.c b/clone.c new file mode 100644 index 00000000..2664f864 --- /dev/null +++ b/clone.c @@ -0,0 +1,694 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "aggregate.h" +#include "scope.h" +#include "mtype.h" +#include "declaration.h" +#include "module.h" +#include "id.h" +#include "expression.h" +#include "statement.h" +#include "init.h" +#include "template.h" + + +/******************************************* + * We need an opAssign for the struct if + * it has a destructor or a postblit. + * We need to generate one if a user-specified one does not exist. + */ + +int StructDeclaration::needOpAssign() +{ +#define X 0 + if (X) printf("StructDeclaration::needOpAssign() %s\n", toChars()); + if (hasIdentityAssign) + goto Ldontneed; + + if (dtor || postblit) + goto Lneed; + + /* If any of the fields need an opAssign, then we + * need it too. + */ + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + if (v->storage_class & STCref) + continue; + Type *tv = v->type->toBasetype(); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->needOpAssign()) + goto Lneed; + } + } +Ldontneed: + if (X) printf("\tdontneed\n"); + return 0; + +Lneed: + if (X) printf("\tneed\n"); + return 1; +#undef X +} + +/****************************************** + * Build opAssign for struct. + * S* opAssign(S s) { ... } + * + * Note that s will be constructed onto the stack, probably copy-constructed. + * Then, the body is: + * S tmp = *this; // bit copy + * *this = s; // bit copy + * tmp.dtor(); + * Instead of running the destructor on s, run it on tmp instead. + */ + +FuncDeclaration *StructDeclaration::buildOpAssign(Scope *sc) +{ + if (!needOpAssign()) + return NULL; + + //printf("StructDeclaration::buildOpAssign() %s\n", toChars()); + + FuncDeclaration *fop = NULL; + + Parameters *fparams = new Parameters; + fparams->push(new Parameter(STCnodtor, type, Id::p, NULL)); + Type *ftype = new TypeFunction(fparams, handle, FALSE, LINKd); +#if STRUCTTHISREF + ((TypeFunction *)ftype)->isref = 1; +#endif + + fop = new FuncDeclaration(loc, 0, Id::assign, STCundefined, ftype); + + Expression *e = NULL; + if (postblit) + { /* Swap: + * tmp = *this; *this = s; tmp.dtor(); + */ + //printf("\tswap copy\n"); + Identifier *idtmp = Lexer::uniqueId("__tmp"); + VarDeclaration *tmp; + AssignExp *ec = NULL; + if (dtor) + { + tmp = new VarDeclaration(0, type, idtmp, new VoidInitializer(0)); + tmp->noscope = 1; + tmp->storage_class |= STCctfe; + e = new DeclarationExp(0, tmp); + ec = new AssignExp(0, + new VarExp(0, tmp), +#if STRUCTTHISREF + new ThisExp(0) +#else + new PtrExp(0, new ThisExp(0)) +#endif + ); + ec->op = TOKblit; + e = Expression::combine(e, ec); + } + ec = new AssignExp(0, +#if STRUCTTHISREF + new ThisExp(0), +#else + new PtrExp(0, new ThisExp(0)), +#endif + new IdentifierExp(0, Id::p)); + ec->op = TOKblit; + e = Expression::combine(e, ec); + if (dtor) + { + /* Instead of running the destructor on s, run it + * on tmp. This avoids needing to copy tmp back in to s. + */ + Expression *ec2 = new DotVarExp(0, new VarExp(0, tmp), dtor, 0); + ec2 = new CallExp(0, ec2); + e = Expression::combine(e, ec2); + } + } + else + { /* Do memberwise copy + */ + //printf("\tmemberwise copy\n"); + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + // this.v = s.v; + AssignExp *ec = new AssignExp(0, + new DotVarExp(0, new ThisExp(0), v, 0), + new DotVarExp(0, new IdentifierExp(0, Id::p), v, 0)); + ec->op = TOKblit; + e = Expression::combine(e, ec); + } + } + Statement *s1 = new ExpStatement(0, e); + + /* Add: + * return this; + */ + e = new ThisExp(0); + Statement *s2 = new ReturnStatement(0, e); + + fop->fbody = new CompoundStatement(0, s1, s2); + + members->push(fop); + fop->addMember(sc, this, 1); + + sc = sc->push(); + sc->stc = 0; + sc->linkage = LINKd; + + fop->semantic(sc); + + sc->pop(); + + //printf("-StructDeclaration::buildOpAssign() %s\n", toChars()); + + return fop; +} + +/******************************************* + * We need an opEquals for the struct if + * any fields has an opEquals. + * Generate one if a user-specified one does not exist. + */ + +int StructDeclaration::needOpEquals() +{ +#define X 0 + if (X) printf("StructDeclaration::needOpEquals() %s\n", toChars()); + + if (hasIdentityEquals) + goto Lneed; + + /* If any of the fields has an opEquals, then we + * need it too. + */ + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + if (v->storage_class & STCref) + continue; + Type *tv = v->type->toBasetype(); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->needOpEquals()) + goto Lneed; + } + } + if (X) printf("\tdontneed\n"); + return 0; + +Lneed: + if (X) printf("\tneed\n"); + return 1; +#undef X +} + +/****************************************** + * Build opEquals for struct. + * const bool opEquals(const S s) { ... } + */ + +FuncDeclaration *StructDeclaration::buildOpEquals(Scope *sc) +{ + Dsymbol *eq = search_function(this, Id::eq); + if (eq) + { + for (size_t i = 0; i <= 1; i++) + { + Expression *e = + i == 0 ? new NullExp(loc, type->constOf()) // dummy rvalue + : type->constOf()->defaultInit(); // dummy lvalue + Expressions *arguments = new Expressions(); + arguments->push(e); + + // check identity opEquals exists + FuncDeclaration *fd = eq->isFuncDeclaration(); + if (fd) + { fd = fd->overloadResolve(loc, e, arguments, 1); + if (fd && !(fd->storage_class & STCdisable)) + return fd; + } + + TemplateDeclaration *td = eq->isTemplateDeclaration(); + if (td) + { fd = td->deduceFunctionTemplate(sc, loc, NULL, e, arguments, 1); + if (fd && !(fd->storage_class & STCdisable)) + return fd; + } + } + return NULL; + } + + if (!needOpEquals()) + return NULL; + + //printf("StructDeclaration::buildOpEquals() %s\n", toChars()); + + Parameters *parameters = new Parameters; + parameters->push(new Parameter(STCin, type, Id::p, NULL)); + TypeFunction *tf = new TypeFunction(parameters, Type::tbool, 0, LINKd); + tf->mod = MODconst; + tf = (TypeFunction *)tf->semantic(loc, sc); + + FuncDeclaration *fop = new FuncDeclaration(loc, 0, Id::eq, STCundefined, tf); + + Expression *e = NULL; + /* Do memberwise compare + */ + //printf("\tmemberwise compare\n"); + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + if (v->storage_class & STCref) + assert(0); // what should we do with this? + // this.v == s.v; + EqualExp *ec = new EqualExp(TOKequal, loc, + new DotVarExp(loc, new ThisExp(loc), v, 0), + new DotVarExp(loc, new IdentifierExp(loc, Id::p), v, 0)); + if (e) + e = new AndAndExp(loc, e, ec); + else + e = ec; + } + if (!e) + e = new IntegerExp(loc, 1, Type::tbool); + fop->fbody = new ReturnStatement(loc, e); + + members->push(fop); + fop->addMember(sc, this, 1); + + sc = sc->push(); + sc->stc = 0; + sc->linkage = LINKd; + + fop->semantic(sc); + + sc->pop(); + + //printf("-StructDeclaration::buildOpEquals() %s\n", toChars()); + + return fop; +} + +/****************************************** + * Build __xopEquals for TypeInfo_Struct + * bool __xopEquals(in void* p, in void* q) { ... } + */ + +FuncDeclaration *StructDeclaration::buildXopEquals(Scope *sc) +{ + if (!search_function(this, Id::eq)) + return NULL; + + /* static bool__xopEquals(in void* p, in void* q) { + * return ( *cast(const S*)(p) ).opEquals( *cast(const S*)(q) ); + * } + */ + + Parameters *parameters = new Parameters; + parameters->push(new Parameter(STCin, Type::tvoidptr, Id::p, NULL)); + parameters->push(new Parameter(STCin, Type::tvoidptr, Id::q, NULL)); + TypeFunction *tf = new TypeFunction(parameters, Type::tbool, 0, LINKd); + tf = (TypeFunction *)tf->semantic(loc, sc); + + Identifier *id = Lexer::idPool("__xopEquals"); + FuncDeclaration *fop = new FuncDeclaration(loc, 0, id, STCstatic, tf); + + Expression *e = new CallExp(0, + new DotIdExp(0, + new PtrExp(0, new CastExp(0, + new IdentifierExp(0, Id::p), type->pointerTo()->constOf())), + Id::eq), + new PtrExp(0, new CastExp(0, + new IdentifierExp(0, Id::q), type->pointerTo()->constOf()))); + + fop->fbody = new ReturnStatement(loc, e); + + size_t index = members->dim; + members->push(fop); + + sc = sc->push(); + sc->stc = 0; + sc->linkage = LINKd; + + unsigned errors = global.startGagging(); + fop->semantic(sc); + if (errors == global.gaggedErrors) + { fop->semantic2(sc); + if (errors == global.gaggedErrors) + { fop->semantic3(sc); + if (errors == global.gaggedErrors) + fop->addMember(sc, this, 1); + } + } + if (global.endGagging(errors)) // if errors happened + { + members->remove(index); + + if (!xerreq) + { + Expression *e = new IdentifierExp(loc, Id::empty); + e = new DotIdExp(loc, e, Id::object); + e = new DotIdExp(loc, e, Lexer::idPool("_xopEquals")); + e = e->semantic(sc); + Dsymbol *s = getDsymbol(e); + FuncDeclaration *fd = s->isFuncDeclaration(); + + xerreq = fd; + } + fop = xerreq; + } + + sc->pop(); + + return fop; +} + + +/******************************************* + * Build copy constructor for struct. + * Copy constructors are compiler generated only, and are only + * callable from the compiler. They are not user accessible. + * A copy constructor is: + * void cpctpr(ref const S s) const + * { + * (*cast(S*)&this) = *cast(S*)s; + * (*cast(S*)&this).postBlit(); + * } + * This is done so: + * - postBlit() never sees uninitialized data + * - memcpy can be much more efficient than memberwise copy + * - no fields are overlooked + */ + +FuncDeclaration *StructDeclaration::buildCpCtor(Scope *sc) +{ + //printf("StructDeclaration::buildCpCtor() %s\n", toChars()); + FuncDeclaration *fcp = NULL; + + /* Copy constructor is only necessary if there is a postblit function, + * otherwise the code generator will just do a bit copy. + */ + if (postblit) + { + //printf("generating cpctor\n"); + + StorageClass stc = postblit->storage_class & + (STCdisable | STCsafe | STCtrusted | STCsystem | STCpure | STCnothrow); + if (stc & (STCsafe | STCtrusted)) + stc = stc & ~STCsafe | STCtrusted; + + Parameters *fparams = new Parameters; + fparams->push(new Parameter(STCref, type->constOf(), Id::p, NULL)); + Type *ftype = new TypeFunction(fparams, Type::tvoid, FALSE, LINKd, stc); + ftype->mod = MODconst; + + fcp = new FuncDeclaration(loc, 0, Id::cpctor, stc, ftype); + + if (!(fcp->storage_class & STCdisable)) + { + // Build *this = p; + Expression *e = new ThisExp(0); +#if !STRUCTTHISREF + e = new PtrExp(0, e); +#endif + AssignExp *ea = new AssignExp(0, + new PtrExp(0, new CastExp(0, new AddrExp(0, e), type->mutableOf()->pointerTo())), + new PtrExp(0, new CastExp(0, new AddrExp(0, new IdentifierExp(0, Id::p)), type->mutableOf()->pointerTo())) + ); + ea->op = TOKblit; + Statement *s = new ExpStatement(0, ea); + + // Build postBlit(); + e = new ThisExp(0); +#if !STRUCTTHISREF + e = new PtrExp(0, e); +#endif + e = new PtrExp(0, new CastExp(0, new AddrExp(0, e), type->mutableOf()->pointerTo())); + e = new DotVarExp(0, e, postblit, 0); + e = new CallExp(0, e); + + s = new CompoundStatement(0, s, new ExpStatement(0, e)); + fcp->fbody = s; + } + else + fcp->fbody = new ExpStatement(0, (Expression *)NULL); + + members->push(fcp); + + sc = sc->push(); + sc->stc = 0; + sc->linkage = LINKd; + + fcp->semantic(sc); + + sc->pop(); + } + + return fcp; +} + +/***************************************** + * Create inclusive postblit for struct by aggregating + * all the postblits in postblits[] with the postblits for + * all the members. + * Note the close similarity with AggregateDeclaration::buildDtor(), + * and the ordering changes (runs forward instead of backwards). + */ + +#if DMDV2 +FuncDeclaration *StructDeclaration::buildPostBlit(Scope *sc) +{ + //printf("StructDeclaration::buildPostBlit() %s\n", toChars()); + Expression *e = NULL; + StorageClass stc = 0; + + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + if (v->storage_class & STCref) + continue; + Type *tv = v->type->toBasetype(); + dinteger_t dim = (tv->ty == Tsarray ? 1 : 0); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + dim *= ((TypeSArray *)tv)->dim->toInteger(); + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->postblit) + { + stc |= sd->postblit->storage_class & STCdisable; + + if (stc & STCdisable) + { + e = NULL; + break; + } + + // this.v + Expression *ex = new ThisExp(0); + ex = new DotVarExp(0, ex, v, 0); + + if (dim == 0) + { // this.v.postblit() + ex = new DotVarExp(0, ex, sd->postblit, 0); + ex = new CallExp(0, ex); + } + else + { + // Typeinfo.postblit(cast(void*)&this.v); + Expression *ea = new AddrExp(0, ex); + ea = new CastExp(0, ea, Type::tvoid->pointerTo()); + + Expression *et = v->type->getTypeInfo(sc); + et = new DotIdExp(0, et, Id::postblit); + + ex = new CallExp(0, et, ea); + } + e = Expression::combine(e, ex); // combine in forward order + } + } + } + + /* Build our own "postblit" which executes e + */ + if (e || (stc & STCdisable)) + { //printf("Building __fieldPostBlit()\n"); + PostBlitDeclaration *dd = new PostBlitDeclaration(loc, 0, Lexer::idPool("__fieldPostBlit")); + dd->storage_class |= stc; + dd->fbody = new ExpStatement(0, e); + postblits.shift(dd); + members->push(dd); + dd->semantic(sc); + } + + switch (postblits.dim) + { + case 0: + return NULL; + + case 1: + return postblits.tdata()[0]; + + default: + e = NULL; + for (size_t i = 0; i < postblits.dim; i++) + { FuncDeclaration *fd = postblits.tdata()[i]; + stc |= fd->storage_class & STCdisable; + if (stc & STCdisable) + { + e = NULL; + break; + } + Expression *ex = new ThisExp(0); + ex = new DotVarExp(0, ex, fd, 0); + ex = new CallExp(0, ex); + e = Expression::combine(e, ex); + } + PostBlitDeclaration *dd = new PostBlitDeclaration(loc, 0, Lexer::idPool("__aggrPostBlit")); + dd->storage_class |= stc; + dd->fbody = new ExpStatement(0, e); + members->push(dd); + dd->semantic(sc); + return dd; + } +} + +#endif + +/***************************************** + * Create inclusive destructor for struct/class by aggregating + * all the destructors in dtors[] with the destructors for + * all the members. + * Note the close similarity with StructDeclaration::buildPostBlit(), + * and the ordering changes (runs backward instead of forwards). + */ + +FuncDeclaration *AggregateDeclaration::buildDtor(Scope *sc) +{ + //printf("AggregateDeclaration::buildDtor() %s\n", toChars()); + Expression *e = NULL; + +#if DMDV2 + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + if (v->storage_class & STCref) + continue; + Type *tv = v->type->toBasetype(); + dinteger_t dim = (tv->ty == Tsarray ? 1 : 0); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + dim *= ((TypeSArray *)tv)->dim->toInteger(); + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->dtor) + { Expression *ex; + + // this.v + ex = new ThisExp(0); + ex = new DotVarExp(0, ex, v, 0); + + if (dim == 0) + { // this.v.dtor() + ex = new DotVarExp(0, ex, sd->dtor, 0); + ex = new CallExp(0, ex); + } + else + { + // Typeinfo.destroy(cast(void*)&this.v); + Expression *ea = new AddrExp(0, ex); + ea = new CastExp(0, ea, Type::tvoid->pointerTo()); + + Expression *et = v->type->getTypeInfo(sc); + et = new DotIdExp(0, et, Id::destroy); + + ex = new CallExp(0, et, ea); + } + e = Expression::combine(ex, e); // combine in reverse order + } + } + } + + /* Build our own "destructor" which executes e + */ + if (e) + { //printf("Building __fieldDtor()\n"); + DtorDeclaration *dd = new DtorDeclaration(loc, 0, Lexer::idPool("__fieldDtor")); + dd->fbody = new ExpStatement(0, e); + dtors.shift(dd); + members->push(dd); + dd->semantic(sc); + } +#endif + + switch (dtors.dim) + { + case 0: + return NULL; + + case 1: + return dtors.tdata()[0]; + + default: + e = NULL; + for (size_t i = 0; i < dtors.dim; i++) + { FuncDeclaration *fd = dtors.tdata()[i]; + Expression *ex = new ThisExp(0); + ex = new DotVarExp(0, ex, fd, 0); + ex = new CallExp(0, ex); + e = Expression::combine(ex, e); + } + DtorDeclaration *dd = new DtorDeclaration(loc, 0, Lexer::idPool("__aggrDtor")); + dd->fbody = new ExpStatement(0, e); + members->push(dd); + dd->semantic(sc); + return dd; + } +} + + diff --git a/complex_t.h b/complex_t.h new file mode 100644 index 00000000..a1b4f4ed --- /dev/null +++ b/complex_t.h @@ -0,0 +1,74 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright and Burton Radons +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_COMPLEX_T_H +#define DMD_COMPLEX_T_H + +/* Roll our own complex type for compilers that don't support complex + */ + +struct complex_t +{ + long double re; + long double im; + + complex_t() { this->re = 0; this->im = 0; } + complex_t(long double re) { this->re = re; this->im = 0; } + complex_t(long double re, long double im) { this->re = re; this->im = im; } + + complex_t operator + (complex_t y) { complex_t r; r.re = re + y.re; r.im = im + y.im; return r; } + complex_t operator - (complex_t y) { complex_t r; r.re = re - y.re; r.im = im - y.im; return r; } + complex_t operator - () { complex_t r; r.re = -re; r.im = -im; return r; } + complex_t operator * (complex_t y) { return complex_t(re * y.re - im * y.im, im * y.re + re * y.im); } + + complex_t operator / (complex_t y) + { + long double abs_y_re = y.re < 0 ? -y.re : y.re; + long double abs_y_im = y.im < 0 ? -y.im : y.im; + long double r, den; + + if (abs_y_re < abs_y_im) + { + r = y.re / y.im; + den = y.im + r * y.re; + return complex_t((re * r + im) / den, + (im * r - re) / den); + } + else + { + r = y.im / y.re; + den = y.re + r * y.im; + return complex_t((re + r * im) / den, + (im - r * re) / den); + } + } + + operator bool () { return re || im; } + + int operator == (complex_t y) { return re == y.re && im == y.im; } + int operator != (complex_t y) { return re != y.re || im != y.im; } +}; + +inline complex_t operator * (long double x, complex_t y) { return complex_t(x) * y; } +inline complex_t operator * (complex_t x, long double y) { return x * complex_t(y); } +inline complex_t operator / (complex_t x, long double y) { return x / complex_t(y); } + + +inline long double creall(complex_t x) +{ + return x.re; +} + +inline long double cimagl(complex_t x) +{ + return x.im; +} + +#endif diff --git a/cond.c b/cond.c new file mode 100644 index 00000000..3ee03889 --- /dev/null +++ b/cond.c @@ -0,0 +1,399 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "id.h" +#include "init.h" +#include "declaration.h" +#include "identifier.h" +#include "expression.h" +#include "cond.h" +#include "module.h" +#include "template.h" +#include "lexer.h" +#include "mtype.h" +#include "scope.h" + +int findCondition(Strings *ids, Identifier *ident) +{ + if (ids) + { + for (size_t i = 0; i < ids->dim; i++) + { + const char *id = ids->tdata()[i]; + + if (strcmp(id, ident->toChars()) == 0) + return TRUE; + } + } + + return FALSE; +} + +/* ============================================================ */ + +Condition::Condition(Loc loc) +{ + this->loc = loc; + inc = 0; +} + +/* ============================================================ */ + +DVCondition::DVCondition(Module *mod, unsigned level, Identifier *ident) + : Condition(0) +{ + this->mod = mod; + this->level = level; + this->ident = ident; +} + +Condition *DVCondition::syntaxCopy() +{ + return this; // don't need to copy +} + +/* ============================================================ */ + +void DebugCondition::setGlobalLevel(unsigned level) +{ + global.params.debuglevel = level; +} + +void DebugCondition::addGlobalIdent(const char *ident) +{ + if (!global.params.debugids) + global.params.debugids = new Strings(); + global.params.debugids->push((char *)ident); +} + + +DebugCondition::DebugCondition(Module *mod, unsigned level, Identifier *ident) + : DVCondition(mod, level, ident) +{ +} + +int DebugCondition::include(Scope *sc, ScopeDsymbol *s) +{ + //printf("DebugCondition::include() level = %d, debuglevel = %d\n", level, global.params.debuglevel); + if (inc == 0) + { + inc = 2; + if (ident) + { + if (findCondition(mod->debugids, ident)) + inc = 1; + else if (findCondition(global.params.debugids, ident)) + inc = 1; + else + { if (!mod->debugidsNot) + mod->debugidsNot = new Strings(); + mod->debugidsNot->push(ident->toChars()); + } + } + else if (level <= global.params.debuglevel || level <= mod->debuglevel) + inc = 1; + } + return (inc == 1); +} + +void DebugCondition::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (ident) + buf->printf("debug (%s)", ident->toChars()); + else + buf->printf("debug (%u)", level); +} + +/* ============================================================ */ + +void VersionCondition::setGlobalLevel(unsigned level) +{ + global.params.versionlevel = level; +} + +void VersionCondition::checkPredefined(Loc loc, const char *ident) +{ + static const char* reserved[] = + { + "DigitalMars", "X86", "X86_64", + "Windows", "Win32", "Win64", + "linux", +#if DMDV2 + /* Although Posix is predefined by D1, disallowing its + * redefinition breaks makefiles and older builds. + */ + "Posix", + "D_NET", +#endif + "OSX", "FreeBSD", + "OpenBSD", + "Solaris", + "LittleEndian", "BigEndian", + "all", + "none", + }; + + for (unsigned i = 0; i < sizeof(reserved) / sizeof(reserved[0]); i++) + { + if (strcmp(ident, reserved[i]) == 0) + goto Lerror; + } + + if (ident[0] == 'D' && ident[1] == '_') + goto Lerror; + + return; + + Lerror: + error(loc, "version identifier '%s' is reserved and cannot be set", ident); +} + +void VersionCondition::addGlobalIdent(const char *ident) +{ + checkPredefined(0, ident); + addPredefinedGlobalIdent(ident); +} + +void VersionCondition::addPredefinedGlobalIdent(const char *ident) +{ + if (!global.params.versionids) + global.params.versionids = new Strings(); + global.params.versionids->push((char *)ident); +} + + +VersionCondition::VersionCondition(Module *mod, unsigned level, Identifier *ident) + : DVCondition(mod, level, ident) +{ +} + +int VersionCondition::include(Scope *sc, ScopeDsymbol *s) +{ + //printf("VersionCondition::include() level = %d, versionlevel = %d\n", level, global.params.versionlevel); + //if (ident) printf("\tident = '%s'\n", ident->toChars()); + if (inc == 0) + { + inc = 2; + if (ident) + { + if (findCondition(mod->versionids, ident)) + inc = 1; + else if (findCondition(global.params.versionids, ident)) + inc = 1; + else + { + if (!mod->versionidsNot) + mod->versionidsNot = new Strings(); + mod->versionidsNot->push(ident->toChars()); + } + } + else if (level <= global.params.versionlevel || level <= mod->versionlevel) + inc = 1; + } + return (inc == 1); +} + +void VersionCondition::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (ident) + buf->printf("version (%s)", ident->toChars()); + else + buf->printf("version (%u)", level); +} + + +/**************************** StaticIfCondition *******************************/ + +StaticIfCondition::StaticIfCondition(Loc loc, Expression *exp) + : Condition(loc) +{ + this->exp = exp; +} + +Condition *StaticIfCondition::syntaxCopy() +{ + return new StaticIfCondition(loc, exp->syntaxCopy()); +} + +int StaticIfCondition::include(Scope *sc, ScopeDsymbol *s) +{ +#if 0 + printf("StaticIfCondition::include(sc = %p, s = %p)\n", sc, s); + if (s) + { + printf("\ts = '%s', kind = %s\n", s->toChars(), s->kind()); + } +#endif + if (inc == 0) + { + if (!sc) + { + error(loc, "static if conditional cannot be at global scope"); + inc = 2; + return 0; + } + + sc = sc->push(sc->scopesym); + sc->sd = s; // s gets any addMember() + sc->flags |= SCOPEstaticif; + Expression *e = exp->semantic(sc); + sc->pop(); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->isBool(TRUE)) + inc = 1; + else if (e->isBool(FALSE)) + inc = 2; + else + { + e->error("expression %s is not constant or does not evaluate to a bool", e->toChars()); + inc = 2; + } + } + return (inc == 1); +} + +void StaticIfCondition::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("static if("); + exp->toCBuffer(buf, hgs); + buf->writeByte(')'); +} + + +/**************************** IftypeCondition *******************************/ + +IftypeCondition::IftypeCondition(Loc loc, Type *targ, Identifier *id, enum TOK tok, Type *tspec) + : Condition(loc) +{ + this->targ = targ; + this->id = id; + this->tok = tok; + this->tspec = tspec; +} + +Condition *IftypeCondition::syntaxCopy() +{ + return new IftypeCondition(loc, + targ->syntaxCopy(), + id, + tok, + tspec ? tspec->syntaxCopy() : NULL); +} + +int IftypeCondition::include(Scope *sc, ScopeDsymbol *sd) +{ + //printf("IftypeCondition::include()\n"); + if (inc == 0) + { + if (!sc) + { + error(loc, "iftype conditional cannot be at global scope"); + inc = 2; + return 0; + } + Type *t = targ->trySemantic(loc, sc); + if (t) + targ = t; + else + inc = 2; // condition is false + + if (!t) + { + } + else if (id && tspec) + { + /* Evaluate to TRUE if targ matches tspec. + * If TRUE, declare id as an alias for the specialized type. + */ + + MATCH m; + TemplateTypeParameter tp(loc, id, NULL, NULL); + + TemplateParameters parameters; + parameters.setDim(1); + parameters.tdata()[0] = &tp; + + Objects dedtypes; + dedtypes.setDim(1); + + m = targ->deduceType(sc, tspec, ¶meters, &dedtypes); + if (m == MATCHnomatch || + (m != MATCHexact && tok == TOKequal)) + inc = 2; + else + { + inc = 1; + Type *tded = (Type *)dedtypes.tdata()[0]; + if (!tded) + tded = targ; + Dsymbol *s = new AliasDeclaration(loc, id, tded); + s->semantic(sc); + sc->insert(s); + if (sd) + s->addMember(sc, sd, 1); + } + } + else if (id) + { + /* Declare id as an alias for type targ. Evaluate to TRUE + */ + Dsymbol *s = new AliasDeclaration(loc, id, targ); + s->semantic(sc); + sc->insert(s); + if (sd) + s->addMember(sc, sd, 1); + inc = 1; + } + else if (tspec) + { + /* Evaluate to TRUE if targ matches tspec + */ + tspec = tspec->semantic(loc, sc); + //printf("targ = %s\n", targ->toChars()); + //printf("tspec = %s\n", tspec->toChars()); + if (tok == TOKcolon) + { if (targ->implicitConvTo(tspec)) + inc = 1; + else + inc = 2; + } + else /* == */ + { if (targ->equals(tspec)) + inc = 1; + else + inc = 2; + } + } + else + inc = 1; + //printf("inc = %d\n", inc); + } + return (inc == 1); +} + +void IftypeCondition::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("iftype("); + targ->toCBuffer(buf, id, hgs); + if (tspec) + { + if (tok == TOKcolon) + buf->writestring(" : "); + else + buf->writestring(" == "); + tspec->toCBuffer(buf, NULL, hgs); + } + buf->writeByte(')'); +} + + diff --git a/cond.h b/cond.h new file mode 100644 index 00000000..789503a4 --- /dev/null +++ b/cond.h @@ -0,0 +1,105 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_DEBCOND_H +#define DMD_DEBCOND_H + +struct Expression; +struct Identifier; +struct OutBuffer; +struct Module; +struct Scope; +struct ScopeDsymbol; +struct DebugCondition; +#include "lexer.h" // dmdhg +enum TOK; +struct HdrGenState; + +int findCondition(Strings *ids, Identifier *ident); + +struct Condition +{ + Loc loc; + int inc; // 0: not computed yet + // 1: include + // 2: do not include + + Condition(Loc loc); + + virtual Condition *syntaxCopy() = 0; + virtual int include(Scope *sc, ScopeDsymbol *s) = 0; + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs) = 0; + virtual DebugCondition *isDebugCondition() { return NULL; } +}; + +struct DVCondition : Condition +{ + unsigned level; + Identifier *ident; + Module *mod; + + DVCondition(Module *mod, unsigned level, Identifier *ident); + + Condition *syntaxCopy(); +}; + +struct DebugCondition : DVCondition +{ + static void setGlobalLevel(unsigned level); + static void addGlobalIdent(const char *ident); + static void addPredefinedGlobalIdent(const char *ident); + + DebugCondition(Module *mod, unsigned level, Identifier *ident); + + int include(Scope *sc, ScopeDsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + DebugCondition *isDebugCondition() { return this; } +}; + +struct VersionCondition : DVCondition +{ + static void setGlobalLevel(unsigned level); + static void checkPredefined(Loc loc, const char *ident); + static void addGlobalIdent(const char *ident); + static void addPredefinedGlobalIdent(const char *ident); + + VersionCondition(Module *mod, unsigned level, Identifier *ident); + + int include(Scope *sc, ScopeDsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct StaticIfCondition : Condition +{ + Expression *exp; + + StaticIfCondition(Loc loc, Expression *exp); + Condition *syntaxCopy(); + int include(Scope *sc, ScopeDsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct IftypeCondition : Condition +{ + /* iftype (targ id tok tspec) + */ + Type *targ; + Identifier *id; // can be NULL + enum TOK tok; // ':' or '==' + Type *tspec; // can be NULL + + IftypeCondition(Loc loc, Type *targ, Identifier *id, enum TOK tok, Type *tspec); + Condition *syntaxCopy(); + int include(Scope *sc, ScopeDsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + + +#endif diff --git a/constfold.c b/constfold.c new file mode 100644 index 00000000..acb65b75 --- /dev/null +++ b/constfold.c @@ -0,0 +1,1868 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if __DMC__ +#include +#endif + +#include "rmem.h" +#include "root.h" +#include "port.h" + +#include "mtype.h" +#include "expression.h" +#include "aggregate.h" +#include "declaration.h" +#include "utf.h" + +#define LOG 0 + +int RealEquals(real_t x1, real_t x2); + +Expression *expType(Type *type, Expression *e) +{ + if (type != e->type) + { + e = e->copy(); + e->type = type; + } + return e; +} + +/* ================================== isConst() ============================== */ + +int Expression::isConst() +{ + //printf("Expression::isConst(): %s\n", toChars()); + return 0; +} + +int IntegerExp::isConst() +{ + return 1; +} + +int RealExp::isConst() +{ + return 1; +} + +int ComplexExp::isConst() +{ + return 1; +} + +int NullExp::isConst() +{ + return 0; +} + +int SymOffExp::isConst() +{ + return 2; +} + +/* =============================== constFold() ============================== */ + +/* The constFold() functions were redundant with the optimize() ones, + * and so have been folded in with them. + */ + +/* ========================================================================== */ + +Expression *Neg(Type *type, Expression *e1) +{ Expression *e; + Loc loc = e1->loc; + + if (e1->type->isreal()) + { + e = new RealExp(loc, -e1->toReal(), type); + } + else if (e1->type->isimaginary()) + { + e = new RealExp(loc, -e1->toImaginary(), type); + } + else if (e1->type->iscomplex()) + { + e = new ComplexExp(loc, -e1->toComplex(), type); + } + else + e = new IntegerExp(loc, -e1->toInteger(), type); + return e; +} + +Expression *Com(Type *type, Expression *e1) +{ Expression *e; + Loc loc = e1->loc; + + e = new IntegerExp(loc, ~e1->toInteger(), type); + return e; +} + +Expression *Not(Type *type, Expression *e1) +{ Expression *e; + Loc loc = e1->loc; + + e = new IntegerExp(loc, e1->isBool(0), type); + return e; +} + +Expression *Bool(Type *type, Expression *e1) +{ Expression *e; + Loc loc = e1->loc; + + e = new IntegerExp(loc, e1->isBool(1), type); + return e; +} + +Expression *Add(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + +#if LOG + printf("Add(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars()); +#endif + if (type->isreal()) + { + e = new RealExp(loc, e1->toReal() + e2->toReal(), type); + } + else if (type->isimaginary()) + { + e = new RealExp(loc, e1->toImaginary() + e2->toImaginary(), type); + } + else if (type->iscomplex()) + { + // This rigamarole is necessary so that -0.0 doesn't get + // converted to +0.0 by doing an extraneous add with +0.0 + complex_t c1; + real_t r1; + real_t i1; + + complex_t c2; + real_t r2; + real_t i2; + + complex_t v; + int x; + + if (e1->type->isreal()) + { r1 = e1->toReal(); + x = 0; + } + else if (e1->type->isimaginary()) + { i1 = e1->toImaginary(); + x = 3; + } + else + { c1 = e1->toComplex(); + x = 6; + } + + if (e2->type->isreal()) + { r2 = e2->toReal(); + } + else if (e2->type->isimaginary()) + { i2 = e2->toImaginary(); + x += 1; + } + else + { c2 = e2->toComplex(); + x += 2; + } + + switch (x) + { +#if __DMC__ + case 0+0: v = (complex_t) (r1 + r2); break; + case 0+1: v = r1 + i2 * I; break; + case 0+2: v = r1 + c2; break; + case 3+0: v = i1 * I + r2; break; + case 3+1: v = (complex_t) ((i1 + i2) * I); break; + case 3+2: v = i1 * I + c2; break; + case 6+0: v = c1 + r2; break; + case 6+1: v = c1 + i2 * I; break; + case 6+2: v = c1 + c2; break; +#else + case 0+0: v = complex_t(r1 + r2, 0); break; + case 0+1: v = complex_t(r1, i2); break; + case 0+2: v = complex_t(r1 + creall(c2), cimagl(c2)); break; + case 3+0: v = complex_t(r2, i1); break; + case 3+1: v = complex_t(0, i1 + i2); break; + case 3+2: v = complex_t(creall(c2), i1 + cimagl(c2)); break; + case 6+0: v = complex_t(creall(c1) + r2, cimagl(c2)); break; + case 6+1: v = complex_t(creall(c1), cimagl(c1) + i2); break; + case 6+2: v = c1 + c2; break; +#endif + default: assert(0); + } + e = new ComplexExp(loc, v, type); + } + else if (e1->op == TOKsymoff) + { + SymOffExp *soe = (SymOffExp *)e1; + e = new SymOffExp(loc, soe->var, soe->offset + e2->toInteger()); + e->type = type; + } + else if (e2->op == TOKsymoff) + { + SymOffExp *soe = (SymOffExp *)e2; + e = new SymOffExp(loc, soe->var, soe->offset + e1->toInteger()); + e->type = type; + } + else + e = new IntegerExp(loc, e1->toInteger() + e2->toInteger(), type); + return e; +} + + +Expression *Min(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + if (type->isreal()) + { + e = new RealExp(loc, e1->toReal() - e2->toReal(), type); + } + else if (type->isimaginary()) + { + e = new RealExp(loc, e1->toImaginary() - e2->toImaginary(), type); + } + else if (type->iscomplex()) + { + // This rigamarole is necessary so that -0.0 doesn't get + // converted to +0.0 by doing an extraneous add with +0.0 + complex_t c1; + real_t r1; + real_t i1; + + complex_t c2; + real_t r2; + real_t i2; + + complex_t v; + int x; + + if (e1->type->isreal()) + { r1 = e1->toReal(); + x = 0; + } + else if (e1->type->isimaginary()) + { i1 = e1->toImaginary(); + x = 3; + } + else + { c1 = e1->toComplex(); + x = 6; + } + + if (e2->type->isreal()) + { r2 = e2->toReal(); + } + else if (e2->type->isimaginary()) + { i2 = e2->toImaginary(); + x += 1; + } + else + { c2 = e2->toComplex(); + x += 2; + } + + switch (x) + { +#if __DMC__ + case 0+0: v = (complex_t) (r1 - r2); break; + case 0+1: v = r1 - i2 * I; break; + case 0+2: v = r1 - c2; break; + case 3+0: v = i1 * I - r2; break; + case 3+1: v = (complex_t) ((i1 - i2) * I); break; + case 3+2: v = i1 * I - c2; break; + case 6+0: v = c1 - r2; break; + case 6+1: v = c1 - i2 * I; break; + case 6+2: v = c1 - c2; break; +#else + case 0+0: v = complex_t(r1 - r2, 0); break; + case 0+1: v = complex_t(r1, -i2); break; + case 0+2: v = complex_t(r1 - creall(c2), -cimagl(c2)); break; + case 3+0: v = complex_t(-r2, i1); break; + case 3+1: v = complex_t(0, i1 - i2); break; + case 3+2: v = complex_t(-creall(c2), i1 - cimagl(c2)); break; + case 6+0: v = complex_t(creall(c1) - r2, cimagl(c1)); break; + case 6+1: v = complex_t(creall(c1), cimagl(c1) - i2); break; + case 6+2: v = c1 - c2; break; +#endif + default: assert(0); + } + e = new ComplexExp(loc, v, type); + } + else if (e1->op == TOKsymoff) + { + SymOffExp *soe = (SymOffExp *)e1; + e = new SymOffExp(loc, soe->var, soe->offset - e2->toInteger()); + e->type = type; + } + else + { + e = new IntegerExp(loc, e1->toInteger() - e2->toInteger(), type); + } + return e; +} + +Expression *Mul(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + if (type->isfloating()) + { complex_t c; +#ifdef IN_GCC + real_t r; +#else + d_float80 r; +#endif + + if (e1->type->isreal()) + { +#if __DMC__ + c = e1->toReal() * e2->toComplex(); +#else + r = e1->toReal(); + c = e2->toComplex(); + c = complex_t(r * creall(c), r * cimagl(c)); +#endif + } + else if (e1->type->isimaginary()) + { +#if __DMC__ + c = e1->toImaginary() * I * e2->toComplex(); +#else + r = e1->toImaginary(); + c = e2->toComplex(); + c = complex_t(-r * cimagl(c), r * creall(c)); +#endif + } + else if (e2->type->isreal()) + { +#if __DMC__ + c = e2->toReal() * e1->toComplex(); +#else + r = e2->toReal(); + c = e1->toComplex(); + c = complex_t(r * creall(c), r * cimagl(c)); +#endif + } + else if (e2->type->isimaginary()) + { +#if __DMC__ + c = e1->toComplex() * e2->toImaginary() * I; +#else + r = e2->toImaginary(); + c = e1->toComplex(); + c = complex_t(-r * cimagl(c), r * creall(c)); +#endif + } + else + c = e1->toComplex() * e2->toComplex(); + + if (type->isreal()) + e = new RealExp(loc, creall(c), type); + else if (type->isimaginary()) + e = new RealExp(loc, cimagl(c), type); + else if (type->iscomplex()) + e = new ComplexExp(loc, c, type); + else + assert(0); + } + else + { + e = new IntegerExp(loc, e1->toInteger() * e2->toInteger(), type); + } + return e; +} + +Expression *Div(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + if (type->isfloating()) + { complex_t c; +#ifdef IN_GCC + real_t r; +#else + d_float80 r; +#endif + + //e1->type->print(); + //e2->type->print(); + if (e2->type->isreal()) + { + if (e1->type->isreal()) + { + e = new RealExp(loc, e1->toReal() / e2->toReal(), type); + return e; + } +#if __DMC__ + //r = e2->toReal(); + //c = e1->toComplex(); + //printf("(%Lg + %Lgi) / %Lg\n", creall(c), cimagl(c), r); + + c = e1->toComplex() / e2->toReal(); +#else + r = e2->toReal(); + c = e1->toComplex(); + c = complex_t(creall(c) / r, cimagl(c) / r); +#endif + } + else if (e2->type->isimaginary()) + { +#if __DMC__ + //r = e2->toImaginary(); + //c = e1->toComplex(); + //printf("(%Lg + %Lgi) / %Lgi\n", creall(c), cimagl(c), r); + + c = e1->toComplex() / (e2->toImaginary() * I); +#else + r = e2->toImaginary(); + c = e1->toComplex(); + c = complex_t(cimagl(c) / r, -creall(c) / r); +#endif + } + else + { + c = e1->toComplex() / e2->toComplex(); + } + + if (type->isreal()) + e = new RealExp(loc, creall(c), type); + else if (type->isimaginary()) + e = new RealExp(loc, cimagl(c), type); + else if (type->iscomplex()) + e = new ComplexExp(loc, c, type); + else + assert(0); + } + else + { sinteger_t n1; + sinteger_t n2; + sinteger_t n; + + n1 = e1->toInteger(); + n2 = e2->toInteger(); + if (n2 == 0) + { e2->error("divide by 0"); + e2 = new IntegerExp(loc, 1, e2->type); + n2 = 1; + } + if (e1->type->isunsigned() || e2->type->isunsigned()) + n = ((d_uns64) n1) / ((d_uns64) n2); + else + n = n1 / n2; + e = new IntegerExp(loc, n, type); + } + return e; +} + +Expression *Mod(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + if (type->isfloating()) + { + complex_t c; + + if (e2->type->isreal()) + { real_t r2 = e2->toReal(); + +#ifdef __DMC__ + c = Port::fmodl(e1->toReal(), r2) + Port::fmodl(e1->toImaginary(), r2) * I; +#elif defined(IN_GCC) + c = complex_t(e1->toReal() % r2, e1->toImaginary() % r2); +#else + c = complex_t(Port::fmodl(e1->toReal(), r2), Port::fmodl(e1->toImaginary(), r2)); +#endif + } + else if (e2->type->isimaginary()) + { real_t i2 = e2->toImaginary(); + +#ifdef __DMC__ + c = Port::fmodl(e1->toReal(), i2) + Port::fmodl(e1->toImaginary(), i2) * I; +#elif defined(IN_GCC) + c = complex_t(e1->toReal() % i2, e1->toImaginary() % i2); +#else + c = complex_t(Port::fmodl(e1->toReal(), i2), Port::fmodl(e1->toImaginary(), i2)); +#endif + } + else + assert(0); + + if (type->isreal()) + e = new RealExp(loc, creall(c), type); + else if (type->isimaginary()) + e = new RealExp(loc, cimagl(c), type); + else if (type->iscomplex()) + e = new ComplexExp(loc, c, type); + else + assert(0); + } + else + { sinteger_t n1; + sinteger_t n2; + sinteger_t n; + + n1 = e1->toInteger(); + n2 = e2->toInteger(); + if (n2 == 0) + { e2->error("divide by 0"); + e2 = new IntegerExp(loc, 1, e2->type); + n2 = 1; + } + if (n2 == -1 && !type->isunsigned()) + { // Check for int.min % -1 + if (n1 == 0xFFFFFFFF80000000ULL && type->toBasetype()->ty != Tint64) + { + e2->error("integer overflow: int.min % -1"); + e2 = new IntegerExp(loc, 1, e2->type); + n2 = 1; + } + else if (n1 == 0x8000000000000000LL) // long.min % -1 + { + e2->error("integer overflow: long.min % -1"); + e2 = new IntegerExp(loc, 1, e2->type); + n2 = 1; + } + } + if (e1->type->isunsigned() || e2->type->isunsigned()) + n = ((d_uns64) n1) % ((d_uns64) n2); + else + n = n1 % n2; + e = new IntegerExp(loc, n, type); + } + return e; +} + +Expression *Pow(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + // Handle integer power operations. + if (e2->type->isintegral()) + { + Expression * r; + Expression * v; + dinteger_t n = e2->toInteger(); + bool neg; + + if (!e2->type->isunsigned() && (sinteger_t)n < 0) + { + if (e1->type->isintegral()) + return EXP_CANT_INTERPRET; + + // Don't worry about overflow, from now on n is unsigned. + neg = true; + n = -n; + } + else + neg = false; + + if (e1->type->isfloating()) + { + r = new RealExp(loc, e1->toReal(), e1->type); + v = new RealExp(loc, 1.0, e1->type); + } + else + { + r = new RealExp(loc, e1->toReal(), Type::tfloat64); + v = new RealExp(loc, 1.0, Type::tfloat64); + } + + while (n != 0) + { + if (n & 1) + v = Mul(v->type, v, r); + n >>= 1; + r = Mul(r->type, r, r); + } + + if (neg) + v = Div(v->type, new RealExp(loc, 1.0, v->type), v); + + if (type->isintegral()) + e = new IntegerExp(loc, v->toInteger(), type); + else + e = new RealExp(loc, v->toReal(), type); + } + else if (e2->type->isfloating()) + { + // x ^^ y for x < 0 and y not an integer is not defined + if (e1->toReal() < 0.0) + { + e = new RealExp(loc, Port::nan, type); + } + else if (e2->toReal() == 0.5) + { + // Special case: call sqrt directly. + Expressions args; + args.setDim(1); + args.tdata()[0] = e1; + e = eval_builtin(loc, BUILTINsqrt, &args); + if (!e) + e = EXP_CANT_INTERPRET; + } + else + e = EXP_CANT_INTERPRET; + } + else + e = EXP_CANT_INTERPRET; + + return e; +} + +Expression *Shl(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + + e = new IntegerExp(loc, e1->toInteger() << e2->toInteger(), type); + return e; +} + +Expression *Shr(Type *type, Expression *e1, Expression *e2) +{ + Loc loc = e1->loc; + + dinteger_t value = e1->toInteger(); + dinteger_t dcount = e2->toInteger(); + assert(dcount <= 0xFFFFFFFF); + unsigned count = (unsigned)dcount; + switch (e1->type->toBasetype()->ty) + { + case Tint8: + value = (d_int8)(value) >> count; + break; + + case Tuns8: + case Tchar: + value = (d_uns8)(value) >> count; + break; + + case Tint16: + value = (d_int16)(value) >> count; + break; + + case Tuns16: + case Twchar: + value = (d_uns16)(value) >> count; + break; + + case Tint32: + value = (d_int32)(value) >> count; + break; + + case Tuns32: + case Tdchar: + value = (d_uns32)(value) >> count; + break; + + case Tint64: + value = (d_int64)(value) >> count; + break; + + case Tuns64: + value = (d_uns64)(value) >> count; + break; + + case Terror: + return e1; + + default: + assert(0); + } + Expression *e = new IntegerExp(loc, value, type); + return e; +} + +Expression *Ushr(Type *type, Expression *e1, Expression *e2) +{ + Loc loc = e1->loc; + + dinteger_t value = e1->toInteger(); + dinteger_t dcount = e2->toInteger(); + assert(dcount <= 0xFFFFFFFF); + unsigned count = (unsigned)dcount; + switch (e1->type->toBasetype()->ty) + { + case Tint8: + case Tuns8: + case Tchar: + // Possible only with >>>=. >>> always gets promoted to int. + value = (value & 0xFF) >> count; + break; + + case Tint16: + case Tuns16: + case Twchar: + // Possible only with >>>=. >>> always gets promoted to int. + value = (value & 0xFFFF) >> count; + break; + + case Tint32: + case Tuns32: + case Tdchar: + value = (value & 0xFFFFFFFF) >> count; + break; + + case Tint64: + case Tuns64: + value = (d_uns64)(value) >> count; + break; + + case Terror: + return e1; + + default: + assert(0); + } + Expression *e = new IntegerExp(loc, value, type); + return e; +} + +Expression *And(Type *type, Expression *e1, Expression *e2) +{ + Expression *e; + e = new IntegerExp(e1->loc, e1->toInteger() & e2->toInteger(), type); + return e; +} + +Expression *Or(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + e = new IntegerExp(e1->loc, e1->toInteger() | e2->toInteger(), type); + return e; +} + +Expression *Xor(Type *type, Expression *e1, Expression *e2) +{ Expression *e; + e = new IntegerExp(e1->loc, e1->toInteger() ^ e2->toInteger(), type); + return e; +} + +/* Also returns EXP_CANT_INTERPRET if cannot be computed. + */ +Expression *Equal(enum TOK op, Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + int cmp; + real_t r1; + real_t r2; + + //printf("Equal(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars()); + + assert(op == TOKequal || op == TOKnotequal); + + if (e1->op == TOKnull) + { + if (e2->op == TOKnull) + cmp = 1; + else if (e2->op == TOKstring) + { StringExp *es2 = (StringExp *)e2; + cmp = (0 == es2->len); + } + else if (e2->op == TOKarrayliteral) + { ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + cmp = !es2->elements || (0 == es2->elements->dim); + } + else + return EXP_CANT_INTERPRET; + } + else if (e2->op == TOKnull) + { + if (e1->op == TOKstring) + { StringExp *es1 = (StringExp *)e1; + cmp = (0 == es1->len); + } + else if (e1->op == TOKarrayliteral) + { ArrayLiteralExp *es1 = (ArrayLiteralExp *)e1; + cmp = !es1->elements || (0 == es1->elements->dim); + } + else + return EXP_CANT_INTERPRET; + } + else if (e1->op == TOKstring && e2->op == TOKstring) + { StringExp *es1 = (StringExp *)e1; + StringExp *es2 = (StringExp *)e2; + + if (es1->sz != es2->sz) + { + assert(global.errors); + return EXP_CANT_INTERPRET; + } + if (es1->len == es2->len && + memcmp(es1->string, es2->string, es1->sz * es1->len) == 0) + cmp = 1; + else + cmp = 0; + } + else if (e1->op == TOKarrayliteral && e2->op == TOKarrayliteral) + { ArrayLiteralExp *es1 = (ArrayLiteralExp *)e1; + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + + if ((!es1->elements || !es1->elements->dim) && + (!es2->elements || !es2->elements->dim)) + cmp = 1; // both arrays are empty + else if (!es1->elements || !es2->elements) + cmp = 0; + else if (es1->elements->dim != es2->elements->dim) + cmp = 0; + else + { + for (size_t i = 0; i < es1->elements->dim; i++) + { Expression *ee1 = (*es1->elements)[i]; + Expression *ee2 = (*es2->elements)[i]; + + Expression *v = Equal(TOKequal, Type::tint32, ee1, ee2); + if (v == EXP_CANT_INTERPRET) + return EXP_CANT_INTERPRET; + cmp = v->toInteger(); + if (cmp == 0) + break; + } + } + } + else if (e1->op == TOKarrayliteral && e2->op == TOKstring) + { // Swap operands and use common code + Expression *etmp = e1; + e1 = e2; + e2 = etmp; + goto Lsa; + } + else if (e1->op == TOKstring && e2->op == TOKarrayliteral) + { + Lsa: + StringExp *es1 = (StringExp *)e1; + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + size_t dim1 = es1->len; + size_t dim2 = es2->elements ? es2->elements->dim : 0; + if (dim1 != dim2) + cmp = 0; + else + { + cmp = 1; // if dim1 winds up being 0 + for (size_t i = 0; i < dim1; i++) + { + uinteger_t c = es1->charAt(i); + Expression *ee2 = (*es2->elements)[i]; + if (ee2->isConst() != 1) + return EXP_CANT_INTERPRET; + cmp = (c == ee2->toInteger()); + if (cmp == 0) + break; + } + } + } + else if (e1->op == TOKstructliteral && e2->op == TOKstructliteral) + { StructLiteralExp *es1 = (StructLiteralExp *)e1; + StructLiteralExp *es2 = (StructLiteralExp *)e2; + + if (es1->sd != es2->sd) + cmp = 0; + else if ((!es1->elements || !es1->elements->dim) && + (!es2->elements || !es2->elements->dim)) + cmp = 1; // both arrays are empty + else if (!es1->elements || !es2->elements) + cmp = 0; + else if (es1->elements->dim != es2->elements->dim) + cmp = 0; + else + { + cmp = 1; + for (size_t i = 0; i < es1->elements->dim; i++) + { Expression *ee1 = (*es1->elements)[i]; + Expression *ee2 = (*es2->elements)[i]; + + if (ee1 == ee2) + continue; + if (!ee1 || !ee2) + { cmp = 0; + break; + } + Expression *v = Equal(TOKequal, Type::tint32, ee1, ee2); + if (v == EXP_CANT_INTERPRET) + return EXP_CANT_INTERPRET; + cmp = v->toInteger(); + if (cmp == 0) + break; + } + } + } +#if 0 // Should handle this + else if (e1->op == TOKarrayliteral && e2->op == TOKstring) + { + } +#endif + else if (e1->isConst() != 1 || e2->isConst() != 1) + return EXP_CANT_INTERPRET; + else if (e1->type->isreal()) + { + r1 = e1->toReal(); + r2 = e2->toReal(); + goto L1; + } + else if (e1->type->isimaginary()) + { + r1 = e1->toImaginary(); + r2 = e2->toImaginary(); + L1: +#if __DMC__ + cmp = (r1 == r2); +#else + if (Port::isNan(r1) || Port::isNan(r2)) // if unordered + { + cmp = 0; + } + else + { + cmp = (r1 == r2); + } +#endif + } + else if (e1->type->iscomplex()) + { + cmp = e1->toComplex() == e2->toComplex(); + } + else if (e1->type->isintegral() || e1->type->toBasetype()->ty == Tpointer) + { + cmp = (e1->toInteger() == e2->toInteger()); + } + else + return EXP_CANT_INTERPRET; + if (op == TOKnotequal) + cmp ^= 1; + e = new IntegerExp(loc, cmp, type); + return e; +} + +Expression *Identity(enum TOK op, Type *type, Expression *e1, Expression *e2) +{ + Loc loc = e1->loc; + int cmp; + + if (e1->op == TOKnull) + { + cmp = (e2->op == TOKnull); + } + else if (e2->op == TOKnull) + { + cmp = 0; + } + else if (e1->op == TOKsymoff && e2->op == TOKsymoff) + { + SymOffExp *es1 = (SymOffExp *)e1; + SymOffExp *es2 = (SymOffExp *)e2; + + cmp = (es1->var == es2->var && es1->offset == es2->offset); + } + else + { + if (e1->type->isreal()) + { + cmp = RealEquals(e1->toReal(), e2->toReal()); + } + else if (e1->type->isimaginary()) + { + cmp = RealEquals(e1->toImaginary(), e2->toImaginary()); + } + else if (e1->type->iscomplex()) + { + complex_t v1 = e1->toComplex(); + complex_t v2 = e2->toComplex(); + cmp = RealEquals(creall(v1), creall(v2)) && + RealEquals(cimagl(v1), cimagl(v1)); + } + else + return Equal((op == TOKidentity) ? TOKequal : TOKnotequal, + type, e1, e2); + } + if (op == TOKnotidentity) + cmp ^= 1; + return new IntegerExp(loc, cmp, type); +} + + +Expression *Cmp(enum TOK op, Type *type, Expression *e1, Expression *e2) +{ Expression *e; + Loc loc = e1->loc; + dinteger_t n; + real_t r1; + real_t r2; + + //printf("Cmp(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars()); + + if (e1->op == TOKstring && e2->op == TOKstring) + { StringExp *es1 = (StringExp *)e1; + StringExp *es2 = (StringExp *)e2; + size_t sz = es1->sz; + assert(sz == es2->sz); + + size_t len = es1->len; + if (es2->len < len) + len = es2->len; + + int cmp = memcmp(es1->string, es2->string, sz * len); + if (cmp == 0) + cmp = es1->len - es2->len; + + switch (op) + { + case TOKlt: n = cmp < 0; break; + case TOKle: n = cmp <= 0; break; + case TOKgt: n = cmp > 0; break; + case TOKge: n = cmp >= 0; break; + + case TOKleg: n = 1; break; + case TOKlg: n = cmp != 0; break; + case TOKunord: n = 0; break; + case TOKue: n = cmp == 0; break; + case TOKug: n = cmp > 0; break; + case TOKuge: n = cmp >= 0; break; + case TOKul: n = cmp < 0; break; + case TOKule: n = cmp <= 0; break; + + default: + assert(0); + } + } + else if (e1->isConst() != 1 || e2->isConst() != 1) + return EXP_CANT_INTERPRET; + else if (e1->type->isreal()) + { + r1 = e1->toReal(); + r2 = e2->toReal(); + goto L1; + } + else if (e1->type->isimaginary()) + { + r1 = e1->toImaginary(); + r2 = e2->toImaginary(); + L1: +#if __DMC__ + // DMC is the only compiler I know of that handles NAN arguments + // correctly in comparisons. + switch (op) + { + case TOKlt: n = r1 < r2; break; + case TOKle: n = r1 <= r2; break; + case TOKgt: n = r1 > r2; break; + case TOKge: n = r1 >= r2; break; + + case TOKleg: n = r1 <>= r2; break; + case TOKlg: n = r1 <> r2; break; + case TOKunord: n = r1 !<>= r2; break; + case TOKue: n = r1 !<> r2; break; + case TOKug: n = r1 !<= r2; break; + case TOKuge: n = r1 !< r2; break; + case TOKul: n = r1 !>= r2; break; + case TOKule: n = r1 !> r2; break; + + default: + assert(0); + } +#else + // Don't rely on compiler, handle NAN arguments separately + if (Port::isNan(r1) || Port::isNan(r2)) // if unordered + { + switch (op) + { + case TOKlt: n = 0; break; + case TOKle: n = 0; break; + case TOKgt: n = 0; break; + case TOKge: n = 0; break; + + case TOKleg: n = 0; break; + case TOKlg: n = 0; break; + case TOKunord: n = 1; break; + case TOKue: n = 1; break; + case TOKug: n = 1; break; + case TOKuge: n = 1; break; + case TOKul: n = 1; break; + case TOKule: n = 1; break; + + default: + assert(0); + } + } + else + { + switch (op) + { + case TOKlt: n = r1 < r2; break; + case TOKle: n = r1 <= r2; break; + case TOKgt: n = r1 > r2; break; + case TOKge: n = r1 >= r2; break; + + case TOKleg: n = 1; break; + case TOKlg: n = r1 != r2; break; + case TOKunord: n = 0; break; + case TOKue: n = r1 == r2; break; + case TOKug: n = r1 > r2; break; + case TOKuge: n = r1 >= r2; break; + case TOKul: n = r1 < r2; break; + case TOKule: n = r1 <= r2; break; + + default: + assert(0); + } + } +#endif + } + else if (e1->type->iscomplex()) + { + assert(0); + } + else + { sinteger_t n1; + sinteger_t n2; + + n1 = e1->toInteger(); + n2 = e2->toInteger(); + if (e1->type->isunsigned() || e2->type->isunsigned()) + { + switch (op) + { + case TOKlt: n = ((d_uns64) n1) < ((d_uns64) n2); break; + case TOKle: n = ((d_uns64) n1) <= ((d_uns64) n2); break; + case TOKgt: n = ((d_uns64) n1) > ((d_uns64) n2); break; + case TOKge: n = ((d_uns64) n1) >= ((d_uns64) n2); break; + + case TOKleg: n = 1; break; + case TOKlg: n = ((d_uns64) n1) != ((d_uns64) n2); break; + case TOKunord: n = 0; break; + case TOKue: n = ((d_uns64) n1) == ((d_uns64) n2); break; + case TOKug: n = ((d_uns64) n1) > ((d_uns64) n2); break; + case TOKuge: n = ((d_uns64) n1) >= ((d_uns64) n2); break; + case TOKul: n = ((d_uns64) n1) < ((d_uns64) n2); break; + case TOKule: n = ((d_uns64) n1) <= ((d_uns64) n2); break; + + default: + assert(0); + } + } + else + { + switch (op) + { + case TOKlt: n = n1 < n2; break; + case TOKle: n = n1 <= n2; break; + case TOKgt: n = n1 > n2; break; + case TOKge: n = n1 >= n2; break; + + case TOKleg: n = 1; break; + case TOKlg: n = n1 != n2; break; + case TOKunord: n = 0; break; + case TOKue: n = n1 == n2; break; + case TOKug: n = n1 > n2; break; + case TOKuge: n = n1 >= n2; break; + case TOKul: n = n1 < n2; break; + case TOKule: n = n1 <= n2; break; + + default: + assert(0); + } + } + } + e = new IntegerExp(loc, n, type); + return e; +} + +/* Also returns EXP_CANT_INTERPRET if cannot be computed. + * to: type to cast to + * type: type to paint the result + */ + +Expression *Cast(Type *type, Type *to, Expression *e1) +{ Expression *e = EXP_CANT_INTERPRET; + Loc loc = e1->loc; + + //printf("Cast(type = %s, to = %s, e1 = %s)\n", type->toChars(), to->toChars(), e1->toChars()); + //printf("\te1->type = %s\n", e1->type->toChars()); + if (e1->type->equals(type) && type->equals(to)) + return e1; + if (e1->type->implicitConvTo(to) >= MATCHconst || + to->implicitConvTo(e1->type) >= MATCHconst) + return expType(to, e1); + + // Allow covariant converions of delegates + // (Perhaps implicit conversion from pure to impure should be a MATCHconst, + // then we wouldn't need this extra check.) + if (e1->type->toBasetype()->ty == Tdelegate && + e1->type->implicitConvTo(to) == MATCHconvert) + return expType(to, e1); + + Type *tb = to->toBasetype(); + Type *typeb = type->toBasetype(); + + /* Allow casting from one string type to another + */ + if (e1->op == TOKstring) + { + if (tb->ty == Tarray && typeb->ty == Tarray && + tb->nextOf()->size() == typeb->nextOf()->size()) + { + return expType(to, e1); + } + } + + if (e1->op == TOKarrayliteral && typeb == tb) + return e1; + + if (e1->isConst() != 1) + return EXP_CANT_INTERPRET; + + if (tb->ty == Tbool) + e = new IntegerExp(loc, e1->toInteger() != 0, type); + else if (type->isintegral()) + { + if (e1->type->isfloating()) + { dinteger_t result; + real_t r = e1->toReal(); + + switch (typeb->ty) + { + case Tint8: result = (d_int8)r; break; + case Tchar: + case Tuns8: result = (d_uns8)r; break; + case Tint16: result = (d_int16)r; break; + case Twchar: + case Tuns16: result = (d_uns16)r; break; + case Tint32: result = (d_int32)r; break; + case Tdchar: + case Tuns32: result = (d_uns32)r; break; + case Tint64: result = (d_int64)r; break; + case Tuns64: result = (d_uns64)r; break; + default: + assert(0); + } + + e = new IntegerExp(loc, result, type); + } + else if (type->isunsigned()) + e = new IntegerExp(loc, e1->toUInteger(), type); + else + e = new IntegerExp(loc, e1->toInteger(), type); + } + else if (tb->isreal()) + { real_t value = e1->toReal(); + + e = new RealExp(loc, value, type); + } + else if (tb->isimaginary()) + { real_t value = e1->toImaginary(); + + e = new RealExp(loc, value, type); + } + else if (tb->iscomplex()) + { complex_t value = e1->toComplex(); + + e = new ComplexExp(loc, value, type); + } + else if (tb->isscalar()) + e = new IntegerExp(loc, e1->toInteger(), type); + else if (tb->ty == Tvoid) + e = EXP_CANT_INTERPRET; + else if (tb->ty == Tstruct && e1->op == TOKint64) + { // Struct = 0; + StructDeclaration *sd = tb->toDsymbol(NULL)->isStructDeclaration(); + assert(sd); + Expressions *elements = new Expressions; + for (size_t i = 0; i < sd->fields.dim; i++) + { Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + + Expression *exp = new IntegerExp(0); + exp = Cast(v->type, v->type, exp); + if (exp == EXP_CANT_INTERPRET) + return exp; + elements->push(exp); + } + e = new StructLiteralExp(loc, sd, elements); + e->type = type; + } + else + { + if (type != Type::terror) + error(loc, "cannot cast %s to %s", e1->type->toChars(), type->toChars()); + e = new ErrorExp(); + } + return e; +} + + +Expression *ArrayLength(Type *type, Expression *e1) +{ Expression *e; + Loc loc = e1->loc; + + if (e1->op == TOKstring) + { StringExp *es1 = (StringExp *)e1; + + e = new IntegerExp(loc, es1->len, type); + } + else if (e1->op == TOKarrayliteral) + { ArrayLiteralExp *ale = (ArrayLiteralExp *)e1; + size_t dim; + + dim = ale->elements ? ale->elements->dim : 0; + e = new IntegerExp(loc, dim, type); + } + else if (e1->op == TOKassocarrayliteral) + { AssocArrayLiteralExp *ale = (AssocArrayLiteralExp *)e1; + size_t dim = ale->keys->dim; + + e = new IntegerExp(loc, dim, type); + } + else + e = EXP_CANT_INTERPRET; + return e; +} + +/* Also return EXP_CANT_INTERPRET if this fails + */ +Expression *Index(Type *type, Expression *e1, Expression *e2) +{ Expression *e = EXP_CANT_INTERPRET; + Loc loc = e1->loc; + + //printf("Index(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars()); + assert(e1->type); + if (e1->op == TOKstring && e2->op == TOKint64) + { StringExp *es1 = (StringExp *)e1; + uinteger_t i = e2->toInteger(); + + if (i >= es1->len) + { + e1->error("string index %ju is out of bounds [0 .. %zu]", i, es1->len); + e = new ErrorExp(); + } + else + { + e = new IntegerExp(loc, es1->charAt(i), type); + } + } + else if (e1->type->toBasetype()->ty == Tsarray && e2->op == TOKint64) + { TypeSArray *tsa = (TypeSArray *)e1->type->toBasetype(); + uinteger_t length = tsa->dim->toInteger(); + uinteger_t i = e2->toInteger(); + + if (i >= length) + { + e1->error("array index %ju is out of bounds %s[0 .. %ju]", i, e1->toChars(), length); + e = new ErrorExp(); + } + else if (e1->op == TOKarrayliteral) + { ArrayLiteralExp *ale = (ArrayLiteralExp *)e1; + e = ale->elements->tdata()[i]; + e->type = type; + if (e->hasSideEffect()) + e = EXP_CANT_INTERPRET; + } + } + else if (e1->type->toBasetype()->ty == Tarray && e2->op == TOKint64) + { + uinteger_t i = e2->toInteger(); + + if (e1->op == TOKarrayliteral) + { ArrayLiteralExp *ale = (ArrayLiteralExp *)e1; + if (i >= ale->elements->dim) + { + e1->error("array index %ju is out of bounds %s[0 .. %u]", i, e1->toChars(), ale->elements->dim); + e = new ErrorExp(); + } + else + { e = ale->elements->tdata()[i]; + e->type = type; + if (e->hasSideEffect()) + e = EXP_CANT_INTERPRET; + } + } + } + else if (e1->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e1; + /* Search the keys backwards, in case there are duplicate keys + */ + for (size_t i = ae->keys->dim; i;) + { + i--; + Expression *ekey = ae->keys->tdata()[i]; + Expression *ex = Equal(TOKequal, Type::tbool, ekey, e2); + if (ex == EXP_CANT_INTERPRET) + return ex; + if (ex->isBool(TRUE)) + { e = ae->values->tdata()[i]; + e->type = type; + if (e->hasSideEffect()) + e = EXP_CANT_INTERPRET; + break; + } + } + } + return e; +} + +/* Also return EXP_CANT_INTERPRET if this fails + */ +Expression *Slice(Type *type, Expression *e1, Expression *lwr, Expression *upr) +{ Expression *e = EXP_CANT_INTERPRET; + Loc loc = e1->loc; + +#if LOG + printf("Slice()\n"); + if (lwr) + { printf("\te1 = %s\n", e1->toChars()); + printf("\tlwr = %s\n", lwr->toChars()); + printf("\tupr = %s\n", upr->toChars()); + } +#endif + if (e1->op == TOKstring && lwr->op == TOKint64 && upr->op == TOKint64) + { StringExp *es1 = (StringExp *)e1; + uinteger_t ilwr = lwr->toInteger(); + uinteger_t iupr = upr->toInteger(); + + if (iupr > es1->len || ilwr > iupr) + { + e1->error("string slice [%ju .. %ju] is out of bounds", ilwr, iupr); + e = new ErrorExp(); + } + else + { + void *s; + size_t len = iupr - ilwr; + int sz = es1->sz; + StringExp *es; + + s = mem.malloc((len + 1) * sz); + memcpy((unsigned char *)s, (unsigned char *)es1->string + ilwr * sz, len * sz); + memset((unsigned char *)s + len * sz, 0, sz); + + es = new StringExp(loc, s, len, es1->postfix); + es->sz = sz; + es->committed = 1; + es->type = type; + e = es; + } + } + else if (e1->op == TOKarrayliteral && + lwr->op == TOKint64 && upr->op == TOKint64 && + !e1->hasSideEffect()) + { ArrayLiteralExp *es1 = (ArrayLiteralExp *)e1; + uinteger_t ilwr = lwr->toInteger(); + uinteger_t iupr = upr->toInteger(); + + if (iupr > es1->elements->dim || ilwr > iupr) + { + e1->error("array slice [%ju .. %ju] is out of bounds", ilwr, iupr); + e = new ErrorExp(); + } + else + { + Expressions *elements = new Expressions(); + elements->setDim(iupr - ilwr); + memcpy(elements->tdata(), + es1->elements->tdata() + ilwr, + (iupr - ilwr) * sizeof(es1->elements->tdata()[0])); + e = new ArrayLiteralExp(e1->loc, elements); + e->type = type; + } + } + return e; +} + +/* Set a slice of char array literal 'existingAE' from a string 'newval'. + * existingAE[firstIndex..firstIndex+newval.length] = newval. + */ +void sliceAssignArrayLiteralFromString(ArrayLiteralExp *existingAE, StringExp *newval, int firstIndex) +{ + size_t newlen = newval->len; + size_t sz = newval->sz; + unsigned char *s = (unsigned char *)newval->string; + Type *elemType = existingAE->type->nextOf(); + for (size_t j = 0; j < newlen; j++) + { + dinteger_t val; + switch (sz) + { + case 1: val = s[j]; break; + case 2: val = ((unsigned short *)s)[j]; break; + case 4: val = ((unsigned *)s)[j]; break; + default: + assert(0); + break; + } + existingAE->elements->tdata()[j+firstIndex] + = new IntegerExp(newval->loc, val, elemType); + } +} + +/* Set a slice of string 'existingSE' from a char array literal 'newae'. + * existingSE[firstIndex..firstIndex+newae.length] = newae. + */ +void sliceAssignStringFromArrayLiteral(StringExp *existingSE, ArrayLiteralExp *newae, int firstIndex) +{ + unsigned char *s = (unsigned char *)existingSE->string; + for (size_t j = 0; j < newae->elements->dim; j++) + { + unsigned value = (unsigned)(newae->elements->tdata()[j]->toInteger()); + switch (existingSE->sz) + { + case 1: s[j+firstIndex] = value; break; + case 2: ((unsigned short *)s)[j+firstIndex] = value; break; + case 4: ((unsigned *)s)[j+firstIndex] = value; break; + default: + assert(0); + break; + } + } +} + +/* Set a slice of string 'existingSE' from a string 'newstr'. + * existingSE[firstIndex..firstIndex+newstr.length] = newstr. + */ +void sliceAssignStringFromString(StringExp *existingSE, StringExp *newstr, int firstIndex) +{ + unsigned char *s = (unsigned char *)existingSE->string; + size_t sz = existingSE->sz; + assert(sz == newstr->sz); + memcpy(s + firstIndex * sz, newstr->string, sz * newstr->len); +} + +/* Also return EXP_CANT_INTERPRET if this fails + */ +Expression *Cat(Type *type, Expression *e1, Expression *e2) +{ Expression *e = EXP_CANT_INTERPRET; + Loc loc = e1->loc; + Type *t; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + + //printf("Cat(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars()); + //printf("\tt1 = %s, t2 = %s, type = %s\n", t1->toChars(), t2->toChars(), type->toChars()); + + if (e1->op == TOKnull && (e2->op == TOKint64 || e2->op == TOKstructliteral)) + { e = e2; + t = t1; + goto L2; + } + else if ((e1->op == TOKint64 || e1->op == TOKstructliteral) && e2->op == TOKnull) + { e = e1; + t = t2; + L2: + Type *tn = e->type->toBasetype(); + if (tn->ty == Tchar || tn->ty == Twchar || tn->ty == Tdchar) + { + // Create a StringExp + void *s; + StringExp *es; + if (t->nextOf()) + t = t->nextOf()->toBasetype(); + int sz = t->size(); + + dinteger_t v = e->toInteger(); + + size_t len = (t->ty == tn->ty) ? 1 : utf_codeLength(sz, v); + s = mem.malloc((len + 1) * sz); + if (t->ty == tn->ty) + memcpy((unsigned char *)s, &v, sz); + else + utf_encode(sz, s, v); + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = 1; + e = es; + } + else + { // Create an ArrayLiteralExp + Expressions *elements = new Expressions(); + elements->push(e); + e = new ArrayLiteralExp(e->loc, elements); + } + e->type = type; + return e; + } + else if (e1->op == TOKnull && e2->op == TOKnull) + { + if (type == e1->type) + { + // Handle null ~= null + if (t1->ty == Tarray && t2 == t1->nextOf()) + { + e = new ArrayLiteralExp(e1->loc, e2); + e->type = type; + return e; + } + else + return e1; + } + if (type == e2->type) + return e2; + return new NullExp(e1->loc, type); + } + else if (e1->op == TOKstring && e2->op == TOKstring) + { + // Concatenate the strings + void *s; + StringExp *es1 = (StringExp *)e1; + StringExp *es2 = (StringExp *)e2; + StringExp *es; + size_t len = es1->len + es2->len; + int sz = es1->sz; + + if (sz != es2->sz) + { + /* Can happen with: + * auto s = "foo"d ~ "bar"c; + */ + assert(global.errors); + return e; + } + s = mem.malloc((len + 1) * sz); + memcpy(s, es1->string, es1->len * sz); + memcpy((unsigned char *)s + es1->len * sz, es2->string, es2->len * sz); + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = es1->committed | es2->committed; + es->type = type; + e = es; + } + else if (e2->op == TOKstring && e1->op == TOKarrayliteral && + t1->nextOf()->isintegral()) + { + // [chars] ~ string --> [chars] + StringExp *es = (StringExp *)e2; + ArrayLiteralExp *ea = (ArrayLiteralExp *)e1; + size_t len = es->len + ea->elements->dim; + Expressions * elems = new Expressions; + elems->setDim(len); + for (size_t i= 0; i < ea->elements->dim; ++i) + { + elems->tdata()[i] = ea->elements->tdata()[i]; + } + ArrayLiteralExp *dest = new ArrayLiteralExp(e1->loc, elems); + dest->type = type; + sliceAssignArrayLiteralFromString(dest, es, ea->elements->dim); + return dest; + } + else if (e1->op == TOKstring && e2->op == TOKarrayliteral && + t2->nextOf()->isintegral()) + { + // string ~ [chars] --> [chars] + StringExp *es = (StringExp *)e1; + ArrayLiteralExp *ea = (ArrayLiteralExp *)e2; + size_t len = es->len + ea->elements->dim; + Expressions * elems = new Expressions; + elems->setDim(len); + for (size_t i= 0; i < ea->elements->dim; ++i) + { + elems->tdata()[es->len + i] = ea->elements->tdata()[i]; + } + ArrayLiteralExp *dest = new ArrayLiteralExp(e1->loc, elems); + dest->type = type; + sliceAssignArrayLiteralFromString(dest, es, 0); + return dest; + } + else if (e1->op == TOKstring && e2->op == TOKint64) + { + // string ~ char --> string + void *s; + StringExp *es1 = (StringExp *)e1; + StringExp *es; + int sz = es1->sz; + dinteger_t v = e2->toInteger(); + + // Is it a concatentation of homogenous types? + // (char[] ~ char, wchar[]~wchar, or dchar[]~dchar) + bool homoConcat = (sz == t2->size()); + size_t len = es1->len; + len += homoConcat ? 1 : utf_codeLength(sz, v); + + s = mem.malloc((len + 1) * sz); + memcpy(s, es1->string, es1->len * sz); + if (homoConcat) + memcpy((unsigned char *)s + (sz * es1->len), &v, sz); + else + utf_encode(sz, (unsigned char *)s + (sz * es1->len), v); + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = es1->committed; + es->type = type; + e = es; + } + else if (e1->op == TOKint64 && e2->op == TOKstring) + { + // Concatenate the strings + void *s; + StringExp *es2 = (StringExp *)e2; + StringExp *es; + size_t len = 1 + es2->len; + int sz = es2->sz; + dinteger_t v = e1->toInteger(); + + s = mem.malloc((len + 1) * sz); + memcpy((unsigned char *)s, &v, sz); + memcpy((unsigned char *)s + sz, es2->string, es2->len * sz); + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = es2->committed; + es->type = type; + e = es; + } + else if (e1->op == TOKarrayliteral && e2->op == TOKarrayliteral && + t1->nextOf()->equals(t2->nextOf())) + { + // Concatenate the arrays + ArrayLiteralExp *es1 = (ArrayLiteralExp *)e1; + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + + es1 = new ArrayLiteralExp(es1->loc, (Expressions *)es1->elements->copy()); + es1->elements->insert(es1->elements->dim, es2->elements); + e = es1; + + if (type->toBasetype()->ty == Tsarray) + { + e->type = new TypeSArray(t1->nextOf(), new IntegerExp(loc, es1->elements->dim, Type::tindex)); + e->type = e->type->semantic(loc, NULL); + } + else + e->type = type; + } + else if (e1->op == TOKarrayliteral && e2->op == TOKnull && + t1->nextOf()->equals(t2->nextOf())) + { + e = e1; + goto L3; + } + else if (e1->op == TOKnull && e2->op == TOKarrayliteral && + t1->nextOf()->equals(t2->nextOf())) + { + e = e2; + L3: + // Concatenate the array with null + ArrayLiteralExp *es = (ArrayLiteralExp *)e; + + es = new ArrayLiteralExp(es->loc, (Expressions *)es->elements->copy()); + e = es; + + if (type->toBasetype()->ty == Tsarray) + { + e->type = new TypeSArray(t1->nextOf(), new IntegerExp(loc, es->elements->dim, Type::tindex)); + e->type = e->type->semantic(loc, NULL); + } + else + e->type = type; + } + else if ((e1->op == TOKarrayliteral || e1->op == TOKnull) && + e1->type->toBasetype()->nextOf()->equals(e2->type)) + { + ArrayLiteralExp *es1; + if (e1->op == TOKarrayliteral) + { es1 = (ArrayLiteralExp *)e1; + es1 = new ArrayLiteralExp(es1->loc, (Expressions *)es1->elements->copy()); + es1->elements->push(e2); + } + else + { + es1 = new ArrayLiteralExp(e1->loc, e2); + } + e = es1; + + if (type->toBasetype()->ty == Tsarray) + { + e->type = new TypeSArray(e2->type, new IntegerExp(loc, es1->elements->dim, Type::tindex)); + e->type = e->type->semantic(loc, NULL); + } + else + e->type = type; + } + else if (e2->op == TOKarrayliteral && + e2->type->toBasetype()->nextOf()->equals(e1->type)) + { + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + + es2 = new ArrayLiteralExp(es2->loc, (Expressions *)es2->elements->copy()); + es2->elements->shift(e1); + e = es2; + + if (type->toBasetype()->ty == Tsarray) + { + e->type = new TypeSArray(e1->type, new IntegerExp(loc, es2->elements->dim, Type::tindex)); + e->type = e->type->semantic(loc, NULL); + } + else + e->type = type; + } + else if (e1->op == TOKnull && e2->op == TOKstring) + { + t = e1->type; + e = e2; + goto L1; + } + else if (e1->op == TOKstring && e2->op == TOKnull) + { e = e1; + t = e2->type; + L1: + Type *tb = t->toBasetype(); + if (tb->ty == Tarray && tb->nextOf()->equals(e->type)) + { Expressions *expressions = new Expressions(); + expressions->push(e); + e = new ArrayLiteralExp(loc, expressions); + e->type = t; + } + if (!e->type->equals(type)) + { StringExp *se = (StringExp *)e->copy(); + e = se->castTo(NULL, type); + } + } + return e; +} + +Expression *Ptr(Type *type, Expression *e1) +{ + //printf("Ptr(e1 = %s)\n", e1->toChars()); + if (e1->op == TOKadd) + { AddExp *ae = (AddExp *)e1; + if (ae->e1->op == TOKaddress && ae->e2->op == TOKint64) + { AddrExp *ade = (AddrExp *)ae->e1; + if (ade->e1->op == TOKstructliteral) + { StructLiteralExp *se = (StructLiteralExp *)ade->e1; + unsigned offset = ae->e2->toInteger(); + Expression *e = se->getField(type, offset); + if (!e) + e = EXP_CANT_INTERPRET; + return e; + } + } + } + return EXP_CANT_INTERPRET; +} + diff --git a/cppmangle.c b/cppmangle.c new file mode 100644 index 00000000..630567ef --- /dev/null +++ b/cppmangle.c @@ -0,0 +1,454 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "dsymbol.h" +#include "mtype.h" +#include "scope.h" +#include "init.h" +#include "expression.h" +#include "attrib.h" +#include "declaration.h" +#include "template.h" +#include "id.h" +#include "enum.h" +#include "import.h" +#include "aggregate.h" + +#if CPP_MANGLE + +/* Do mangling for C++ linkage. + * Follows Itanium C++ ABI 1.86 + * No attempt is made to support mangling of templates, operator + * overloading, or special functions. + * + * So why don't we use the C++ ABI for D name mangling? + * Because D supports a lot of things (like modules) that the C++ + * ABI has no concept of. These affect every D mangled name, + * so nothing would be compatible anyway. + */ + +struct CppMangleState +{ + static Voids components; + + int substitute(OutBuffer *buf, void *p); + int exist(void *p); + void store(void *p); +}; + +Voids CppMangleState::components; + + +void writeBase36(OutBuffer *buf, unsigned i) +{ + if (i >= 36) + { + writeBase36(buf, i / 36); + i %= 36; + } + if (i < 10) + buf->writeByte(i + '0'); + else if (i < 36) + buf->writeByte(i - 10 + 'A'); + else + assert(0); +} + +int CppMangleState::substitute(OutBuffer *buf, void *p) +{ + for (size_t i = 0; i < components.dim; i++) + { + if (p == components.tdata()[i]) + { + /* Sequence is S_, S0_, .., S9_, SA_, ..., SZ_, S10_, ... + */ + buf->writeByte('S'); + if (i) + writeBase36(buf, i - 1); + buf->writeByte('_'); + return 1; + } + } + components.push(p); + return 0; +} + +int CppMangleState::exist(void *p) +{ + for (size_t i = 0; i < components.dim; i++) + { + if (p == components.tdata()[i]) + { + return 1; + } + } + return 0; +} + +void CppMangleState::store(void *p) +{ + components.push(p); +} + +void source_name(OutBuffer *buf, Dsymbol *s) +{ + char *name = s->ident->toChars(); + buf->printf("%d%s", strlen(name), name); +} + +void prefix_name(OutBuffer *buf, CppMangleState *cms, Dsymbol *s) +{ + if (!cms->substitute(buf, s)) + { + Dsymbol *p = s->toParent(); + if (p && !p->isModule()) + { + prefix_name(buf, cms, p); + } + source_name(buf, s); + } +} + +void cpp_mangle_name(OutBuffer *buf, CppMangleState *cms, Dsymbol *s) +{ + Dsymbol *p = s->toParent(); + if (p && !p->isModule()) + { + buf->writeByte('N'); + + FuncDeclaration *fd = s->isFuncDeclaration(); + if (!fd) + { + s->error("C++ static variables not supported"); + } + else + if (fd->isConst()) + buf->writeByte('K'); + + prefix_name(buf, cms, p); + source_name(buf, s); + + buf->writeByte('E'); + } + else + source_name(buf, s); +} + + +char *cpp_mangle(Dsymbol *s) +{ + /* + * ::= _Z + * ::= + * ::= + * ::= + */ + + CppMangleState cms; + memset(&cms, 0, sizeof(cms)); + cms.components.setDim(0); + + OutBuffer buf; +#if MACHOBJ + buf.writestring("__Z"); +#else + buf.writestring("_Z"); +#endif + + cpp_mangle_name(&buf, &cms, s); + + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { // add + TypeFunction *tf = (TypeFunction *)fd->type; + assert(tf->ty == Tfunction); + Parameter::argsCppMangle(&buf, &cms, tf->parameters, tf->varargs); + } + buf.writeByte(0); + return (char *)buf.extractData(); +} + +/* ============= Type Encodings ============================================= */ + +void Type::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + /* Make this the 'vendor extended type' when there is no + * C++ analog. + * u + */ + if (!cms->substitute(buf, this)) + { assert(deco); + buf->printf("u%d%s", strlen(deco), deco); + } +} + +void TypeBasic::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ char c; + char p = 0; + + /* ABI spec says: + * v void + * w wchar_t + * b bool + * c char + * a signed char + * h unsigned char + * s short + * t unsigned short + * i int + * j unsigned int + * l long + * m unsigned long + * x long long, __int64 + * y unsigned long long, __int64 + * n __int128 + * o unsigned __int128 + * f float + * d double + * e long double, __float80 + * g __float128 + * z ellipsis + * u # vendor extended type + */ + + switch (ty) + { + case Tvoid: c = 'v'; break; + case Tint8: c = 'a'; break; + case Tuns8: c = 'h'; break; + case Tint16: c = 's'; break; + case Tuns16: c = 't'; break; + case Tint32: c = 'i'; break; + case Tuns32: c = 'j'; break; + case Tfloat32: c = 'f'; break; + case Tint64: c = 'x'; break; + case Tuns64: c = 'y'; break; + case Tfloat64: c = 'd'; break; + case Tfloat80: c = 'e'; break; + case Tbool: c = 'b'; break; + case Tchar: c = 'c'; break; + case Twchar: c = 't'; break; + case Tdchar: c = 'w'; break; + + case Timaginary32: p = 'G'; c = 'f'; break; + case Timaginary64: p = 'G'; c = 'd'; break; + case Timaginary80: p = 'G'; c = 'e'; break; + case Tcomplex32: p = 'C'; c = 'f'; break; + case Tcomplex64: p = 'C'; c = 'd'; break; + case Tcomplex80: p = 'C'; c = 'e'; break; + + default: assert(0); + } + if (p || isConst()) + { + if (cms->substitute(buf, this)) + return; + } + + if (isConst()) + buf->writeByte('K'); + + if (p) + buf->writeByte(p); + + buf->writeByte(c); +} + + +void TypeVector::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->substitute(buf, this)) + { buf->writestring("U8__vector"); + basetype->toCppMangle(buf, cms); + } +} + +void TypeSArray::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->substitute(buf, this)) + { buf->printf("A%ju_", dim ? dim->toInteger() : 0); + next->toCppMangle(buf, cms); + } +} + +void TypeDArray::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + Type::toCppMangle(buf, cms); +} + + +void TypeAArray::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + Type::toCppMangle(buf, cms); +} + + +void TypePointer::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->exist(this)) + { buf->writeByte('P'); + next->toCppMangle(buf, cms); + cms->store(this); + } + else + cms->substitute(buf, this); +} + + +void TypeReference::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->exist(this)) + { buf->writeByte('R'); + next->toCppMangle(buf, cms); + cms->store(this); + } + else + cms->substitute(buf, this); +} + + +void TypeFunction::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ /* + * ::= F [Y] E + * ::= + + * # types are possible return type, then parameter types + */ + + /* ABI says: + "The type of a non-static member function is considered to be different, + for the purposes of substitution, from the type of a namespace-scope or + static member function whose type appears similar. The types of two + non-static member functions are considered to be different, for the + purposes of substitution, if the functions are members of different + classes. In other words, for the purposes of substitution, the class of + which the function is a member is considered part of the type of + function." + + BUG: Right now, types of functions are never merged, so our simplistic + component matcher always finds them to be different. + We should use Type::equals on these, and use different + TypeFunctions for non-static member functions, and non-static + member functions of different classes. + */ + if (!cms->substitute(buf, this)) + { + buf->writeByte('F'); + if (linkage == LINKc) + buf->writeByte('Y'); + next->toCppMangle(buf, cms); + Parameter::argsCppMangle(buf, cms, parameters, varargs); + buf->writeByte('E'); + } +} + + +void TypeDelegate::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + Type::toCppMangle(buf, cms); +} + + +void TypeStruct::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->exist(this)) + { + if (isConst()) + buf->writeByte('K'); + + if (!cms->substitute(buf, sym)) + cpp_mangle_name(buf, cms, sym); + + if (isConst()) + cms->store(this); + } + else + cms->substitute(buf, this); +} + + +void TypeEnum::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->exist(this)) + { + if (isConst()) + buf->writeByte('K'); + + if (!cms->substitute(buf, sym)) + cpp_mangle_name(buf, cms, sym); + + if (isConst()) + cms->store(this); + } + else + cms->substitute(buf, this); +} + + +void TypeTypedef::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + Type::toCppMangle(buf, cms); +} + + +void TypeClass::toCppMangle(OutBuffer *buf, CppMangleState *cms) +{ + if (!cms->substitute(buf, this)) + { buf->writeByte('P'); + if (!cms->substitute(buf, sym)) + cpp_mangle_name(buf, cms, sym); + } +} + + + +void Parameter::argsCppMangle(OutBuffer *buf, CppMangleState *cms, Parameters *arguments, int varargs) +{ int n = 0; + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { Parameter *arg = arguments->tdata()[i]; + Type *t = arg->type; + if (arg->storageClass & (STCout | STCref)) + t = t->referenceTo(); + else if (arg->storageClass & STClazy) + { // Mangle as delegate + Type *td = new TypeFunction(NULL, t, 0, LINKd); + td = new TypeDelegate(td); + t = t->merge(); + } + if (t->ty == Tsarray) + { // Mangle static arrays as pointers + t = t->pointerTo(); + } + + /* If it is a basic, enum or struct type, + * then don't mark it const + */ + if ((t->ty == Tenum || t->ty == Tstruct || t->isTypeBasic()) && t->isConst()) + t->mutableOf()->toCppMangle(buf, cms); + else + t->toCppMangle(buf, cms); + + n++; + } + } + if (varargs) + buf->writestring("z"); + else if (!n) + buf->writeByte('v'); // encode ( ) arguments +} + + +#endif + diff --git a/declaration.c b/declaration.c new file mode 100644 index 00000000..3fc3df01 --- /dev/null +++ b/declaration.c @@ -0,0 +1,2258 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "init.h" +#include "declaration.h" +#include "attrib.h" +#include "mtype.h" +#include "template.h" +#include "scope.h" +#include "aggregate.h" +#include "module.h" +#include "id.h" +#include "expression.h" +#include "statement.h" +#include "hdrgen.h" + +/********************************* Declaration ****************************/ + +Declaration::Declaration(Identifier *id) + : Dsymbol(id) +{ + type = NULL; + originalType = NULL; + storage_class = STCundefined; + protection = PROTundefined; + linkage = LINKdefault; + inuse = 0; + sem = SemanticStart; +} + +void Declaration::semantic(Scope *sc) +{ +} + +const char *Declaration::kind() +{ + return "declaration"; +} + +unsigned Declaration::size(Loc loc) +{ + assert(type); + return type->size(); +} + +int Declaration::isDelete() +{ + return FALSE; +} + +int Declaration::isDataseg() +{ + return FALSE; +} + +int Declaration::isThreadlocal() +{ + return FALSE; +} + +int Declaration::isCodeseg() +{ + return FALSE; +} + +enum PROT Declaration::prot() +{ + return protection; +} + +/************************************* + * Check to see if declaration can be modified in this context (sc). + * Issue error if not. + */ + +#if DMDV2 + +void Declaration::checkModify(Loc loc, Scope *sc, Type *t) +{ + if (sc->incontract && isParameter()) + error(loc, "cannot modify parameter '%s' in contract", toChars()); + + if (sc->incontract && isResult()) + error(loc, "cannot modify result '%s' in contract", toChars()); + + if (isCtorinit() && !t->isMutable() || + (storage_class & STCnodefaultctor)) + { // It's only modifiable if inside the right constructor + modifyFieldVar(loc, sc, isVarDeclaration(), NULL); + } + else + { + VarDeclaration *v = isVarDeclaration(); + if (v && v->canassign == 0) + { + const char *p = NULL; + if (isConst()) + p = "const"; + else if (isImmutable()) + p = "immutable"; + else if (isWild()) + p = "inout"; + else if (storage_class & STCmanifest) + p = "enum"; + else if (!t->isAssignable()) + p = "struct with immutable members"; + if (p) + { error(loc, "cannot modify %s", p); + } + } + } +} +#endif + + +/********************************* TupleDeclaration ****************************/ + +TupleDeclaration::TupleDeclaration(Loc loc, Identifier *id, Objects *objects) + : Declaration(id) +{ + this->loc = loc; + this->type = NULL; + this->objects = objects; + this->isexp = 0; + this->tupletype = NULL; +} + +Dsymbol *TupleDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(0); + return NULL; +} + +const char *TupleDeclaration::kind() +{ + return "tuple"; +} + +Type *TupleDeclaration::getType() +{ + /* If this tuple represents a type, return that type + */ + + //printf("TupleDeclaration::getType() %s\n", toChars()); + if (isexp) + return NULL; + if (!tupletype) + { + /* It's only a type tuple if all the Object's are types + */ + for (size_t i = 0; i < objects->dim; i++) + { Object *o = objects->tdata()[i]; + + if (o->dyncast() != DYNCAST_TYPE) + { + //printf("\tnot[%d], %p, %d\n", i, o, o->dyncast()); + return NULL; + } + } + + /* We know it's a type tuple, so build the TypeTuple + */ + Types *types = (Types *)objects; + Parameters *args = new Parameters(); + args->setDim(objects->dim); + OutBuffer buf; + int hasdeco = 1; + for (size_t i = 0; i < types->dim; i++) + { Type *t = types->tdata()[i]; + + //printf("type = %s\n", t->toChars()); +#if 0 + buf.printf("_%s_%d", ident->toChars(), i); + char *name = (char *)buf.extractData(); + Identifier *id = new Identifier(name, TOKidentifier); + Parameter *arg = new Parameter(STCin, t, id, NULL); +#else + Parameter *arg = new Parameter(0, t, NULL, NULL); +#endif + args->tdata()[i] = arg; + if (!t->deco) + hasdeco = 0; + } + + tupletype = new TypeTuple(args); + if (hasdeco) + return tupletype->semantic(0, NULL); + } + + return tupletype; +} + +int TupleDeclaration::needThis() +{ + //printf("TupleDeclaration::needThis(%s)\n", toChars()); + for (size_t i = 0; i < objects->dim; i++) + { Object *o = objects->tdata()[i]; + if (o->dyncast() == DYNCAST_EXPRESSION) + { Expression *e = (Expression *)o; + if (e->op == TOKdsymbol) + { DsymbolExp *ve = (DsymbolExp *)e; + Declaration *d = ve->s->isDeclaration(); + if (d && d->needThis()) + { + return 1; + } + } + } + } + return 0; +} + + +/********************************* TypedefDeclaration ****************************/ + +TypedefDeclaration::TypedefDeclaration(Loc loc, Identifier *id, Type *basetype, Initializer *init) + : Declaration(id) +{ + this->type = new TypeTypedef(this); + this->basetype = basetype->toBasetype(); + this->init = init; + this->htype = NULL; + this->hbasetype = NULL; + this->loc = loc; + this->sinit = NULL; +} + +Dsymbol *TypedefDeclaration::syntaxCopy(Dsymbol *s) +{ + Type *basetype = this->basetype->syntaxCopy(); + + Initializer *init = NULL; + if (this->init) + init = this->init->syntaxCopy(); + + assert(!s); + TypedefDeclaration *st; + st = new TypedefDeclaration(loc, ident, basetype, init); + + // Syntax copy for header file + if (!htype) // Don't overwrite original + { if (type) // Make copy for both old and new instances + { htype = type->syntaxCopy(); + st->htype = type->syntaxCopy(); + } + } + else // Make copy of original for new instance + st->htype = htype->syntaxCopy(); + if (!hbasetype) + { if (basetype) + { hbasetype = basetype->syntaxCopy(); + st->hbasetype = basetype->syntaxCopy(); + } + } + else + st->hbasetype = hbasetype->syntaxCopy(); + + return st; +} + +void TypedefDeclaration::semantic(Scope *sc) +{ + //printf("TypedefDeclaration::semantic(%s) sem = %d\n", toChars(), sem); + if (sem == SemanticStart) + { sem = SemanticIn; + parent = sc->parent; + int errors = global.errors; + Type *savedbasetype = basetype; + basetype = basetype->semantic(loc, sc); + if (errors != global.errors) + { + basetype = savedbasetype; + sem = SemanticStart; + return; + } + sem = SemanticDone; +#if DMDV2 + type = type->addStorageClass(storage_class); +#endif + Type *savedtype = type; + type = type->semantic(loc, sc); + if (sc->parent->isFuncDeclaration() && init) + semantic2(sc); + if (errors != global.errors) + { + basetype = savedbasetype; + type = savedtype; + sem = SemanticStart; + return; + } + storage_class |= sc->stc & STCdeprecated; + } + else if (sem == SemanticIn) + { + error("circular definition"); + } +} + +void TypedefDeclaration::semantic2(Scope *sc) +{ + //printf("TypedefDeclaration::semantic2(%s) sem = %d\n", toChars(), sem); + if (sem == SemanticDone) + { sem = Semantic2Done; + if (init) + { + Initializer *savedinit = init; + int errors = global.errors; + init = init->semantic(sc, basetype, WANTinterpret); + if (errors != global.errors) + { + init = savedinit; + return; + } + + ExpInitializer *ie = init->isExpInitializer(); + if (ie) + { + if (ie->exp->type == basetype) + ie->exp->type = type; + } + } + } +} + +const char *TypedefDeclaration::kind() +{ + return "typedef"; +} + +Type *TypedefDeclaration::getType() +{ + return type; +} + +void TypedefDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("typedef "); + basetype->toCBuffer(buf, ident, hgs); + if (init) + { + buf->writestring(" = "); + init->toCBuffer(buf, hgs); + } + buf->writeByte(';'); + buf->writenl(); +} + +/********************************* AliasDeclaration ****************************/ + +AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Type *type) + : Declaration(id) +{ + //printf("AliasDeclaration(id = '%s', type = %p)\n", id->toChars(), type); + //printf("type = '%s'\n", type->toChars()); + this->loc = loc; + this->type = type; + this->aliassym = NULL; + this->htype = NULL; + this->haliassym = NULL; + this->overnext = NULL; + this->inSemantic = 0; + assert(type); +} + +AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Dsymbol *s) + : Declaration(id) +{ + //printf("AliasDeclaration(id = '%s', s = %p)\n", id->toChars(), s); + assert(s != this); + this->loc = loc; + this->type = NULL; + this->aliassym = s; + this->htype = NULL; + this->haliassym = NULL; + this->overnext = NULL; + this->inSemantic = 0; + assert(s); +} + +Dsymbol *AliasDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("AliasDeclaration::syntaxCopy()\n"); + assert(!s); + AliasDeclaration *sa; + if (type) + sa = new AliasDeclaration(loc, ident, type->syntaxCopy()); + else + sa = new AliasDeclaration(loc, ident, aliassym->syntaxCopy(NULL)); + + // Syntax copy for header file + if (!htype) // Don't overwrite original + { if (type) // Make copy for both old and new instances + { htype = type->syntaxCopy(); + sa->htype = type->syntaxCopy(); + } + } + else // Make copy of original for new instance + sa->htype = htype->syntaxCopy(); + if (!haliassym) + { if (aliassym) + { haliassym = aliassym->syntaxCopy(s); + sa->haliassym = aliassym->syntaxCopy(s); + } + } + else + sa->haliassym = haliassym->syntaxCopy(s); + + return sa; +} + +void AliasDeclaration::semantic(Scope *sc) +{ + //printf("AliasDeclaration::semantic() %s\n", toChars()); + if (aliassym) + { + if (aliassym->isTemplateInstance()) + aliassym->semantic(sc); + return; + } + this->inSemantic = 1; + +#if DMDV1 // don't really know why this is here + if (storage_class & STCconst) + error("cannot be const"); +#endif + + storage_class |= sc->stc & STCdeprecated; + protection = sc->protection; + + // Given: + // alias foo.bar.abc def; + // it is not knowable from the syntax whether this is an alias + // for a type or an alias for a symbol. It is up to the semantic() + // pass to distinguish. + // If it is a type, then type is set and getType() will return that + // type. If it is a symbol, then aliassym is set and type is NULL - + // toAlias() will return aliasssym. + + int errors = global.errors; + Type *savedtype = type; + + Dsymbol *s; + Type *t; + Expression *e; + + /* This section is needed because resolve() will: + * const x = 3; + * alias x y; + * try to alias y to 3. + */ + s = type->toDsymbol(sc); + if (s +#if DMDV2 + && ((s->getType() && type->equals(s->getType())) || s->isEnumMember()) +#endif + ) + goto L2; // it's a symbolic alias + +#if DMDV2 + type = type->addStorageClass(storage_class); + if (storage_class & (STCref | STCnothrow | STCpure | STCdisable)) + { // For 'ref' to be attached to function types, and picked + // up by Type::resolve(), it has to go into sc. + sc = sc->push(); + sc->stc |= storage_class & (STCref | STCnothrow | STCpure | STCshared | STCdisable); + type->resolve(loc, sc, &e, &t, &s); + sc = sc->pop(); + } + else +#endif + type->resolve(loc, sc, &e, &t, &s); + if (s) + { + goto L2; + } + else if (e) + { + // Try to convert Expression to Dsymbol + s = getDsymbol(e); + if (s) + goto L2; + + error("cannot alias an expression %s", e->toChars()); + t = e->type; + } + else if (t) + { + type = t->semantic(loc, sc); + //printf("\talias resolved to type %s\n", type->toChars()); + } + if (overnext) + ScopeDsymbol::multiplyDefined(0, this, overnext); + this->inSemantic = 0; + + if (errors != global.errors) + type = savedtype; + return; + + L2: + //printf("alias is a symbol %s %s\n", s->kind(), s->toChars()); + type = NULL; + VarDeclaration *v = s->isVarDeclaration(); + if (0 && v && v->linkage == LINKdefault) + { + error("forward reference of %s", v->toChars()); + s = NULL; + } + else + { + Dsymbol *savedovernext = overnext; + FuncDeclaration *f = s->toAlias()->isFuncDeclaration(); + if (f) + { + if (overnext) + { + FuncAliasDeclaration *fa = new FuncAliasDeclaration(f); + if (!fa->overloadInsert(overnext)) + ScopeDsymbol::multiplyDefined(0, f, overnext); + overnext = NULL; + s = fa; + s->parent = sc->parent; + } + } + if (overnext) + ScopeDsymbol::multiplyDefined(0, this, overnext); + if (s == this) + { + assert(global.errors); + s = NULL; + } + if (errors != global.errors) + { + type = savedtype; + overnext = savedovernext; + aliassym = NULL; + inSemantic = 0; + return; + } + } + //printf("setting aliassym %s to %s %s\n", toChars(), s->kind(), s->toChars()); + aliassym = s; + this->inSemantic = 0; +} + +int AliasDeclaration::overloadInsert(Dsymbol *s) +{ + /* Don't know yet what the aliased symbol is, so assume it can + * be overloaded and check later for correctness. + */ + + //printf("AliasDeclaration::overloadInsert('%s')\n", s->toChars()); + if (aliassym) // see test/test56.d + { + Dsymbol *a = aliassym->toAlias(); + FuncDeclaration *f = a->isFuncDeclaration(); + if (f) // BUG: what if it's a template? + { + FuncAliasDeclaration *fa = new FuncAliasDeclaration(f); + aliassym = fa; + return fa->overloadInsert(s); + } + } + + if (overnext == NULL) + { + if (s == this) + { + return TRUE; + } + overnext = s; + return TRUE; + } + else + { + return overnext->overloadInsert(s); + } +} + +const char *AliasDeclaration::kind() +{ + return "alias"; +} + +Type *AliasDeclaration::getType() +{ + return type; +} + +Dsymbol *AliasDeclaration::toAlias() +{ + //printf("AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s')\n", toChars(), this, aliassym, aliassym ? aliassym->kind() : ""); + assert(this != aliassym); + //static int count; if (++count == 10) *(char*)0=0; + if (inSemantic) + { error("recursive alias declaration"); + aliassym = new AliasDeclaration(loc, ident, Type::terror); + type = Type::terror; + } + else if (!aliassym && scope) + semantic(scope); + Dsymbol *s = aliassym ? aliassym->toAlias() : this; + return s; +} + +void AliasDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("alias "); +#if 0 + if (hgs->hdrgen) + { + if (haliassym) + { + haliassym->toCBuffer(buf, hgs); + buf->writeByte(' '); + buf->writestring(ident->toChars()); + } + else + htype->toCBuffer(buf, ident, hgs); + } + else +#endif + { + if (aliassym) + { + aliassym->toCBuffer(buf, hgs); + buf->writeByte(' '); + buf->writestring(ident->toChars()); + } + else + type->toCBuffer(buf, ident, hgs); + } + buf->writeByte(';'); + buf->writenl(); +} + +/********************************* VarDeclaration ****************************/ + +VarDeclaration::VarDeclaration(Loc loc, Type *type, Identifier *id, Initializer *init) + : Declaration(id) +{ + //printf("VarDeclaration('%s')\n", id->toChars()); +#ifdef DEBUG + if (!type && !init) + { printf("VarDeclaration('%s')\n", id->toChars()); + //*(char*)0=0; + } +#endif + assert(type || init); + this->type = type; + this->init = init; + this->htype = NULL; + this->hinit = NULL; + this->loc = loc; + offset = 0; + noscope = 0; +#if DMDV2 + isargptr = FALSE; +#endif +#if DMDV1 + nestedref = 0; +#endif + ctorinit = 0; + aliassym = NULL; + onstack = 0; + canassign = 0; + ctfeAdrOnStack = (size_t)(-1); +#if DMDV2 + rundtor = NULL; + edtor = NULL; +#endif +} + +Dsymbol *VarDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("VarDeclaration::syntaxCopy(%s)\n", toChars()); + + VarDeclaration *sv; + if (s) + { sv = (VarDeclaration *)s; + } + else + { + Initializer *init = NULL; + if (this->init) + { init = this->init->syntaxCopy(); + //init->isExpInitializer()->exp->print(); + //init->isExpInitializer()->exp->dump(0); + } + + sv = new VarDeclaration(loc, type ? type->syntaxCopy() : NULL, ident, init); + sv->storage_class = storage_class; + } + + // Syntax copy for header file + if (!htype) // Don't overwrite original + { if (type) // Make copy for both old and new instances + { htype = type->syntaxCopy(); + sv->htype = type->syntaxCopy(); + } + } + else // Make copy of original for new instance + sv->htype = htype->syntaxCopy(); + if (!hinit) + { if (init) + { hinit = init->syntaxCopy(); + sv->hinit = init->syntaxCopy(); + } + } + else + sv->hinit = hinit->syntaxCopy(); + + return sv; +} + +void VarDeclaration::semantic(Scope *sc) +{ +#if 0 + printf("VarDeclaration::semantic('%s', parent = '%s')\n", toChars(), sc->parent->toChars()); + printf(" type = %s\n", type ? type->toChars() : "null"); + printf(" stc = x%x\n", sc->stc); + printf(" storage_class = x%llx\n", storage_class); + printf("linkage = %d\n", sc->linkage); + //if (strcmp(toChars(), "mul") == 0) halt(); +#endif + +// if (sem > SemanticStart) +// return; +// sem = SemanticIn; + + if (scope) + { sc = scope; + scope = NULL; + } + + /* Pick up storage classes from context, but skip synchronized + */ + storage_class |= (sc->stc & ~STCsynchronized); + if (storage_class & STCextern && init) + error("extern symbols cannot have initializers"); + + AggregateDeclaration *ad = isThis(); + if (ad) + storage_class |= ad->storage_class & STC_TYPECTOR; + + /* If auto type inference, do the inference + */ + int inferred = 0; + if (!type) + { inuse++; + + ArrayInitializer *ai = init->isArrayInitializer(); + if (ai) + { Expression *e; + if (ai->isAssociativeArray()) + e = ai->toAssocArrayLiteral(); + else + e = init->toExpression(); + if (!e) + { + error("cannot infer type from initializer"); + e = new ErrorExp(); + } + init = new ExpInitializer(e->loc, e); + type = init->inferType(sc); + if (type->ty == Tsarray) + type = type->nextOf()->arrayOf(); + } + else + type = init->inferType(sc); + +//printf("test2: %s, %s, %s\n", toChars(), type->toChars(), type->deco); +// type = type->semantic(loc, sc); + + inuse--; + inferred = 1; + + if (init->isArrayInitializer() && type->toBasetype()->ty == Tsarray) + { // Prefer array literals to give a T[] type rather than a T[dim] + type = type->toBasetype()->nextOf()->arrayOf(); + } + + /* This is a kludge to support the existing syntax for RAII + * declarations. + */ + storage_class &= ~STCauto; + originalType = type; + } + else + { if (!originalType) + originalType = type; + type = type->semantic(loc, sc); + } + //printf(" semantic type = %s\n", type ? type->toChars() : "null"); + + type->checkDeprecated(loc, sc); + linkage = sc->linkage; + this->parent = sc->parent; + //printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars()); + protection = sc->protection; + //printf("sc->stc = %x\n", sc->stc); + //printf("storage_class = x%x\n", storage_class); + +#if DMDV2 + // Safety checks + if (sc->func && !sc->intypeof) + { + if (storage_class & STCgshared) + { + if (sc->func->setUnsafe()) + error("__gshared not allowed in safe functions; use shared"); + } + if (init && init->isVoidInitializer() && type->hasPointers()) + { + if (sc->func->setUnsafe()) + error("void initializers for pointers not allowed in safe functions"); + } + if (type->hasPointers() && type->toDsymbol(sc)) + { + Dsymbol *s = type->toDsymbol(sc); + if (s) + { + AggregateDeclaration *ad2 = s->isAggregateDeclaration(); + if (ad2 && ad2->hasUnions) + { + if (sc->func->setUnsafe()) + error("unions containing pointers are not allowed in @safe functions"); + } + } + } + } +#endif + + Dsymbol *parent = toParent(); + FuncDeclaration *fd = parent->isFuncDeclaration(); + + Type *tb = type->toBasetype(); + if (tb->ty == Tvoid && !(storage_class & STClazy)) + { error("voids have no value"); + type = Type::terror; + tb = type; + } + if (tb->ty == Tfunction) + { error("cannot be declared to be a function"); + type = Type::terror; + tb = type; + } + if (tb->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tb; + + if (!ts->sym->members) + { + error("no definition of struct %s", ts->toChars()); + } + } + if ((storage_class & STCauto) && !inferred) + error("storage class 'auto' has no effect if type is not inferred, did you mean 'scope'?"); + + if (tb->ty == Ttuple) + { /* Instead, declare variables for each of the tuple elements + * and add those. + */ + TypeTuple *tt = (TypeTuple *)tb; + size_t nelems = Parameter::dim(tt->arguments); + Objects *exps = new Objects(); + exps->setDim(nelems); + Expression *ie = init ? init->toExpression() : NULL; + if (ie) ie = ie->semantic(sc); + + if (nelems > 0 && ie) + { + Expressions *iexps = new Expressions(); + iexps->push(ie); + + Expressions *exps = new Expressions(); + + for (size_t pos = 0; pos < iexps->dim; pos++) + { + Lexpand1: + Expression *e = iexps->tdata()[pos]; + Parameter *arg = Parameter::getNth(tt->arguments, pos); + arg->type = arg->type->semantic(loc, sc); + //printf("[%d] iexps->dim = %d, ", pos, iexps->dim); + //printf("e = (%s %s, %s), ", Token::tochars[e->op], e->toChars(), e->type->toChars()); + //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); + + if (e != ie) + { + if (iexps->dim > nelems) + goto Lnomatch; + if (e->type->implicitConvTo(arg->type)) + continue; + } + + if (e->op == TOKtuple) + { + TupleExp *te = (TupleExp *)e; + if (iexps->dim - 1 + te->exps->dim > nelems) + goto Lnomatch; + + iexps->remove(pos); + iexps->insert(pos, te->exps); + goto Lexpand1; + } + else if (isAliasThisTuple(e)) + { + Identifier *id = Lexer::uniqueId("__tup"); + ExpInitializer *ei = new ExpInitializer(e->loc, e); + VarDeclaration *v = new VarDeclaration(loc, NULL, id, ei); + v->storage_class = STCctfe | STCref | STCforeach; + VarExp *ve = new VarExp(loc, v); + ve->type = e->type; + + exps->setDim(1); + (*exps)[0] = ve; + expandAliasThisTuples(exps, 0); + + for (size_t u = 0; u < exps->dim ; u++) + { + Lexpand2: + Expression *ee = (*exps)[u]; + Parameter *arg = Parameter::getNth(tt->arguments, pos + u); + arg->type = arg->type->semantic(loc, sc); + //printf("[%d+%d] exps->dim = %d, ", pos, u, exps->dim); + //printf("ee = (%s %s, %s), ", Token::tochars[ee->op], ee->toChars(), ee->type->toChars()); + //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); + + size_t iexps_dim = iexps->dim - 1 + exps->dim; + if (iexps_dim > nelems) + goto Lnomatch; + if (ee->type->implicitConvTo(arg->type)) + continue; + + if (expandAliasThisTuples(exps, u) != -1) + goto Lexpand2; + } + + if ((*exps)[0] != ve) + { + Expression *e0 = (*exps)[0]; + (*exps)[0] = new CommaExp(loc, new DeclarationExp(loc, v), e0); + (*exps)[0]->type = e0->type; + + iexps->remove(pos); + iexps->insert(pos, exps); + goto Lexpand1; + } + } + } + if (iexps->dim < nelems) + goto Lnomatch; + + ie = new TupleExp(init->loc, iexps); + } +Lnomatch: + + if (ie && ie->op == TOKtuple) + { size_t tedim = ((TupleExp *)ie)->exps->dim; + if (tedim != nelems) + { ::error(loc, "tuple of %d elements cannot be assigned to tuple of %d elements", (int)tedim, (int)nelems); + for (size_t u = tedim; u < nelems; u++) // fill dummy expression + ((TupleExp *)ie)->exps->push(new ErrorExp()); + } + } + + for (size_t i = 0; i < nelems; i++) + { Parameter *arg = Parameter::getNth(tt->arguments, i); + + OutBuffer buf; + buf.printf("_%s_field_%zu", ident->toChars(), i); + buf.writeByte(0); + const char *name = (const char *)buf.extractData(); + Identifier *id = Lexer::idPool(name); + + Expression *einit = ie; + if (ie && ie->op == TOKtuple) + { einit = ((TupleExp *)ie)->exps->tdata()[i]; + } + Initializer *ti = init; + if (einit) + { ti = new ExpInitializer(einit->loc, einit); + } + + VarDeclaration *v = new VarDeclaration(loc, arg->type, id, ti); + if (arg->storageClass & STCparameter) + v->storage_class |= arg->storageClass; + //printf("declaring field %s of type %s\n", v->toChars(), v->type->toChars()); + v->semantic(sc); + + if (sc->scopesym) + { //printf("adding %s to %s\n", v->toChars(), sc->scopesym->toChars()); + if (sc->scopesym->members) + sc->scopesym->members->push(v); + } + + Expression *e = new DsymbolExp(loc, v); + exps->tdata()[i] = e; + } + TupleDeclaration *v2 = new TupleDeclaration(loc, ident, exps); + v2->isexp = 1; + aliassym = v2; + return; + } + + /* Storage class can modify the type + */ + type = type->addStorageClass(storage_class); + + /* Adjust storage class to reflect type + */ + if (type->isConst()) + { storage_class |= STCconst; + if (type->isShared()) + storage_class |= STCshared; + } + else if (type->isImmutable()) + storage_class |= STCimmutable; + else if (type->isShared()) + storage_class |= STCshared; + else if (type->isWild()) + storage_class |= STCwild; + + if (isSynchronized()) + { + error("variable %s cannot be synchronized", toChars()); + } + else if (isOverride()) + { + error("override cannot be applied to variable"); + } + else if (isAbstract()) + { + error("abstract cannot be applied to variable"); + } + else if (storage_class & STCfinal) + { + error("final cannot be applied to variable"); + } + + if (storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | STCtls | STCgshared | STCctfe)) + { + } + else + { + AggregateDeclaration *aad = sc->anonAgg; + if (!aad) + aad = parent->isAggregateDeclaration(); + if (aad) + { +#if DMDV2 + assert(!(storage_class & (STCextern | STCstatic | STCtls | STCgshared))); + + if (storage_class & (STCconst | STCimmutable) && init) + { + if (!tb->isTypeBasic()) + storage_class |= STCstatic; + } + else + { + aad->addField(sc, this); + if (tb->ty == Tstruct && ((TypeStruct *)tb)->sym->noDefaultCtor || + tb->ty == Tclass && ((TypeClass *)tb)->sym->noDefaultCtor) + aad->noDefaultCtor = TRUE; + } +#else + aad->addField(sc, this); +#endif + } + + InterfaceDeclaration *id = parent->isInterfaceDeclaration(); + if (id) + { + error("field not allowed in interface"); + } + + /* Templates cannot add fields to aggregates + */ + TemplateInstance *ti = parent->isTemplateInstance(); + if (ti) + { + // Take care of nested templates + while (1) + { + TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance(); + if (!ti2) + break; + ti = ti2; + } + + // If it's a member template + AggregateDeclaration *ad2 = ti->tempdecl->isMember(); + if (ad2 && storage_class != STCundefined) + { + error("cannot use template to add field to aggregate '%s'", ad2->toChars()); + } + } + } + +#if DMDV2 + if ((storage_class & (STCref | STCparameter | STCforeach)) == STCref && + ident != Id::This) + { + error("only parameters or foreach declarations can be ref"); + } + + if (type->hasWild() && + !(type->ty == Tpointer && type->nextOf()->ty == Tfunction || type->ty == Tdelegate)) + { + if (storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield) || + isDataseg() + ) + { + error("only parameters or stack based variables can be inout"); + } + FuncDeclaration *func = sc->func; + if (func) + { + if (func->fes) + func = func->fes->func; + if (!func->type->hasWild()) + { + error("inout variables can only be declared inside inout functions"); + } + } + } + + if (!(storage_class & (STCctfe | STCref)) && tb->ty == Tstruct && + ((TypeStruct *)tb)->sym->noDefaultCtor) + { + if (!init) + { if (storage_class & STCfield) + /* For fields, we'll check the constructor later to make sure it is initialized + */ + storage_class |= STCnodefaultctor; + else if (storage_class & STCparameter) + ; + else + error("initializer required for type %s", type->toChars()); + } + } +#endif + + if (type->isscope() && !noscope) + { + if (storage_class & (STCfield | STCout | STCref | STCstatic | STCmanifest | STCtls | STCgshared) || !fd) + { + error("globals, statics, fields, manifest constants, ref and out parameters cannot be scope"); + } + + if (!(storage_class & STCscope)) + { + if (!(storage_class & STCparameter) && ident != Id::withSym) + error("reference to scope class must be scope"); + } + } + + if (!init && !fd) + { // If not mutable, initializable by constructor only + storage_class |= STCctorinit; + } + + if (init) + storage_class |= STCinit; // remember we had an explicit initializer + else if (storage_class & STCmanifest) + error("manifest constants must have initializers"); + + enum TOK op = TOKconstruct; + if (!init && !sc->inunion && !isStatic() && fd && + (!(storage_class & (STCfield | STCin | STCforeach | STCparameter | STCresult)) + || (storage_class & STCout)) && + type->size() != 0) + { + // Provide a default initializer + //printf("Providing default initializer for '%s'\n", toChars()); + if (type->ty == Tstruct && + ((TypeStruct *)type)->sym->zeroInit == 1) + { /* If a struct is all zeros, as a special case + * set it's initializer to the integer 0. + * In AssignExp::toElem(), we check for this and issue + * a memset() to initialize the struct. + * Must do same check in interpreter. + */ + Expression *e = new IntegerExp(loc, 0, Type::tint32); + Expression *e1; + e1 = new VarExp(loc, this); + e = new ConstructExp(loc, e1, e); + e->type = e1->type; // don't type check this, it would fail + init = new ExpInitializer(loc, e); + goto Ldtor; + } + else if (type->ty == Ttypedef) + { TypeTypedef *td = (TypeTypedef *)type; + if (td->sym->init) + { init = td->sym->init; + ExpInitializer *ie = init->isExpInitializer(); + if (ie) + // Make copy so we can modify it + init = new ExpInitializer(ie->loc, ie->exp); + } + else + init = getExpInitializer(); + } + else + { + init = getExpInitializer(); + } + // Default initializer is always a blit + op = TOKblit; + } + + if (init) + { + sc = sc->push(); + sc->stc &= ~(STC_TYPECTOR | STCpure | STCnothrow | STCref | STCdisable); + + ArrayInitializer *ai = init->isArrayInitializer(); + if (ai && tb->ty == Taarray) + { + Expression *e = ai->toAssocArrayLiteral(); + init = new ExpInitializer(e->loc, e); + } + + StructInitializer *si = init->isStructInitializer(); + ExpInitializer *ei = init->isExpInitializer(); + + if (ei && ei->exp->op == TOKfunction && !inferred) + ((FuncExp *)ei->exp)->setType(type); + + if (ei && isScope()) + { + // See if initializer is a NewExp that can be allocated on the stack + if (ei->exp->op == TOKnew) + { NewExp *ne = (NewExp *)ei->exp; + if (!(ne->newargs && ne->newargs->dim)) + { ne->onstack = 1; + onstack = 1; + if (type->isBaseOf(ne->newtype->semantic(loc, sc), NULL)) + onstack = 2; + } + } + // or a delegate that doesn't escape a reference to the function + else if (ei->exp->op == TOKfunction) + { FuncDeclaration *f = ((FuncExp *)ei->exp)->fd; + f->tookAddressOf--; + } + } + + // If inside function, there is no semantic3() call + if (sc->func) + { + // If local variable, use AssignExp to handle all the various + // possibilities. + if (fd && + !(storage_class & (STCmanifest | STCstatic | STCtls | STCgshared | STCextern)) && + !init->isVoidInitializer()) + { + //printf("fd = '%s', var = '%s'\n", fd->toChars(), toChars()); + if (!ei) + { + Expression *e = init->toExpression(); + if (!e) + { + init = init->semantic(sc, type, 0); // Don't need to interpret + e = init->toExpression(); + if (!e) + { error("is not a static and cannot have static initializer"); + return; + } + } + ei = new ExpInitializer(init->loc, e); + init = ei; + } + + Expression *e1 = new VarExp(loc, this); + + Type *t = type->toBasetype(); + + Linit2: + if (t->ty == Tsarray && !(storage_class & (STCref | STCout))) + { + ei->exp = ei->exp->semantic(sc); + if (!ei->exp->implicitConvTo(type)) + { + dinteger_t dim = ((TypeSArray *)t)->dim->toInteger(); + // If multidimensional static array, treat as one large array + while (1) + { + t = t->nextOf()->toBasetype(); + if (t->ty != Tsarray) + break; + dim *= ((TypeSArray *)t)->dim->toInteger(); + e1->type = new TypeSArray(t->nextOf(), new IntegerExp(0, dim, Type::tindex)); + } + } + e1 = new SliceExp(loc, e1, NULL, NULL); + } + else if (t->ty == Tstruct) + { + ei->exp = ei->exp->semantic(sc); + ei->exp = resolveProperties(sc, ei->exp); + StructDeclaration *sd = ((TypeStruct *)t)->sym; +#if DMDV2 + Expression** pinit = &ei->exp; + while ((*pinit)->op == TOKcomma) + { + pinit = &((CommaExp *)*pinit)->e2; + } + + /* Look to see if initializer is a call to the constructor + */ + if (sd->ctor && // there are constructors + (*pinit)->type->ty == Tstruct && // rvalue is the same struct + ((TypeStruct *)(*pinit)->type)->sym == sd && + (*pinit)->op == TOKcall) + { + /* Look for form of constructor call which is: + * *__ctmp.ctor(arguments...) + */ + if (1) + { CallExp *ce = (CallExp *)(*pinit); + if (ce->e1->op == TOKdotvar) + { DotVarExp *dve = (DotVarExp *)ce->e1; + if (dve->var->isCtorDeclaration()) + { /* It's a constructor call, currently constructing + * a temporary __ctmp. + */ + /* Before calling the constructor, initialize + * variable with a bit copy of the default + * initializer + */ + + /* Remove ref if this declaration is ref binding. + * ref Type __self = (__ctmp = 0, __ctmp).this(...); + * -> Type __self = (__self = 0, __self.this(...)); + */ + storage_class &= ~(STCref | STCforeach | STCparameter); + + Expression *e; + if (sd->zeroInit == 1) + { + e = new ConstructExp(loc, new VarExp(loc, this), new IntegerExp(loc, 0, Type::tint32)); + } + else + { e = new AssignExp(loc, new VarExp(loc, this), t->defaultInit(loc)); + e->op = TOKblit; + } + e->type = t; + (*pinit) = new CommaExp(loc, e, (*pinit)); + + /* Replace __ctmp being constructed with e1 + */ + dve->e1 = e1; + (*pinit) = (*pinit)->semantic(sc); + goto Ldtor; + } + } + } + } + + /* Look for ((S tmp = S()),tmp) and replace it with just S() + */ + Expression *e2 = ei->exp->isTemp(); + if (e2) + { + ei->exp = e2; + goto Linit2; + } +#endif + if (!ei->exp->implicitConvTo(type)) + { + Type *ti = ei->exp->type->toBasetype(); + // Look for constructor first + if (sd->ctor && + /* Initializing with the same type is done differently + */ + !(ti->ty == Tstruct && t->toDsymbol(sc) == ti->toDsymbol(sc))) + { + // Rewrite as e1.ctor(arguments) + Expression *ector = new DotIdExp(loc, e1, Id::ctor); + ei->exp = new CallExp(loc, ector, ei->exp); + /* Before calling the constructor, initialize + * variable with a bit copy of the default + * initializer + */ + Expression *e = new AssignExp(loc, e1, t->defaultInit(loc)); + e->op = TOKblit; + e->type = t; + ei->exp = new CommaExp(loc, e, ei->exp); + } + else + /* Look for opCall + * See bugzilla 2702 for more discussion + */ + // Don't cast away invariant or mutability in initializer + if (search_function(sd, Id::call) && + /* Initializing with the same type is done differently + */ + !(ti->ty == Tstruct && t->toDsymbol(sc) == ti->toDsymbol(sc))) + { // Rewrite as e1.call(arguments) + Expression * eCall = new DotIdExp(loc, e1, Id::call); + ei->exp = new CallExp(loc, eCall, ei->exp); + } + } + } + ei->exp = new AssignExp(loc, e1, ei->exp); + ei->exp->op = op; + canassign++; + ei->exp = ei->exp->semantic(sc); + canassign--; + ei->exp->optimize(WANTvalue); + } + else + { + init = init->semantic(sc, type, WANTinterpret); + } + } + else if (storage_class & (STCconst | STCimmutable | STCmanifest) || + type->isConst() || type->isImmutable() || + parent->isAggregateDeclaration()) + { + /* Because we may need the results of a const declaration in a + * subsequent type, such as an array dimension, before semantic2() + * gets ordinarily run, try to run semantic2() now. + * Ignore failure. + */ + + if (!global.errors && !inferred) + { + unsigned errors = global.startGagging(); + Expression *e; + Initializer *i2 = init; + inuse++; + if (ei) + { + e = ei->exp->syntaxCopy(); + e = e->semantic(sc); + e = resolveProperties(sc, e); +#if DMDV2 + /* The problem is the following code: + * struct CopyTest { + * double x; + * this(double a) { x = a * 10.0;} + * this(this) { x += 2.0; } + * } + * const CopyTest z = CopyTest(5.3); // ok + * const CopyTest w = z; // not ok, postblit not run + * static assert(w.x == 55.0); + * because the postblit doesn't get run on the initialization of w. + */ + + Type *tb2 = e->type->toBasetype(); + if (tb2->ty == Tstruct) + { StructDeclaration *sd = ((TypeStruct *)tb2)->sym; + Type *typeb = type->toBasetype(); + /* Look to see if initializer involves a copy constructor + * (which implies a postblit) + */ + if (sd->cpctor && // there is a copy constructor + typeb->equals(tb2)) // rvalue is the same struct + { + // The only allowable initializer is a (non-copy) constructor + if (e->op == TOKcall) + { + CallExp *ce = (CallExp *)e; + if (ce->e1->op == TOKdotvar) + { + DotVarExp *dve = (DotVarExp *)ce->e1; + if (dve->var->isCtorDeclaration()) + goto LNoCopyConstruction; + } + } + global.gag--; + error("of type struct %s uses this(this), which is not allowed in static initialization", typeb->toChars()); + global.gag++; + + LNoCopyConstruction: + ; + } + } +#endif + e = e->implicitCastTo(sc, type); + } + else if (si || ai) + { i2 = init->syntaxCopy(); + i2 = i2->semantic(sc, type, WANTinterpret); + } + inuse--; + if (global.endGagging(errors)) // if errors happened + { +#if DMDV2 + /* Save scope for later use, to try again + */ + scope = new Scope(*sc); + scope->setNoFree(); +#endif + } + else if (ei) + { + if (isDataseg() || (storage_class & STCmanifest)) + e = e->optimize(WANTvalue | WANTinterpret); + else + e = e->optimize(WANTvalue); + switch (e->op) + { + case TOKint64: + case TOKfloat64: + case TOKstring: + case TOKarrayliteral: + case TOKassocarrayliteral: + case TOKstructliteral: + case TOKnull: + ei->exp = e; // no errors, keep result + break; + + default: +#if DMDV2 + /* Save scope for later use, to try again + */ + scope = new Scope(*sc); + scope->setNoFree(); +#endif + break; + } + } + else + init = i2; // no errors, keep result + } + } + sc = sc->pop(); + } + +Ldtor: + /* Build code to execute destruction, if necessary + */ + edtor = callScopeDtor(sc); + if (edtor) + { + edtor = edtor->semantic(sc); + +#if 0 // currently disabled because of std.stdio.stdin, stdout and stderr + if (isDataseg() && !(storage_class & STCextern)) + error("static storage variables cannot have destructors"); +#endif + } + + sem = SemanticDone; +} + +void VarDeclaration::semantic2(Scope *sc) +{ + //printf("VarDeclaration::semantic2('%s')\n", toChars()); + if (init && !toParent()->isFuncDeclaration()) + { inuse++; +#if 0 + ExpInitializer *ei = init->isExpInitializer(); + if (ei) + { + ei->exp->dump(0); + printf("type = %p\n", ei->exp->type); + } +#endif + init = init->semantic(sc, type, WANTinterpret); + inuse--; + } + sem = Semantic2Done; +} + +const char *VarDeclaration::kind() +{ + return "variable"; +} + +Dsymbol *VarDeclaration::toAlias() +{ + //printf("VarDeclaration::toAlias('%s', this = %p, aliassym = %p)\n", toChars(), this, aliassym); + assert(this != aliassym); + Dsymbol *s = aliassym ? aliassym->toAlias() : this; + return s; +} + +void VarDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + StorageClassDeclaration::stcToCBuffer(buf, storage_class); + + /* If changing, be sure and fix CompoundDeclarationStatement::toCBuffer() + * too. + */ + if (type) + type->toCBuffer(buf, ident, hgs); + else + buf->writestring(ident->toChars()); + if (init) + { buf->writestring(" = "); +#if DMDV2 + ExpInitializer *ie = init->isExpInitializer(); + if (ie && (ie->exp->op == TOKconstruct || ie->exp->op == TOKblit)) + ((AssignExp *)ie->exp)->e2->toCBuffer(buf, hgs); + else +#endif + init->toCBuffer(buf, hgs); + } + buf->writeByte(';'); + buf->writenl(); +} + +AggregateDeclaration *VarDeclaration::isThis() +{ + AggregateDeclaration *ad = NULL; + + if (!(storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | + STCtls | STCgshared | STCctfe))) + { + if ((storage_class & (STCconst | STCimmutable | STCwild)) && init) + return NULL; + + for (Dsymbol *s = this; s; s = s->parent) + { + ad = s->isMember(); + if (ad) + break; + if (!s->parent || !s->parent->isTemplateMixin()) break; + } + } + return ad; +} + +int VarDeclaration::needThis() +{ + //printf("VarDeclaration::needThis(%s, x%x)\n", toChars(), storage_class); + return storage_class & STCfield; +} + +int VarDeclaration::isImportedSymbol() +{ + if (protection == PROTexport && !init && + (storage_class & STCstatic || parent->isModule())) + return TRUE; + return FALSE; +} + +void VarDeclaration::checkCtorConstInit() +{ +#if 0 /* doesn't work if more than one static ctor */ + if (ctorinit == 0 && isCtorinit() && !(storage_class & STCfield)) + error("missing initializer in static constructor for const variable"); +#endif +} + +/************************************ + * Check to see if this variable is actually in an enclosing function + * rather than the current one. + */ + +void VarDeclaration::checkNestedReference(Scope *sc, Loc loc) +{ + //printf("VarDeclaration::checkNestedReference() %s\n", toChars()); + if (parent && !isDataseg() && parent != sc->parent && + !(storage_class & STCmanifest)) + { + // The function that this variable is in + FuncDeclaration *fdv = toParent()->isFuncDeclaration(); + // The current function + FuncDeclaration *fdthis = sc->parent->isFuncDeclaration(); + + if (fdv && fdthis && fdv != fdthis && fdthis->ident != Id::ensure) + { + /* __ensure is always called directly, + * so it never becomes closure. + */ + + //printf("\tfdv = %s\n", fdv->toChars()); + //printf("\tfdthis = %s\n", fdthis->toChars()); + + if (loc.filename) + fdthis->getLevel(loc, sc, fdv); + + // Function literals from fdthis to fdv must be delegates + for (Dsymbol *s = fdthis; s && s != fdv; s = s->toParent2()) + { + // function literal has reference to enclosing scope is delegate + if (FuncLiteralDeclaration *fld = s->isFuncLiteralDeclaration()) + { + fld->tok = TOKdelegate; + } + } + + // Add fdthis to nestedrefs[] if not already there + for (size_t i = 0; 1; i++) + { + if (i == nestedrefs.dim) + { + nestedrefs.push(fdthis); + break; + } + if (nestedrefs[i] == fdthis) + break; + } + + // Add this to fdv->closureVars[] if not already there + for (size_t i = 0; 1; i++) + { + if (i == fdv->closureVars.dim) + { + fdv->closureVars.push(this); + break; + } + if (fdv->closureVars[i] == this) + break; + } + + //printf("fdthis is %s\n", fdthis->toChars()); + //printf("var %s in function %s is nested ref\n", toChars(), fdv->toChars()); + // __dollar creates problems because it isn't a real variable Bugzilla 3326 + if (ident == Id::dollar) + ::error(loc, "cannnot use $ inside a function literal"); + } + } +} + +/**************************** + * Get ExpInitializer for a variable, if there is one. + */ + +ExpInitializer *VarDeclaration::getExpInitializer() +{ + ExpInitializer *ei; + + if (init) + ei = init->isExpInitializer(); + else + { + Expression *e = type->defaultInit(loc); + if (e) + ei = new ExpInitializer(loc, e); + else + ei = NULL; + } + return ei; +} + +/******************************************* + * If variable has a constant expression initializer, get it. + * Otherwise, return NULL. + */ + +Expression *VarDeclaration::getConstInitializer() +{ + if ((isConst() || isImmutable() || storage_class & STCmanifest) && + storage_class & STCinit) + { + ExpInitializer *ei = getExpInitializer(); + if (ei) + return ei->exp; + } + + return NULL; +} + +/************************************* + * Return !=0 if we can take the address of this variable. + */ + +int VarDeclaration::canTakeAddressOf() +{ +#if 0 + /* Global variables and struct/class fields of the form: + * const int x = 3; + * are not stored and hence cannot have their address taken. + */ + if ((isConst() || isImmutable()) && + storage_class & STCinit && + (!(storage_class & (STCstatic | STCextern)) || (storage_class & STCfield)) && + (!parent || toParent()->isModule() || toParent()->isTemplateInstance()) && + type->toBasetype()->isTypeBasic() + ) + { + return 0; + } +#else + if (storage_class & STCmanifest) + return 0; +#endif + return 1; +} + + +/******************************* + * Does symbol go into data segment? + * Includes extern variables. + */ + +int VarDeclaration::isDataseg() +{ +#if 0 + printf("VarDeclaration::isDataseg(%p, '%s')\n", this, toChars()); + printf("%llx, isModule: %p, isTemplateInstance: %p\n", storage_class & (STCstatic | STCconst), parent->isModule(), parent->isTemplateInstance()); + printf("parent = '%s'\n", parent->toChars()); +#endif + if (storage_class & STCmanifest) + return 0; + Dsymbol *parent = this->toParent(); + if (!parent && !(storage_class & STCstatic)) + { error("forward referenced"); + type = Type::terror; + return 0; + } + return canTakeAddressOf() && + (storage_class & (STCstatic | STCextern | STCtls | STCgshared) || + toParent()->isModule() || + toParent()->isTemplateInstance()); +} + +/************************************ + * Does symbol go into thread local storage? + */ + +int VarDeclaration::isThreadlocal() +{ + //printf("VarDeclaration::isThreadlocal(%p, '%s')\n", this, toChars()); +#if 0 //|| TARGET_OSX + /* To be thread-local, must use the __thread storage class. + * BUG: OSX doesn't support thread local yet. + */ + return isDataseg() && + (storage_class & (STCtls | STCconst | STCimmutable | STCshared | STCgshared)) == STCtls; +#else + /* Data defaults to being thread-local. It is not thread-local + * if it is immutable, const or shared. + */ + int i = isDataseg() && + !(storage_class & (STCimmutable | STCconst | STCshared | STCgshared)); + //printf("\treturn %d\n", i); + return i; +#endif +} + +/******************************************** + * Can variable be read and written by CTFE? + */ + +int VarDeclaration::isCTFE() +{ + return (storage_class & STCctfe) != 0; // || !isDataseg(); +} + +int VarDeclaration::hasPointers() +{ + //printf("VarDeclaration::hasPointers() %s, ty = %d\n", toChars(), type->ty); + return (!isDataseg() && type->hasPointers()); +} + +/****************************************** + * Return TRUE if variable needs to call the destructor. + */ + +int VarDeclaration::needsAutoDtor() +{ + //printf("VarDeclaration::needsAutoDtor() %s\n", toChars()); + + if (noscope || !edtor) + return FALSE; + + return TRUE; +} + + +/****************************************** + * If a variable has a scope destructor call, return call for it. + * Otherwise, return NULL. + */ + +Expression *VarDeclaration::callScopeDtor(Scope *sc) +{ Expression *e = NULL; + + //printf("VarDeclaration::callScopeDtor() %s\n", toChars()); + + // Destruction of STCfield's is handled by buildDtor() + if (noscope || storage_class & (STCnodtor | STCref | STCout | STCfield)) + { + return NULL; + } + + // Destructors for structs and arrays of structs + bool array = false; + Type *tv = type->toBasetype(); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + array = true; + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->dtor) + { + if (array) + { + // Typeinfo.destroy(cast(void*)&v); + Expression *ea = new SymOffExp(loc, this, 0, 0); + ea = new CastExp(loc, ea, Type::tvoid->pointerTo()); + Expressions *args = new Expressions(); + args->push(ea); + + Expression *et = type->getTypeInfo(sc); + et = new DotIdExp(loc, et, Id::destroy); + + e = new CallExp(loc, et, args); + } + else + { + e = new VarExp(loc, this); + /* This is a hack so we can call destructors on const/immutable objects. + * Need to add things like "const ~this()" and "immutable ~this()" to + * fix properly. + */ + e->type = e->type->mutableOf(); + e = new DotVarExp(loc, e, sd->dtor, 0); + e = new CallExp(loc, e); + } + return e; + } + } + + // Destructors for classes + if (storage_class & (STCauto | STCscope)) + { + for (ClassDeclaration *cd = type->isClassHandle(); + cd; + cd = cd->baseClass) + { + /* We can do better if there's a way with onstack + * classes to determine if there's no way the monitor + * could be set. + */ + //if (cd->isInterfaceDeclaration()) + //error("interface %s cannot be scope", cd->toChars()); + if (1 || onstack || cd->dtors.dim) // if any destructors + { + // delete this; + Expression *ec; + + ec = new VarExp(loc, this); + e = new DeleteExp(loc, ec); + e->type = Type::tvoid; + break; + } + } + } + return e; +} + +/****************************************** + */ + +void ObjectNotFound(Identifier *id) +{ + Type::error(0, "%s not found. object.d may be incorrectly installed or corrupt.", id->toChars()); + fatal(); +} + + +/********************************* ClassInfoDeclaration ****************************/ + +ClassInfoDeclaration::ClassInfoDeclaration(ClassDeclaration *cd) + : VarDeclaration(0, ClassDeclaration::classinfo->type, cd->ident, NULL) +{ + this->cd = cd; + storage_class = STCstatic | STCgshared; +} + +Dsymbol *ClassInfoDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(0); // should never be produced by syntax + return NULL; +} + +void ClassInfoDeclaration::semantic(Scope *sc) +{ +} + +/********************************* ModuleInfoDeclaration ****************************/ + +ModuleInfoDeclaration::ModuleInfoDeclaration(Module *mod) + : VarDeclaration(0, Module::moduleinfo->type, mod->ident, NULL) +{ + this->mod = mod; + storage_class = STCstatic | STCgshared; +} + +Dsymbol *ModuleInfoDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(0); // should never be produced by syntax + return NULL; +} + +void ModuleInfoDeclaration::semantic(Scope *sc) +{ +} + +/********************************* TypeInfoDeclaration ****************************/ + +TypeInfoDeclaration::TypeInfoDeclaration(Type *tinfo, int internal) + : VarDeclaration(0, Type::typeinfo->type, tinfo->getTypeInfoIdent(internal), NULL) +{ + this->tinfo = tinfo; + storage_class = STCstatic | STCgshared; + protection = PROTpublic; + linkage = LINKc; +} + +Dsymbol *TypeInfoDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(0); // should never be produced by syntax + return NULL; +} + +void TypeInfoDeclaration::semantic(Scope *sc) +{ + assert(linkage == LINKc); +} + +/***************************** TypeInfoConstDeclaration **********************/ + +#if DMDV2 +TypeInfoConstDeclaration::TypeInfoConstDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoconst) + { + ObjectNotFound(Id::TypeInfo_Const); + } + type = Type::typeinfoconst->type; +} +#endif + +/***************************** TypeInfoInvariantDeclaration **********************/ + +#if DMDV2 +TypeInfoInvariantDeclaration::TypeInfoInvariantDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoinvariant) + { + ObjectNotFound(Id::TypeInfo_Invariant); + } + type = Type::typeinfoinvariant->type; +} +#endif + +/***************************** TypeInfoSharedDeclaration **********************/ + +#if DMDV2 +TypeInfoSharedDeclaration::TypeInfoSharedDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoshared) + { + ObjectNotFound(Id::TypeInfo_Shared); + } + type = Type::typeinfoshared->type; +} +#endif + +/***************************** TypeInfoWildDeclaration **********************/ + +#if DMDV2 +TypeInfoWildDeclaration::TypeInfoWildDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfowild) + { + ObjectNotFound(Id::TypeInfo_Wild); + } + type = Type::typeinfowild->type; +} +#endif + +/***************************** TypeInfoStructDeclaration **********************/ + +TypeInfoStructDeclaration::TypeInfoStructDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfostruct) + { + ObjectNotFound(Id::TypeInfo_Struct); + } + type = Type::typeinfostruct->type; +} + +/***************************** TypeInfoClassDeclaration ***********************/ + +TypeInfoClassDeclaration::TypeInfoClassDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoclass) + { + ObjectNotFound(Id::TypeInfo_Class); + } + type = Type::typeinfoclass->type; +} + +/***************************** TypeInfoInterfaceDeclaration *******************/ + +TypeInfoInterfaceDeclaration::TypeInfoInterfaceDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfointerface) + { + ObjectNotFound(Id::TypeInfo_Interface); + } + type = Type::typeinfointerface->type; +} + +/***************************** TypeInfoTypedefDeclaration *********************/ + +TypeInfoTypedefDeclaration::TypeInfoTypedefDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfotypedef) + { + ObjectNotFound(Id::TypeInfo_Typedef); + } + type = Type::typeinfotypedef->type; +} + +/***************************** TypeInfoPointerDeclaration *********************/ + +TypeInfoPointerDeclaration::TypeInfoPointerDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfopointer) + { + ObjectNotFound(Id::TypeInfo_Pointer); + } + type = Type::typeinfopointer->type; +} + +/***************************** TypeInfoArrayDeclaration ***********************/ + +TypeInfoArrayDeclaration::TypeInfoArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoarray) + { + ObjectNotFound(Id::TypeInfo_Array); + } + type = Type::typeinfoarray->type; +} + +/***************************** TypeInfoStaticArrayDeclaration *****************/ + +TypeInfoStaticArrayDeclaration::TypeInfoStaticArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfostaticarray) + { + ObjectNotFound(Id::TypeInfo_StaticArray); + } + type = Type::typeinfostaticarray->type; +} + +/***************************** TypeInfoAssociativeArrayDeclaration ************/ + +TypeInfoAssociativeArrayDeclaration::TypeInfoAssociativeArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoassociativearray) + { + ObjectNotFound(Id::TypeInfo_AssociativeArray); + } + type = Type::typeinfoassociativearray->type; +} + +/***************************** TypeInfoVectorDeclaration ***********************/ + +TypeInfoVectorDeclaration::TypeInfoVectorDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoarray) + { + ObjectNotFound(Id::TypeInfo_Vector); + } + type = Type::typeinfovector->type; +} + +/***************************** TypeInfoEnumDeclaration ***********************/ + +TypeInfoEnumDeclaration::TypeInfoEnumDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfoenum) + { + ObjectNotFound(Id::TypeInfo_Enum); + } + type = Type::typeinfoenum->type; +} + +/***************************** TypeInfoFunctionDeclaration ********************/ + +TypeInfoFunctionDeclaration::TypeInfoFunctionDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfofunction) + { + ObjectNotFound(Id::TypeInfo_Function); + } + type = Type::typeinfofunction->type; +} + +/***************************** TypeInfoDelegateDeclaration ********************/ + +TypeInfoDelegateDeclaration::TypeInfoDelegateDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfodelegate) + { + ObjectNotFound(Id::TypeInfo_Delegate); + } + type = Type::typeinfodelegate->type; +} + +/***************************** TypeInfoTupleDeclaration **********************/ + +TypeInfoTupleDeclaration::TypeInfoTupleDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo, 0) +{ + if (!Type::typeinfotypelist) + { + ObjectNotFound(Id::TypeInfo_Tuple); + } + type = Type::typeinfotypelist->type; +} + +/********************************* ThisDeclaration ****************************/ + +// For the "this" parameter to member functions + +ThisDeclaration::ThisDeclaration(Loc loc, Type *t) + : VarDeclaration(loc, t, Id::This, NULL) +{ + noscope = 1; +} + +Dsymbol *ThisDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(0); // should never be produced by syntax + return NULL; +} + diff --git a/declaration.h b/declaration.h new file mode 100644 index 00000000..deab930e --- /dev/null +++ b/declaration.h @@ -0,0 +1,889 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_DECLARATION_H +#define DMD_DECLARATION_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "dsymbol.h" +#include "lexer.h" +#include "mtype.h" + +struct Expression; +struct Statement; +struct LabelDsymbol; +struct Initializer; +struct Module; +struct InlineScanState; +struct ForeachStatement; +struct FuncDeclaration; +struct ExpInitializer; +struct StructDeclaration; +struct TupleType; +struct InterState; +struct IRState; + +enum PROT; +enum LINK; +enum TOK; +enum MATCH; +enum PURE; + +#define STCundefined 0LL +#define STCstatic 1LL +#define STCextern 2LL +#define STCconst 4LL +#define STCfinal 8LL +#define STCabstract 0x10LL +#define STCparameter 0x20LL +#define STCfield 0x40LL +#define STCoverride 0x80LL +#define STCauto 0x100LL +#define STCsynchronized 0x200LL +#define STCdeprecated 0x400LL +#define STCin 0x800LL // in parameter +#define STCout 0x1000LL // out parameter +#define STClazy 0x2000LL // lazy parameter +#define STCforeach 0x4000LL // variable for foreach loop +#define STCcomdat 0x8000LL // should go into COMDAT record +#define STCvariadic 0x10000LL // variadic function argument +#define STCctorinit 0x20000LL // can only be set inside constructor +#define STCtemplateparameter 0x40000LL // template parameter +#define STCscope 0x80000LL // template parameter +#define STCimmutable 0x100000LL +#define STCref 0x200000LL +#define STCinit 0x400000LL // has explicit initializer +#define STCmanifest 0x800000LL // manifest constant +#define STCnodtor 0x1000000LL // don't run destructor +#define STCnothrow 0x2000000LL // never throws exceptions +#define STCpure 0x4000000LL // pure function +#define STCtls 0x8000000LL // thread local +#define STCalias 0x10000000LL // alias parameter +#define STCshared 0x20000000LL // accessible from multiple threads +#define STCgshared 0x40000000LL // accessible from multiple threads + // but not typed as "shared" +#define STCwild 0x80000000LL // for "wild" type constructor +#define STC_TYPECTOR (STCconst | STCimmutable | STCshared | STCwild) +#define STC_FUNCATTR (STCref | STCnothrow | STCpure | STCproperty | STCsafe | STCtrusted | STCsystem) + +#define STCproperty 0x100000000LL +#define STCsafe 0x200000000LL +#define STCtrusted 0x400000000LL +#define STCsystem 0x800000000LL +#define STCctfe 0x1000000000LL // can be used in CTFE, even if it is static +#define STCdisable 0x2000000000LL // for functions that are not callable +#define STCresult 0x4000000000LL // for result variables passed to out contracts +#define STCnodefaultctor 0x8000000000LL // must be set inside constructor + +struct Match +{ + int count; // number of matches found + MATCH last; // match level of lastf + FuncDeclaration *lastf; // last matching function we found + FuncDeclaration *nextf; // current matching function + FuncDeclaration *anyf; // pick a func, any func, to use for error recovery +}; + +void overloadResolveX(Match *m, FuncDeclaration *f, + Expression *ethis, Expressions *arguments); +int overloadApply(FuncDeclaration *fstart, + int (*fp)(void *, FuncDeclaration *), + void *param); + +enum Semantic +{ + SemanticStart, // semantic has not been run + SemanticIn, // semantic() is in progress + SemanticDone, // semantic() has been run + Semantic2Done, // semantic2() has been run +}; + +/**************************************************************/ + +struct Declaration : Dsymbol +{ + Type *type; + Type *originalType; // before semantic analysis + StorageClass storage_class; + enum PROT protection; + enum LINK linkage; + int inuse; // used to detect cycles + + enum Semantic sem; + + Declaration(Identifier *id); + void semantic(Scope *sc); + const char *kind(); + unsigned size(Loc loc); + void checkModify(Loc loc, Scope *sc, Type *t); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toDocBuffer(OutBuffer *buf); + + char *mangle(); + int isStatic() { return storage_class & STCstatic; } + virtual int isDelete(); + virtual int isDataseg(); + virtual int isThreadlocal(); + virtual int isCodeseg(); + int isCtorinit() { return storage_class & STCctorinit; } + int isFinal() { return storage_class & STCfinal; } + int isAbstract() { return storage_class & STCabstract; } + int isConst() { return storage_class & STCconst; } + int isImmutable() { return storage_class & STCimmutable; } + int isWild() { return storage_class & STCwild; } + int isAuto() { return storage_class & STCauto; } + int isScope() { return storage_class & STCscope; } + int isSynchronized() { return storage_class & STCsynchronized; } + int isParameter() { return storage_class & STCparameter; } + int isDeprecated() { return storage_class & STCdeprecated; } + int isOverride() { return storage_class & STCoverride; } + StorageClass isResult() { return storage_class & STCresult; } + + int isIn() { return storage_class & STCin; } + int isOut() { return storage_class & STCout; } + int isRef() { return storage_class & STCref; } + + enum PROT prot(); + + Declaration *isDeclaration() { return this; } +}; + +/**************************************************************/ + +struct TupleDeclaration : Declaration +{ + Objects *objects; + int isexp; // 1: expression tuple + + TypeTuple *tupletype; // !=NULL if this is a type tuple + + TupleDeclaration(Loc loc, Identifier *ident, Objects *objects); + Dsymbol *syntaxCopy(Dsymbol *); + const char *kind(); + Type *getType(); + int needThis(); + + TupleDeclaration *isTupleDeclaration() { return this; } +}; + +/**************************************************************/ + +struct TypedefDeclaration : Declaration +{ + Type *basetype; + Initializer *init; + + TypedefDeclaration(Loc loc, Identifier *ident, Type *basetype, Initializer *init); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void semantic2(Scope *sc); + char *mangle(); + const char *kind(); + Type *getType(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Type *htype; + Type *hbasetype; + + void toDocBuffer(OutBuffer *buf); + + void toObjFile(int multiobj); // compile to .obj file + void toDebug(); + int cvMember(unsigned char *p); + + TypedefDeclaration *isTypedefDeclaration() { return this; } + + Symbol *sinit; + Symbol *toInitializer(); +}; + +/**************************************************************/ + +struct AliasDeclaration : Declaration +{ + Dsymbol *aliassym; + Dsymbol *overnext; // next in overload list + int inSemantic; + + AliasDeclaration(Loc loc, Identifier *ident, Type *type); + AliasDeclaration(Loc loc, Identifier *ident, Dsymbol *s); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + int overloadInsert(Dsymbol *s); + const char *kind(); + Type *getType(); + Dsymbol *toAlias(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Type *htype; + Dsymbol *haliassym; + + void toDocBuffer(OutBuffer *buf); + + AliasDeclaration *isAliasDeclaration() { return this; } +}; + +/**************************************************************/ + +struct VarDeclaration : Declaration +{ + Initializer *init; + unsigned offset; + int noscope; // no auto semantics +#if DMDV2 + FuncDeclarations nestedrefs; // referenced by these lexically nested functions + bool isargptr; // if parameter that _argptr points to +#else + int nestedref; // referenced by a lexically nested function +#endif + int ctorinit; // it has been initialized in a ctor + int onstack; // 1: it has been allocated on the stack + // 2: on stack, run destructor anyway + int canassign; // it can be assigned to + Dsymbol *aliassym; // if redone as alias to another symbol + + // When interpreting, these point to the value (NULL if value not determinable) + // The index of this variable on the CTFE stack, -1 if not allocated + size_t ctfeAdrOnStack; + // The various functions are used only to detect compiler CTFE bugs + Expression *getValue(); + bool hasValue(); + void setValueNull(); + void setValueWithoutChecking(Expression *newval); + void setValue(Expression *newval); + +#if DMDV2 + VarDeclaration *rundtor; // if !NULL, rundtor is tested at runtime to see + // if the destructor should be run. Used to prevent + // dtor calls on postblitted vars + Expression *edtor; // if !=NULL, does the destruction of the variable +#endif + + VarDeclaration(Loc loc, Type *t, Identifier *id, Initializer *init); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void semantic2(Scope *sc); + const char *kind(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Type *htype; + Initializer *hinit; + AggregateDeclaration *isThis(); + int needThis(); + int isImportedSymbol(); + int isDataseg(); + int isThreadlocal(); + int isCTFE(); + int hasPointers(); +#if DMDV2 + int canTakeAddressOf(); + int needsAutoDtor(); +#endif + Expression *callScopeDtor(Scope *sc); + ExpInitializer *getExpInitializer(); + Expression *getConstInitializer(); + void checkCtorConstInit(); + void checkNestedReference(Scope *sc, Loc loc); + Dsymbol *toAlias(); + + Symbol *toSymbol(); + void toObjFile(int multiobj); // compile to .obj file + int cvMember(unsigned char *p); + + // Eliminate need for dynamic_cast + VarDeclaration *isVarDeclaration() { return (VarDeclaration *)this; } +}; + +/**************************************************************/ + +// This is a shell around a back end symbol + +struct SymbolDeclaration : Declaration +{ + Symbol *sym; + StructDeclaration *dsym; + + SymbolDeclaration(Loc loc, Symbol *s, StructDeclaration *dsym); + + Symbol *toSymbol(); + + // Eliminate need for dynamic_cast + SymbolDeclaration *isSymbolDeclaration() { return (SymbolDeclaration *)this; } +}; + +struct ClassInfoDeclaration : VarDeclaration +{ + ClassDeclaration *cd; + + ClassInfoDeclaration(ClassDeclaration *cd); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + + Symbol *toSymbol(); +}; + +struct ModuleInfoDeclaration : VarDeclaration +{ + Module *mod; + + ModuleInfoDeclaration(Module *mod); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + + Symbol *toSymbol(); +}; + +struct TypeInfoDeclaration : VarDeclaration +{ + Type *tinfo; + + TypeInfoDeclaration(Type *tinfo, int internal); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + + Symbol *toSymbol(); + void toObjFile(int multiobj); // compile to .obj file + virtual void toDt(dt_t **pdt); +}; + +struct TypeInfoStructDeclaration : TypeInfoDeclaration +{ + TypeInfoStructDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoClassDeclaration : TypeInfoDeclaration +{ + TypeInfoClassDeclaration(Type *tinfo); + Symbol *toSymbol(); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoInterfaceDeclaration : TypeInfoDeclaration +{ + TypeInfoInterfaceDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoTypedefDeclaration : TypeInfoDeclaration +{ + TypeInfoTypedefDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoPointerDeclaration : TypeInfoDeclaration +{ + TypeInfoPointerDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoArrayDeclaration : TypeInfoDeclaration +{ + TypeInfoArrayDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoStaticArrayDeclaration : TypeInfoDeclaration +{ + TypeInfoStaticArrayDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoAssociativeArrayDeclaration : TypeInfoDeclaration +{ + TypeInfoAssociativeArrayDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoEnumDeclaration : TypeInfoDeclaration +{ + TypeInfoEnumDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoFunctionDeclaration : TypeInfoDeclaration +{ + TypeInfoFunctionDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoDelegateDeclaration : TypeInfoDeclaration +{ + TypeInfoDelegateDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoTupleDeclaration : TypeInfoDeclaration +{ + TypeInfoTupleDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +#if DMDV2 +struct TypeInfoConstDeclaration : TypeInfoDeclaration +{ + TypeInfoConstDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoInvariantDeclaration : TypeInfoDeclaration +{ + TypeInfoInvariantDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoSharedDeclaration : TypeInfoDeclaration +{ + TypeInfoSharedDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoWildDeclaration : TypeInfoDeclaration +{ + TypeInfoWildDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; + +struct TypeInfoVectorDeclaration : TypeInfoDeclaration +{ + TypeInfoVectorDeclaration(Type *tinfo); + + void toDt(dt_t **pdt); +}; +#endif + +/**************************************************************/ + +struct ThisDeclaration : VarDeclaration +{ + ThisDeclaration(Loc loc, Type *t); + Dsymbol *syntaxCopy(Dsymbol *); + ThisDeclaration *isThisDeclaration() { return this; } +}; + +enum ILS +{ + ILSuninitialized, // not computed yet + ILSno, // cannot inline + ILSyes, // can inline +}; + +/**************************************************************/ +#if DMDV2 + +enum BUILTIN +{ + BUILTINunknown = -1, // not known if this is a builtin + BUILTINnot, // this is not a builtin + BUILTINsin, // std.math.sin + BUILTINcos, // std.math.cos + BUILTINtan, // std.math.tan + BUILTINsqrt, // std.math.sqrt + BUILTINfabs, // std.math.fabs + BUILTINatan2, // std.math.atan2 + BUILTINrndtol, // std.math.rndtol + BUILTINexpm1, // std.math.expm1 + BUILTINexp2, // std.math.exp2 + BUILTINyl2x, // std.math.yl2x + BUILTINyl2xp1, // std.math.yl2xp1 + BUILTINbsr, // core.bitop.bsr + BUILTINbsf, // core.bitop.bsf + BUILTINbswap, // core.bitop.bswap +}; + +Expression *eval_builtin(Loc loc, enum BUILTIN builtin, Expressions *arguments); + +#else +enum BUILTIN { }; +#endif + +struct FuncDeclaration : Declaration +{ + Types *fthrows; // Array of Type's of exceptions (not used) + Statement *frequire; + Statement *fensure; + Statement *fbody; + + FuncDeclarations foverrides; // functions this function overrides + FuncDeclaration *fdrequire; // function that does the in contract + FuncDeclaration *fdensure; // function that does the out contract + + Identifier *outId; // identifier for out statement + VarDeclaration *vresult; // variable corresponding to outId + LabelDsymbol *returnLabel; // where the return goes + + DsymbolTable *localsymtab; // used to prevent symbols in different + // scopes from having the same name + VarDeclaration *vthis; // 'this' parameter (member and nested) + VarDeclaration *v_arguments; // '_arguments' parameter +#if IN_GCC + VarDeclaration *v_argptr; // '_argptr' variable +#endif + VarDeclaration *v_argsave; // save area for args passed in registers for variadic functions + VarDeclarations *parameters; // Array of VarDeclaration's for parameters + DsymbolTable *labtab; // statement label symbol table + Declaration *overnext; // next in overload list + Loc endloc; // location of closing curly bracket + int vtblIndex; // for member functions, index into vtbl[] + int naked; // !=0 if naked + ILS inlineStatusStmt; + ILS inlineStatusExp; + int inlineNest; // !=0 if nested inline + int isArrayOp; // !=0 if array operation + enum PASS semanticRun; + int semantic3Errors; // !=0 if errors in semantic3 + // this function's frame ptr + ForeachStatement *fes; // if foreach body, this is the foreach + int introducing; // !=0 if 'introducing' function + Type *tintro; // if !=NULL, then this is the type + // of the 'introducing' function + // this one is overriding + int inferRetType; // !=0 if return type is to be inferred + StorageClass storage_class2; // storage class for template onemember's + + // Things that should really go into Scope + int hasReturnExp; // 1 if there's a return exp; statement + // 2 if there's a throw statement + // 4 if there's an assert(0) + // 8 if there's inline asm + + // Support for NRVO (named return value optimization) + int nrvo_can; // !=0 means we can do it + VarDeclaration *nrvo_var; // variable to replace with shidden + Symbol *shidden; // hidden pointer passed to function + +#if DMDV2 + enum BUILTIN builtin; // set if this is a known, builtin + // function we can evaluate at compile + // time + + int tookAddressOf; // set if someone took the address of + // this function + VarDeclarations closureVars; // local variables in this function + // which are referenced by nested + // functions + + unsigned flags; + #define FUNCFLAGpurityInprocess 1 // working on determining purity + #define FUNCFLAGsafetyInprocess 2 // working on determining safety + #define FUNCFLAGnothrowInprocess 4 // working on determining nothrow +#else + int nestedFrameRef; // !=0 if nested variables referenced +#endif + + FuncDeclaration(Loc loc, Loc endloc, Identifier *id, StorageClass storage_class, Type *type); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void semantic2(Scope *sc); + void semantic3(Scope *sc); + // called from semantic3 + void varArgs(Scope *sc, TypeFunction*, VarDeclaration *&, VarDeclaration *&); + VarDeclaration *declareThis(Scope *sc, AggregateDeclaration *ad); + int equals(Object *o); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void bodyToCBuffer(OutBuffer *buf, HdrGenState *hgs); + int overrides(FuncDeclaration *fd); + int findVtblIndex(Dsymbols *vtbl, int dim); + int overloadInsert(Dsymbol *s); + FuncDeclaration *overloadExactMatch(Type *t); + FuncDeclaration *overloadResolve(Loc loc, Expression *ethis, Expressions *arguments, int flags = 0); + MATCH leastAsSpecialized(FuncDeclaration *g); + LabelDsymbol *searchLabel(Identifier *ident); + AggregateDeclaration *isThis(); + AggregateDeclaration *isMember2(); + int getLevel(Loc loc, Scope *sc, FuncDeclaration *fd); // lexical nesting level difference + void appendExp(Expression *e); + void appendState(Statement *s); + char *mangle(); + const char *toPrettyChars(); + int isMain(); + int isWinMain(); + int isDllMain(); + enum BUILTIN isBuiltin(); + int isExport(); + int isImportedSymbol(); + int isAbstract(); + int isCodeseg(); + int isOverloadable(); + enum PURE isPure(); + enum PURE isPureBypassingInference(); + bool setImpure(); + int isSafe(); + int isTrusted(); + bool setUnsafe(); + virtual int isNested(); + int needThis(); + int isVirtualMethod(); + virtual int isVirtual(); + virtual int isFinal(); + virtual int addPreInvariant(); + virtual int addPostInvariant(); + Expression *interpret(InterState *istate, Expressions *arguments, Expression *thisexp = NULL); + void inlineScan(); + int canInline(int hasthis, int hdrscan, int statementsToo); + Expression *expandInline(InlineScanState *iss, Expression *ethis, Expressions *arguments, Statement **ps); + const char *kind(); + void toDocBuffer(OutBuffer *buf); + FuncDeclaration *isUnique(); + void checkNestedReference(Scope *sc, Loc loc); + int needsClosure(); + int hasNestedFrameRefs(); + Statement *mergeFrequire(Statement *); + Statement *mergeFensure(Statement *); + Parameters *getParameters(int *pvarargs); + + static FuncDeclaration *genCfunc(Type *treturn, const char *name); + static FuncDeclaration *genCfunc(Type *treturn, Identifier *id); + + Symbol *toSymbol(); + Symbol *toThunkSymbol(int offset); // thunk version + void toObjFile(int multiobj); // compile to .obj file + int cvMember(unsigned char *p); + void buildClosure(IRState *irs); + + FuncDeclaration *isFuncDeclaration() { return this; } +}; + +#if DMDV2 +FuncDeclaration *resolveFuncCall(Scope *sc, Loc loc, Dsymbol *s, + Objects *tiargs, + Expression *ethis, + Expressions *arguments, + int flags); +#endif + +struct FuncAliasDeclaration : FuncDeclaration +{ + FuncDeclaration *funcalias; + + FuncAliasDeclaration(FuncDeclaration *funcalias); + + FuncAliasDeclaration *isFuncAliasDeclaration() { return this; } + const char *kind(); + Symbol *toSymbol(); +}; + +struct FuncLiteralDeclaration : FuncDeclaration +{ + enum TOK tok; // TOKfunction or TOKdelegate + + FuncLiteralDeclaration(Loc loc, Loc endloc, Type *type, enum TOK tok, + ForeachStatement *fes); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Dsymbol *syntaxCopy(Dsymbol *); + int isNested(); + int isVirtual(); + + FuncLiteralDeclaration *isFuncLiteralDeclaration() { return this; } + const char *kind(); +}; + +struct CtorDeclaration : FuncDeclaration +{ + CtorDeclaration(Loc loc, Loc endloc, StorageClass stc, Type *type); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + const char *kind(); + char *toChars(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + + CtorDeclaration *isCtorDeclaration() { return this; } +}; + +#if DMDV2 +struct PostBlitDeclaration : FuncDeclaration +{ + PostBlitDeclaration(Loc loc, Loc endloc, StorageClass stc = STCundefined); + PostBlitDeclaration(Loc loc, Loc endloc, Identifier *id); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + int overloadInsert(Dsymbol *s); + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + + PostBlitDeclaration *isPostBlitDeclaration() { return this; } +}; +#endif + +struct DtorDeclaration : FuncDeclaration +{ + DtorDeclaration(Loc loc, Loc endloc); + DtorDeclaration(Loc loc, Loc endloc, Identifier *id); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); + char *toChars(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + int overloadInsert(Dsymbol *s); + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + + DtorDeclaration *isDtorDeclaration() { return this; } +}; + +struct StaticCtorDeclaration : FuncDeclaration +{ + StaticCtorDeclaration(Loc loc, Loc endloc); + StaticCtorDeclaration(Loc loc, Loc endloc, const char *name); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + AggregateDeclaration *isThis(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + bool hasStaticCtorOrDtor(); + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + StaticCtorDeclaration *isStaticCtorDeclaration() { return this; } +}; + +#if DMDV2 +struct SharedStaticCtorDeclaration : StaticCtorDeclaration +{ + SharedStaticCtorDeclaration(Loc loc, Loc endloc); + Dsymbol *syntaxCopy(Dsymbol *); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + SharedStaticCtorDeclaration *isSharedStaticCtorDeclaration() { return this; } +}; +#endif + +struct StaticDtorDeclaration : FuncDeclaration +{ VarDeclaration *vgate; // 'gate' variable + + StaticDtorDeclaration(Loc loc, Loc endloc); + StaticDtorDeclaration(Loc loc, Loc endloc, const char *name); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + AggregateDeclaration *isThis(); + int isVirtual(); + bool hasStaticCtorOrDtor(); + int addPreInvariant(); + int addPostInvariant(); + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + StaticDtorDeclaration *isStaticDtorDeclaration() { return this; } +}; + +#if DMDV2 +struct SharedStaticDtorDeclaration : StaticDtorDeclaration +{ + SharedStaticDtorDeclaration(Loc loc, Loc endloc); + Dsymbol *syntaxCopy(Dsymbol *); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + SharedStaticDtorDeclaration *isSharedStaticDtorDeclaration() { return this; } +}; +#endif + +struct InvariantDeclaration : FuncDeclaration +{ + InvariantDeclaration(Loc loc, Loc endloc); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + InvariantDeclaration *isInvariantDeclaration() { return this; } +}; + +struct UnitTestDeclaration : FuncDeclaration +{ + UnitTestDeclaration(Loc loc, Loc endloc); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + AggregateDeclaration *isThis(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toJsonBuffer(OutBuffer *buf); + + UnitTestDeclaration *isUnitTestDeclaration() { return this; } +}; + +struct NewDeclaration : FuncDeclaration +{ Parameters *arguments; + int varargs; + + NewDeclaration(Loc loc, Loc endloc, Parameters *arguments, int varargs); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + + NewDeclaration *isNewDeclaration() { return this; } +}; + + +struct DeleteDeclaration : FuncDeclaration +{ Parameters *arguments; + + DeleteDeclaration(Loc loc, Loc endloc, Parameters *arguments); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); + int isDelete(); + int isVirtual(); + int addPreInvariant(); + int addPostInvariant(); + DeleteDeclaration *isDeleteDeclaration() { return this; } +}; + +#endif /* DMD_DECLARATION_H */ diff --git a/delegatize.c b/delegatize.c new file mode 100644 index 00000000..a4d37152 --- /dev/null +++ b/delegatize.c @@ -0,0 +1,140 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "expression.h" +#include "statement.h" +#include "mtype.h" +#include "utf.h" +#include "declaration.h" +#include "aggregate.h" +#include "scope.h" + +/******************************************** + * Convert from expression to delegate that returns the expression, + * i.e. convert: + * expr + * to: + * t delegate() { return expr; } + */ + +int lambdaSetParent(Expression *e, void *param); +int lambdaCheckForNestedRef(Expression *e, void *param); + +Expression *Expression::toDelegate(Scope *sc, Type *t) +{ + //printf("Expression::toDelegate(t = %s) %s\n", t->toChars(), toChars()); + TypeFunction *tf = new TypeFunction(NULL, t, 0, LINKd); + FuncLiteralDeclaration *fld = + new FuncLiteralDeclaration(loc, loc, tf, TOKdelegate, NULL); + Expression *e; + sc = sc->push(); + sc->parent = fld; // set current function to be the delegate + e = this; + e->apply(&lambdaSetParent, sc); + e->apply(&lambdaCheckForNestedRef, sc); + sc = sc->pop(); + Statement *s; + if (t->ty == Tvoid) + s = new ExpStatement(loc, e); + else + s = new ReturnStatement(loc, e); + fld->fbody = s; + e = new FuncExp(loc, fld); + e = e->semantic(sc); + return e; +} + +/****************************************** + * Patch the parent of declarations to be the new function literal. + */ +int lambdaSetParent(Expression *e, void *param) +{ + Scope *sc = (Scope *)param; + /* We could use virtual functions instead of a switch, + * but it doesn't seem worth the bother. + */ + switch (e->op) + { + case TOKdeclaration: + { DeclarationExp *de = (DeclarationExp *)e; + de->declaration->parent = sc->parent; + break; + } + + case TOKindex: + { IndexExp *de = (IndexExp *)e; + if (de->lengthVar) + { //printf("lengthVar\n"); + de->lengthVar->parent = sc->parent; + } + break; + } + + case TOKslice: + { SliceExp *se = (SliceExp *)e; + if (se->lengthVar) + { //printf("lengthVar\n"); + se->lengthVar->parent = sc->parent; + } + break; + } + + default: + break; + } + return 0; +} + +/******************************************* + * Look for references to variables in a scope enclosing the new function literal. + */ +int lambdaCheckForNestedRef(Expression *e, void *param) +{ + Scope *sc = (Scope *)param; + /* We could use virtual functions instead of a switch, + * but it doesn't seem worth the bother. + */ + switch (e->op) + { + case TOKsymoff: + { SymOffExp *se = (SymOffExp *)e; + VarDeclaration *v = se->var->isVarDeclaration(); + if (v) + v->checkNestedReference(sc, 0); + break; + } + + case TOKvar: + { VarExp *ve = (VarExp *)e; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v) + v->checkNestedReference(sc, 0); + break; + } + + case TOKthis: + case TOKsuper: + { ThisExp *te = (ThisExp *)e; + VarDeclaration *v = te->var->isVarDeclaration(); + if (v) + v->checkNestedReference(sc, 0); + break; + } + + default: + break; + } + return 0; +} + diff --git a/doc.c b/doc.c new file mode 100644 index 00000000..51c9d9c0 --- /dev/null +++ b/doc.c @@ -0,0 +1,2226 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// This implements the Ddoc capability. + +#include +#include +#include +#include +#include + +#include "rmem.h" +#include "root.h" + +#include "mars.h" +#include "dsymbol.h" +#include "macro.h" +#include "template.h" +#include "lexer.h" +#include "aggregate.h" +#include "declaration.h" +#include "enum.h" +#include "id.h" +#include "module.h" +#include "scope.h" +#include "hdrgen.h" +#include "doc.h" +#include "mtype.h" +#include "utf.h" + +struct Escape +{ + const char *strings[256]; + + static const char *escapeChar(unsigned c); +}; + +struct Section +{ + unsigned char *name; + unsigned namelen; + + unsigned char *body; + unsigned bodylen; + + int nooutput; + + virtual void write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf); +}; + +struct ParamSection : Section +{ + void write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf); +}; + +struct MacroSection : Section +{ + void write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf); +}; + +typedef ArrayBase
Sections; + +struct DocComment +{ + Sections sections; // Section*[] + + Section *summary; + Section *copyright; + Section *macros; + Macro **pmacrotable; + Escape **pescapetable; + + DocComment(); + + static DocComment *parse(Scope *sc, Dsymbol *s, unsigned char *comment); + static void parseMacros(Escape **pescapetable, Macro **pmacrotable, unsigned char *m, unsigned mlen); + static void parseEscapes(Escape **pescapetable, unsigned char *textstart, unsigned textlen); + + void parseSections(unsigned char *comment); + void writeSections(Scope *sc, Dsymbol *s, OutBuffer *buf); +}; + + +int cmp(const char *stringz, void *s, size_t slen); +int icmp(const char *stringz, void *s, size_t slen); +int isDitto(unsigned char *comment); +unsigned char *skipwhitespace(unsigned char *p); +unsigned skiptoident(OutBuffer *buf, size_t i); +unsigned skippastident(OutBuffer *buf, size_t i); +unsigned skippastURL(OutBuffer *buf, size_t i); +void highlightText(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset); +void highlightCode(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset); +void highlightCode2(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset); +Parameter *isFunctionParameter(Dsymbol *s, unsigned char *p, unsigned len); + +int isIdStart(unsigned char *p); +int isIdTail(unsigned char *p); +int utfStride(unsigned char *p); + +static unsigned char ddoc_default[] = "\ +DDOC = \n\ + \n\ + $(TITLE)\n\ + \n\ +

$(TITLE)

\n\ + $(BODY)\n\ +
$(SMALL Page generated by $(LINK2 http://www.digitalmars.com/d/2.0/ddoc.html, Ddoc). $(COPYRIGHT))\n\ + \n\ +\n\ +B = $0\n\ +I = $0\n\ +U = $0\n\ +P =

$0

\n\ +DL =
$0
\n\ +DT =
$0
\n\ +DD =
$0
\n\ +TABLE = $0
\n\ +TR = $0\n\ +TH = $0\n\ +TD = $0\n\ +OL =
    $0
\n\ +UL =
    $0
\n\ +LI =
  • $0
    • \n\ +BIG = $0\n\ +SMALL = $0\n\ +BR =
    \n\ +LINK = $0\n\ +LINK2 = $+\n\ +LPAREN= (\n\ +RPAREN= )\n\ +DOLLAR= $\n\ +\n\ +RED = $0\n\ +BLUE = $0\n\ +GREEN = $0\n\ +YELLOW =$0\n\ +BLACK = $0\n\ +WHITE = $0\n\ +\n\ +D_CODE = 
    $0
    \n\ +D_COMMENT = $(GREEN $0)\n\ +D_STRING = $(RED $0)\n\ +D_KEYWORD = $(BLUE $0)\n\ +D_PSYMBOL = $(U $0)\n\ +D_PARAM = $(I $0)\n\ +\n\ +DDOC_COMMENT = \n\ +DDOC_DECL = $(DT $(BIG $0))\n\ +DDOC_DECL_DD = $(DD $0)\n\ +DDOC_DITTO = $(BR)$0\n\ +DDOC_SECTIONS = $0\n\ +DDOC_SUMMARY = $0$(BR)$(BR)\n\ +DDOC_DESCRIPTION = $0$(BR)$(BR)\n\ +DDOC_AUTHORS = $(B Authors:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_BUGS = $(RED BUGS:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_COPYRIGHT = $(B Copyright:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_DATE = $(B Date:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_DEPRECATED = $(RED Deprecated:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_EXAMPLES = $(B Examples:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_HISTORY = $(B History:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_LICENSE = $(B License:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_RETURNS = $(B Returns:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_SEE_ALSO = $(B See Also:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_STANDARDS = $(B Standards:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_THROWS = $(B Throws:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_VERSION = $(B Version:)$(BR)\n$0$(BR)$(BR)\n\ +DDOC_SECTION_H = $(B $0)$(BR)\n\ +DDOC_SECTION = $0$(BR)$(BR)\n\ +DDOC_MEMBERS = $(DL $0)\n\ +DDOC_MODULE_MEMBERS = $(DDOC_MEMBERS $0)\n\ +DDOC_CLASS_MEMBERS = $(DDOC_MEMBERS $0)\n\ +DDOC_STRUCT_MEMBERS = $(DDOC_MEMBERS $0)\n\ +DDOC_ENUM_MEMBERS = $(DDOC_MEMBERS $0)\n\ +DDOC_TEMPLATE_MEMBERS = $(DDOC_MEMBERS $0)\n\ +DDOC_PARAMS = $(B Params:)$(BR)\n$(TABLE $0)$(BR)\n\ +DDOC_PARAM_ROW = $(TR $0)\n\ +DDOC_PARAM_ID = $(TD $0)\n\ +DDOC_PARAM_DESC = $(TD $0)\n\ +DDOC_BLANKLINE = $(BR)$(BR)\n\ +\n\ +DDOC_PSYMBOL = $(U $0)\n\ +DDOC_KEYWORD = $(B $0)\n\ +DDOC_PARAM = $(I $0)\n\ +\n\ +ESCAPES = //>/\n\ + /&/&/\n\ +"; + +static char ddoc_decl_s[] = "$(DDOC_DECL "; +static char ddoc_decl_e[] = ")\n"; + +static char ddoc_decl_dd_s[] = "$(DDOC_DECL_DD "; +static char ddoc_decl_dd_e[] = ")\n"; + + +/**************************************************** + */ + +void Module::gendocfile() +{ + static OutBuffer mbuf; + static int mbuf_done; + + OutBuffer buf; + + //printf("Module::gendocfile()\n"); + + if (!mbuf_done) // if not already read the ddoc files + { mbuf_done = 1; + + // Use our internal default + mbuf.write(ddoc_default, sizeof(ddoc_default) - 1); + + // Override with DDOCFILE specified in the sc.ini file + char *p = getenv("DDOCFILE"); + if (p) + global.params.ddocfiles->shift(p); + + // Override with the ddoc macro files from the command line + for (size_t i = 0; i < global.params.ddocfiles->dim; i++) + { + FileName f(global.params.ddocfiles->tdata()[i], 0); + File file(&f); + file.readv(); + // BUG: convert file contents to UTF-8 before use + + //printf("file: '%.*s'\n", file.len, file.buffer); + mbuf.write(file.buffer, file.len); + } + } + DocComment::parseMacros(&escapetable, ¯otable, mbuf.data, mbuf.offset); + + Scope *sc = Scope::createGlobal(this); // create root scope + sc->docbuf = &buf; + + DocComment *dc = DocComment::parse(sc, this, comment); + dc->pmacrotable = ¯otable; + dc->pescapetable = &escapetable; + + // Generate predefined macros + + // Set the title to be the name of the module + { const char *p = toPrettyChars(); + Macro::define(¯otable, (unsigned char *)"TITLE", 5, (unsigned char *)p, strlen(p)); + } + + // Set time macros + { time_t t; + time(&t); + char *p = ctime(&t); + p = mem.strdup(p); + Macro::define(¯otable, (unsigned char *)"DATETIME", 8, (unsigned char *)p, strlen(p)); + Macro::define(¯otable, (unsigned char *)"YEAR", 4, (unsigned char *)p + 20, 4); + } + + char *docfilename = docfile->toChars(); + Macro::define(¯otable, (unsigned char *)"DOCFILENAME", 11, (unsigned char *)docfilename, strlen(docfilename)); + + if (dc->copyright) + { + dc->copyright->nooutput = 1; + Macro::define(¯otable, (unsigned char *)"COPYRIGHT", 9, dc->copyright->body, dc->copyright->bodylen); + } + + buf.printf("$(DDOC_COMMENT Generated by Ddoc from %s)\n", srcfile->toChars()); + if (isDocFile) + { + size_t commentlen = strlen((char *)comment); + if (dc->macros) + { + commentlen = dc->macros->name - comment; + dc->macros->write(dc, sc, this, sc->docbuf); + } + sc->docbuf->write(comment, commentlen); + highlightText(NULL, this, sc->docbuf, 0); + } + else + { + dc->writeSections(sc, this, sc->docbuf); + emitMemberComments(sc); + } + + //printf("BODY= '%.*s'\n", buf.offset, buf.data); + Macro::define(¯otable, (unsigned char *)"BODY", 4, buf.data, buf.offset); + + OutBuffer buf2; + buf2.writestring("$(DDOC)\n"); + unsigned end = buf2.offset; + macrotable->expand(&buf2, 0, &end, NULL, 0); + +#if 1 + /* Remove all the escape sequences from buf2, + * and make CR-LF the newline. + */ + { + buf.setsize(0); + buf.reserve(buf2.offset); + unsigned char *p = buf2.data; + for (unsigned j = 0; j < buf2.offset; j++) + { + unsigned char c = p[j]; + if (c == 0xFF && j + 1 < buf2.offset) + { + j++; + continue; + } + if (c == '\n') + buf.writeByte('\r'); + else if (c == '\r') + { + buf.writestring("\r\n"); + if (j + 1 < buf2.offset && p[j + 1] == '\n') + { + j++; + } + continue; + } + buf.writeByte(c); + } + } + + // Transfer image to file + assert(docfile); + docfile->setbuffer(buf.data, buf.offset); + docfile->ref = 1; + char *pt = FileName::path(docfile->toChars()); + if (*pt) + FileName::ensurePathExists(pt); + mem.free(pt); + docfile->writev(); +#else + /* Remove all the escape sequences from buf2 + */ + { unsigned i = 0; + unsigned char *p = buf2.data; + for (unsigned j = 0; j < buf2.offset; j++) + { + if (p[j] == 0xFF && j + 1 < buf2.offset) + { + j++; + continue; + } + p[i] = p[j]; + i++; + } + buf2.setsize(i); + } + + // Transfer image to file + docfile->setbuffer(buf2.data, buf2.offset); + docfile->ref = 1; + char *pt = FileName::path(docfile->toChars()); + if (*pt) + FileName::ensurePathExists(pt); + mem.free(pt); + docfile->writev(); +#endif +} + +/**************************************************** + * Having unmatched parentheses can hose the output of Ddoc, + * as the macros depend on properly nested parentheses. + * This function replaces all ( with $(LPAREN) and ) with $(RPAREN) + * to preserve text literally. This also means macros in the + * text won't be expanded. + */ +void escapeDdocString(OutBuffer *buf, unsigned start) +{ + for (unsigned u = start; u < buf->offset; u++) + { + unsigned char c = buf->data[u]; + switch(c) + { + case '$': + buf->remove(u, 1); + buf->insert(u, "$(DOLLAR)", 9); + u += 8; + break; + + case '(': + buf->remove(u, 1); //remove the ( + buf->insert(u, "$(LPAREN)", 9); //insert this instead + u += 8; //skip over newly inserted macro + break; + + case ')': + buf->remove(u, 1); //remove the ) + buf->insert(u, "$(RPAREN)", 9); //insert this instead + u += 8; //skip over newly inserted macro + break; + } + } +} + +/**************************************************** + * Having unmatched parentheses can hose the output of Ddoc, + * as the macros depend on properly nested parentheses. + + * Fix by replacing unmatched ( with $(LPAREN) and unmatched ) with $(RPAREN). + */ +void escapeStrayParenthesis(OutBuffer *buf, unsigned start, Loc loc) +{ + unsigned par_open = 0; + + for (unsigned u = start; u < buf->offset; u++) + { + unsigned char c = buf->data[u]; + switch(c) + { + case '(': + par_open++; + break; + + case ')': + if (par_open == 0) + { + //stray ')' + if (global.params.warnings) + warning(loc, "Ddoc: Stray ')'. This may cause incorrect Ddoc output." + " Use $(RPAREN) instead for unpaired right parentheses."); + buf->remove(u, 1); //remove the ) + buf->insert(u, "$(RPAREN)", 9); //insert this instead + u += 8; //skip over newly inserted macro + } + else + par_open--; + break; +#if 0 + // For this to work, loc must be set to the beginning of the passed + // text which is currently not possible + // (loc is set to the Loc of the Dsymbol) + case '\n': + loc.linnum++; + break; +#endif + } + } + + if (par_open) // if any unmatched lparens + { par_open = 0; + for (unsigned u = buf->offset; u > start;) + { u--; + unsigned char c = buf->data[u]; + switch(c) + { + case ')': + par_open++; + break; + + case '(': + if (par_open == 0) + { + //stray '(' + if (global.params.warnings) + warning(loc, "Ddoc: Stray '('. This may cause incorrect Ddoc output." + " Use $(LPAREN) instead for unpaired left parentheses."); + buf->remove(u, 1); //remove the ( + buf->insert(u, "$(LPAREN)", 9); //insert this instead + } + else + par_open--; + break; + } + } + } +} + +/******************************* emitComment **********************************/ + +/* + * Emit doc comment to documentation file + */ + +void Dsymbol::emitDitto(Scope *sc) +{ + //printf("Dsymbol::emitDitto() %s %s\n", kind(), toChars()); + OutBuffer *buf = sc->docbuf; + unsigned o; + OutBuffer b; + + b.writestring("$(DDOC_DITTO "); + o = b.offset; + toDocBuffer(&b); + //printf("b: '%.*s'\n", b.offset, b.data); + /* If 'this' is a function template, then highlightCode() was + * already run by FuncDeclaration::toDocbuffer(). + */ + TemplateDeclaration *td; + if (parent && + (td = parent->isTemplateDeclaration()) != NULL && + td->onemember == this) + { + } + else + highlightCode(sc, this, &b, o); + b.writeByte(')'); + buf->spread(sc->lastoffset, b.offset); + memcpy(buf->data + sc->lastoffset, b.data, b.offset); + sc->lastoffset += b.offset; +} + +void ScopeDsymbol::emitMemberComments(Scope *sc) +{ + //printf("ScopeDsymbol::emitMemberComments() %s\n", toChars()); + OutBuffer *buf = sc->docbuf; + + if (members) + { const char *m = "$(DDOC_MEMBERS \n"; + + if (isModule()) + m = "$(DDOC_MODULE_MEMBERS \n"; + else if (isClassDeclaration()) + m = "$(DDOC_CLASS_MEMBERS \n"; + else if (isStructDeclaration()) + m = "$(DDOC_STRUCT_MEMBERS \n"; + else if (isEnumDeclaration()) + m = "$(DDOC_ENUM_MEMBERS \n"; + else if (isTemplateDeclaration()) + m = "$(DDOC_TEMPLATE_MEMBERS \n"; + + unsigned offset1 = buf->offset; // save starting offset + buf->writestring(m); + unsigned offset2 = buf->offset; // to see if we write anything + sc = sc->push(this); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = (*members)[i]; + //printf("\ts = '%s'\n", s->toChars()); + s->emitComment(sc); + } + sc->pop(); + if (buf->offset == offset2) + { + /* Didn't write out any members, so back out last write + */ + buf->offset = offset1; + } + else + buf->writestring(")\n"); + } +} + +void emitProtection(OutBuffer *buf, PROT prot) +{ + const char *p; + + switch (prot) + { + case PROTpackage: p = "package"; break; + case PROTprotected: p = "protected"; break; + case PROTexport: p = "export"; break; + default: p = NULL; break; + } + if (p) + buf->printf("%s ", p); +} + +void Dsymbol::emitComment(Scope *sc) { } +void InvariantDeclaration::emitComment(Scope *sc) { } +#if DMDV2 +void PostBlitDeclaration::emitComment(Scope *sc) { } +#endif +void DtorDeclaration::emitComment(Scope *sc) { } +void StaticCtorDeclaration::emitComment(Scope *sc) { } +void StaticDtorDeclaration::emitComment(Scope *sc) { } +void ClassInfoDeclaration::emitComment(Scope *sc) { } +void ModuleInfoDeclaration::emitComment(Scope *sc) { } +void TypeInfoDeclaration::emitComment(Scope *sc) { } + + +void Declaration::emitComment(Scope *sc) +{ + //printf("Declaration::emitComment(%p '%s'), comment = '%s'\n", this, toChars(), comment); + //printf("type = %p\n", type); + + if (protection == PROTprivate || !ident || + (!type && !isCtorDeclaration() && !isAliasDeclaration())) + return; + if (!comment) + return; + + OutBuffer *buf = sc->docbuf; + DocComment *dc = DocComment::parse(sc, this, comment); + unsigned o; + + if (!dc) + { + emitDitto(sc); + return; + } + dc->pmacrotable = &sc->module->macrotable; + + buf->writestring(ddoc_decl_s); + o = buf->offset; + toDocBuffer(buf); + highlightCode(sc, this, buf, o); + sc->lastoffset = buf->offset; + buf->writestring(ddoc_decl_e); + + buf->writestring(ddoc_decl_dd_s); + dc->writeSections(sc, this, buf); + buf->writestring(ddoc_decl_dd_e); +} + +void AggregateDeclaration::emitComment(Scope *sc) +{ + //printf("AggregateDeclaration::emitComment() '%s'\n", toChars()); + if (prot() == PROTprivate) + return; + if (!comment) + return; + + OutBuffer *buf = sc->docbuf; + DocComment *dc = DocComment::parse(sc, this, comment); + + if (!dc) + { + emitDitto(sc); + return; + } + dc->pmacrotable = &sc->module->macrotable; + + buf->writestring(ddoc_decl_s); + toDocBuffer(buf); + sc->lastoffset = buf->offset; + buf->writestring(ddoc_decl_e); + + buf->writestring(ddoc_decl_dd_s); + dc->writeSections(sc, this, buf); + emitMemberComments(sc); + buf->writestring(ddoc_decl_dd_e); +} + +void TemplateDeclaration::emitComment(Scope *sc) +{ + //printf("TemplateDeclaration::emitComment() '%s', kind = %s\n", toChars(), kind()); + if (prot() == PROTprivate) + return; + + unsigned char *com = comment; + int hasmembers = 1; + + Dsymbol *ss = this; + + if (onemember) + { + ss = onemember->isAggregateDeclaration(); + if (!ss) + { + ss = onemember->isFuncDeclaration(); + if (ss) + { hasmembers = 0; + if (com != ss->comment) + com = Lexer::combineComments(com, ss->comment); + } + else + ss = this; + } + } + + if (!com) + return; + + OutBuffer *buf = sc->docbuf; + DocComment *dc = DocComment::parse(sc, this, com); + unsigned o; + + if (!dc) + { + ss->emitDitto(sc); + return; + } + dc->pmacrotable = &sc->module->macrotable; + + buf->writestring(ddoc_decl_s); + o = buf->offset; + ss->toDocBuffer(buf); + if (ss == this) + highlightCode(sc, this, buf, o); + sc->lastoffset = buf->offset; + buf->writestring(ddoc_decl_e); + + buf->writestring(ddoc_decl_dd_s); + dc->writeSections(sc, this, buf); + if (hasmembers) + ((ScopeDsymbol *)ss)->emitMemberComments(sc); + buf->writestring(ddoc_decl_dd_e); +} + +void EnumDeclaration::emitComment(Scope *sc) +{ + if (prot() == PROTprivate) + return; +// if (!comment) + { if (isAnonymous() && members) + { + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = (*members)[i]; + s->emitComment(sc); + } + return; + } + } + if (!comment) + return; + if (isAnonymous()) + return; + + OutBuffer *buf = sc->docbuf; + DocComment *dc = DocComment::parse(sc, this, comment); + + if (!dc) + { + emitDitto(sc); + return; + } + dc->pmacrotable = &sc->module->macrotable; + + buf->writestring(ddoc_decl_s); + toDocBuffer(buf); + sc->lastoffset = buf->offset; + buf->writestring(ddoc_decl_e); + + buf->writestring(ddoc_decl_dd_s); + dc->writeSections(sc, this, buf); + emitMemberComments(sc); + buf->writestring(ddoc_decl_dd_e); +} + +void EnumMember::emitComment(Scope *sc) +{ + //printf("EnumMember::emitComment(%p '%s'), comment = '%s'\n", this, toChars(), comment); + if (prot() == PROTprivate) + return; + if (!comment) + return; + + OutBuffer *buf = sc->docbuf; + DocComment *dc = DocComment::parse(sc, this, comment); + unsigned o; + + if (!dc) + { + emitDitto(sc); + return; + } + dc->pmacrotable = &sc->module->macrotable; + + buf->writestring(ddoc_decl_s); + o = buf->offset; + toDocBuffer(buf); + highlightCode(sc, this, buf, o); + sc->lastoffset = buf->offset; + buf->writestring(ddoc_decl_e); + + buf->writestring(ddoc_decl_dd_s); + dc->writeSections(sc, this, buf); + buf->writestring(ddoc_decl_dd_e); +} + +/******************************* toDocBuffer **********************************/ + +void Dsymbol::toDocBuffer(OutBuffer *buf) +{ + //printf("Dsymbol::toDocbuffer() %s\n", toChars()); + HdrGenState hgs; + + hgs.ddoc = 1; + toCBuffer(buf, &hgs); +} + +void prefix(OutBuffer *buf, Dsymbol *s) +{ + if (s->isDeprecated()) + buf->writestring("deprecated "); + Declaration *d = s->isDeclaration(); + if (d) + { + emitProtection(buf, d->protection); + if (d->isAbstract()) + buf->writestring("abstract "); + if (d->isStatic()) + buf->writestring("static "); + if (d->isConst()) + buf->writestring("const "); +#if DMDV2 + if (d->isImmutable()) + buf->writestring("immutable "); +#endif + if (d->isFinal()) + buf->writestring("final "); + if (d->isSynchronized()) + buf->writestring("synchronized "); + } +} + +void declarationToDocBuffer(Declaration *decl, OutBuffer *buf, TemplateDeclaration *td) +{ + //printf("declarationToDocBuffer() %s, originalType = %s, td = %s\n", decl->toChars(), decl->originalType ? decl->originalType->toChars() : "--", td ? td->toChars() : "--"); + if (decl->ident) + { + prefix(buf, decl); + + if (decl->type) + { HdrGenState hgs; + hgs.ddoc = 1; + Type *origType = decl->originalType ? decl->originalType : decl->type; + if (origType->ty == Tfunction) + { + TypeFunction *attrType = (TypeFunction*)(decl->ident == Id::ctor ? origType : decl->type); + ((TypeFunction*)origType)->toCBufferWithAttributes(buf, decl->ident, &hgs, attrType, td); + } + else + origType->toCBuffer(buf, decl->ident, &hgs); + } + else + buf->writestring(decl->ident->toChars()); + buf->writestring(";\n"); + } +} + +void Declaration::toDocBuffer(OutBuffer *buf) +{ + declarationToDocBuffer(this, buf, NULL); +} + +void AliasDeclaration::toDocBuffer(OutBuffer *buf) +{ + //printf("AliasDeclaration::toDocbuffer() %s\n", toChars()); + if (ident) + { + if (isDeprecated()) + buf->writestring("deprecated "); + + emitProtection(buf, protection); + buf->writestring("alias "); + buf->writestring(toChars()); + buf->writestring(";\n"); + } +} + + +void TypedefDeclaration::toDocBuffer(OutBuffer *buf) +{ + if (ident) + { + if (isDeprecated()) + buf->writestring("deprecated "); + + emitProtection(buf, protection); + buf->writestring("typedef "); + buf->writestring(toChars()); + buf->writestring(";\n"); + } +} + + +void FuncDeclaration::toDocBuffer(OutBuffer *buf) +{ + //printf("FuncDeclaration::toDocbuffer() %s\n", toChars()); + if (ident) + { + TemplateDeclaration *td; + + if (parent && + (td = parent->isTemplateDeclaration()) != NULL && + td->onemember == this) + { /* It's a function template + */ + unsigned o = buf->offset; + + declarationToDocBuffer(this, buf, td); + + highlightCode(NULL, this, buf, o); + } + else + { + Declaration::toDocBuffer(buf); + } + } +} + +#if DMDV1 +void CtorDeclaration::toDocBuffer(OutBuffer *buf) +{ + HdrGenState hgs; + + buf->writestring("this"); + Parameter::argsToCBuffer(buf, &hgs, arguments, varargs); + buf->writestring(";\n"); +} +#endif + +void AggregateDeclaration::toDocBuffer(OutBuffer *buf) +{ + if (ident) + { +#if 0 + emitProtection(buf, protection); +#endif + buf->printf("%s $(DDOC_PSYMBOL %s)", kind(), toChars()); + buf->writestring(";\n"); + } +} + +void StructDeclaration::toDocBuffer(OutBuffer *buf) +{ + //printf("StructDeclaration::toDocbuffer() %s\n", toChars()); + if (ident) + { +#if 0 + emitProtection(buf, protection); +#endif + TemplateDeclaration *td; + + if (parent && + (td = parent->isTemplateDeclaration()) != NULL && + td->onemember == this) + { unsigned o = buf->offset; + td->toDocBuffer(buf); + highlightCode(NULL, this, buf, o); + } + else + { + buf->printf("%s $(DDOC_PSYMBOL %s)", kind(), toChars()); + } + buf->writestring(";\n"); + } +} + +void ClassDeclaration::toDocBuffer(OutBuffer *buf) +{ + //printf("ClassDeclaration::toDocbuffer() %s\n", toChars()); + if (ident) + { +#if 0 + emitProtection(buf, protection); +#endif + TemplateDeclaration *td; + + if (parent && + (td = parent->isTemplateDeclaration()) != NULL && + td->onemember == this) + { unsigned o = buf->offset; + td->toDocBuffer(buf); + highlightCode(NULL, this, buf, o); + } + else + { + if (isAbstract()) + buf->writestring("abstract "); + buf->printf("%s $(DDOC_PSYMBOL %s)", kind(), toChars()); + } + int any = 0; + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *bc = (*baseclasses)[i]; + + if (bc->protection == PROTprivate) + continue; + if (bc->base && bc->base->ident == Id::Object) + continue; + + if (any) + buf->writestring(", "); + else + { buf->writestring(": "); + any = 1; + } + emitProtection(buf, bc->protection); + if (bc->base) + { + buf->writestring(bc->base->toPrettyChars()); + } + else + { + HdrGenState hgs; + bc->type->toCBuffer(buf, NULL, &hgs); + } + } + buf->writestring(";\n"); + } +} + + +void EnumDeclaration::toDocBuffer(OutBuffer *buf) +{ + if (ident) + { + buf->printf("%s $(DDOC_PSYMBOL %s)", kind(), toChars()); + buf->writestring(";\n"); + } +} + +void EnumMember::toDocBuffer(OutBuffer *buf) +{ + if (ident) + { + buf->writestring(toChars()); + } +} + + +/********************************* DocComment *********************************/ + +DocComment::DocComment() +{ + memset(this, 0, sizeof(DocComment)); +} + +DocComment *DocComment::parse(Scope *sc, Dsymbol *s, unsigned char *comment) +{ + //printf("parse(%s): '%s'\n", s->toChars(), comment); + if (sc->lastdc && isDitto(comment)) + return NULL; + + DocComment *dc = new DocComment(); + if (!comment) + return dc; + + dc->parseSections(comment); + + for (size_t i = 0; i < dc->sections.dim; i++) + { Section *sec = dc->sections[i]; + + if (icmp("copyright", sec->name, sec->namelen) == 0) + { + dc->copyright = sec; + } + if (icmp("macros", sec->name, sec->namelen) == 0) + { + dc->macros = sec; + } + } + + sc->lastdc = dc; + return dc; +} + +/***************************************** + * Parse next paragraph out of *pcomment. + * Update *pcomment to point past paragraph. + * Returns NULL if no more paragraphs. + * If paragraph ends in 'identifier:', + * then (*pcomment)[0 .. idlen] is the identifier. + */ + +void DocComment::parseSections(unsigned char *comment) +{ unsigned char *p; + unsigned char *pstart; + unsigned char *pend; + unsigned char *idstart; + unsigned idlen; + + unsigned char *name = NULL; + unsigned namelen = 0; + + //printf("parseSections('%s')\n", comment); + p = comment; + while (*p) + { + p = skipwhitespace(p); + pstart = p; + pend = p; + + /* Find end of section, which is ended by one of: + * 'identifier:' (but not inside a code section) + * '\0' + */ + idlen = 0; + int inCode = 0; + while (1) + { + // Check for start/end of a code section + if (*p == '-') + { + int numdash = 0; + while (*p == '-') + { + ++numdash; + p++; + } + // BUG: handle UTF PS and LS too + if (!*p || *p == '\r' || *p == '\n' && numdash >= 3) + inCode ^= 1; + pend = p; + } + + if (!inCode && isIdStart(p)) + { + unsigned char *q = p + utfStride(p); + while (isIdTail(q)) + q += utfStride(q); + if (*q == ':') // identifier: ends it + { idlen = q - p; + idstart = p; + for (pend = p; pend > pstart; pend--) + { if (pend[-1] == '\n') + break; + } + p = q + 1; + break; + } + } + while (1) + { + if (!*p) + goto L1; + if (*p == '\n') + { p++; + if (*p == '\n' && !summary && !namelen && !inCode) + { + pend = p; + p++; + goto L1; + } + break; + } + p++; + pend = p; + } + p = skipwhitespace(p); + } + L1: + + if (namelen || pstart < pend) + { + Section *s; + if (icmp("Params", name, namelen) == 0) + s = new ParamSection(); + else if (icmp("Macros", name, namelen) == 0) + s = new MacroSection(); + else + s = new Section(); + s->name = name; + s->namelen = namelen; + s->body = pstart; + s->bodylen = pend - pstart; + s->nooutput = 0; + + //printf("Section: '%.*s' = '%.*s'\n", s->namelen, s->name, s->bodylen, s->body); + + sections.push(s); + + if (!summary && !namelen) + summary = s; + } + + if (idlen) + { name = idstart; + namelen = idlen; + } + else + { name = NULL; + namelen = 0; + if (!*p) + break; + } + } +} + +void DocComment::writeSections(Scope *sc, Dsymbol *s, OutBuffer *buf) +{ + //printf("DocComment::writeSections()\n"); + if (sections.dim) + { + buf->writestring("$(DDOC_SECTIONS \n"); + for (size_t i = 0; i < sections.dim; i++) + { Section *sec = sections[i]; + + if (sec->nooutput) + continue; + //printf("Section: '%.*s' = '%.*s'\n", sec->namelen, sec->name, sec->bodylen, sec->body); + if (sec->namelen || i) + sec->write(this, sc, s, buf); + else + { + buf->writestring("$(DDOC_SUMMARY "); + unsigned o = buf->offset; + buf->write(sec->body, sec->bodylen); + escapeStrayParenthesis(buf, o, s->loc); + highlightText(sc, s, buf, o); + buf->writestring(")\n"); + } + } + buf->writestring(")\n"); + } + else + { + buf->writestring("$(DDOC_BLANKLINE)\n"); + } +} + +/*************************************************** + */ + +void Section::write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf) +{ + if (namelen) + { + static const char *table[] = + { "AUTHORS", "BUGS", "COPYRIGHT", "DATE", + "DEPRECATED", "EXAMPLES", "HISTORY", "LICENSE", + "RETURNS", "SEE_ALSO", "STANDARDS", "THROWS", + "VERSION" }; + + for (int i = 0; i < sizeof(table) / sizeof(table[0]); i++) + { + if (icmp(table[i], name, namelen) == 0) + { + buf->printf("$(DDOC_%s ", table[i]); + goto L1; + } + } + + buf->writestring("$(DDOC_SECTION "); + // Replace _ characters with spaces + buf->writestring("$(DDOC_SECTION_H "); + unsigned o = buf->offset; + for (unsigned u = 0; u < namelen; u++) + { unsigned char c = name[u]; + buf->writeByte((c == '_') ? ' ' : c); + } + escapeStrayParenthesis(buf, o, s->loc); + buf->writestring(":)\n"); + } + else + { + buf->writestring("$(DDOC_DESCRIPTION "); + } + L1: + unsigned o = buf->offset; + buf->write(body, bodylen); + escapeStrayParenthesis(buf, o, s->loc); + highlightText(sc, s, buf, o); + buf->writestring(")\n"); +} + +/*************************************************** + */ + +void ParamSection::write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf) +{ + unsigned char *p = body; + unsigned len = bodylen; + unsigned char *pend = p + len; + + unsigned char *tempstart; + unsigned templen; + + unsigned char *namestart; + unsigned namelen = 0; // !=0 if line continuation + + unsigned char *textstart; + unsigned textlen; + + unsigned o; + Parameter *arg; + + buf->writestring("$(DDOC_PARAMS \n"); + while (p < pend) + { + // Skip to start of macro + while (1) + { + switch (*p) + { + case ' ': + case '\t': + p++; + continue; + + case '\n': + p++; + goto Lcont; + + default: + if (isIdStart(p)) + break; + if (namelen) + goto Ltext; // continuation of prev macro + goto Lskipline; + } + break; + } + tempstart = p; + + while (isIdTail(p)) + p += utfStride(p); + templen = p - tempstart; + + while (*p == ' ' || *p == '\t') + p++; + + if (*p != '=') + { if (namelen) + goto Ltext; // continuation of prev macro + goto Lskipline; + } + p++; + + if (namelen) + { // Output existing param + + L1: + //printf("param '%.*s' = '%.*s'\n", namelen, namestart, textlen, textstart); + HdrGenState hgs; + buf->writestring("$(DDOC_PARAM_ROW "); + buf->writestring("$(DDOC_PARAM_ID "); + o = buf->offset; + arg = isFunctionParameter(s, namestart, namelen); + if (arg && arg->type && arg->ident) + arg->type->toCBuffer(buf, arg->ident, &hgs); + else + buf->write(namestart, namelen); + escapeStrayParenthesis(buf, o, s->loc); + highlightCode(sc, s, buf, o); + buf->writestring(")\n"); + + buf->writestring("$(DDOC_PARAM_DESC "); + o = buf->offset; + buf->write(textstart, textlen); + escapeStrayParenthesis(buf, o, s->loc); + highlightText(sc, s, buf, o); + buf->writestring(")"); + buf->writestring(")\n"); + namelen = 0; + if (p >= pend) + break; + } + + namestart = tempstart; + namelen = templen; + + while (*p == ' ' || *p == '\t') + p++; + textstart = p; + + Ltext: + while (*p != '\n') + p++; + textlen = p - textstart; + p++; + + Lcont: + continue; + + Lskipline: + // Ignore this line + while (*p++ != '\n') + ; + } + if (namelen) + goto L1; // write out last one + buf->writestring(")\n"); +} + +/*************************************************** + */ + +void MacroSection::write(DocComment *dc, Scope *sc, Dsymbol *s, OutBuffer *buf) +{ + //printf("MacroSection::write()\n"); + DocComment::parseMacros(dc->pescapetable, dc->pmacrotable, body, bodylen); +} + +/************************************************ + * Parse macros out of Macros: section. + * Macros are of the form: + * name1 = value1 + * + * name2 = value2 + */ + +void DocComment::parseMacros(Escape **pescapetable, Macro **pmacrotable, unsigned char *m, unsigned mlen) +{ + unsigned char *p = m; + unsigned len = mlen; + unsigned char *pend = p + len; + + unsigned char *tempstart; + unsigned templen; + + unsigned char *namestart; + unsigned namelen = 0; // !=0 if line continuation + + unsigned char *textstart; + unsigned textlen; + + while (p < pend) + { + // Skip to start of macro + while (1) + { + if (p >= pend) + goto Ldone; + switch (*p) + { + case ' ': + case '\t': + p++; + continue; + + case '\n': + p++; + goto Lcont; + + default: + if (isIdStart(p)) + break; + if (namelen) + goto Ltext; // continuation of prev macro + goto Lskipline; + } + break; + } + tempstart = p; + + while (1) + { + if (p >= pend) + goto Ldone; + if (!isIdTail(p)) + break; + p += utfStride(p); + } + templen = p - tempstart; + + while (1) + { + if (p >= pend) + goto Ldone; + if (!(*p == ' ' || *p == '\t')) + break; + p++; + } + + if (*p != '=') + { if (namelen) + goto Ltext; // continuation of prev macro + goto Lskipline; + } + p++; + if (p >= pend) + goto Ldone; + + if (namelen) + { // Output existing macro + L1: + //printf("macro '%.*s' = '%.*s'\n", namelen, namestart, textlen, textstart); + if (icmp("ESCAPES", namestart, namelen) == 0) + parseEscapes(pescapetable, textstart, textlen); + else + Macro::define(pmacrotable, namestart, namelen, textstart, textlen); + namelen = 0; + if (p >= pend) + break; + } + + namestart = tempstart; + namelen = templen; + + while (p < pend && (*p == ' ' || *p == '\t')) + p++; + textstart = p; + + Ltext: + while (p < pend && *p != '\n') + p++; + textlen = p - textstart; + + // Remove trailing \r if there is one + if (p > m && p[-1] == '\r') + textlen--; + + p++; + //printf("p = %p, pend = %p\n", p, pend); + + Lcont: + continue; + + Lskipline: + // Ignore this line + while (p < pend && *p++ != '\n') + ; + } +Ldone: + if (namelen) + goto L1; // write out last one +} + +/************************************** + * Parse escapes of the form: + * /c/string/ + * where c is a single character. + * Multiple escapes can be separated + * by whitespace and/or commas. + */ + +void DocComment::parseEscapes(Escape **pescapetable, unsigned char *textstart, unsigned textlen) +{ Escape *escapetable = *pescapetable; + + if (!escapetable) + { escapetable = new Escape; + *pescapetable = escapetable; + } + unsigned char *p = textstart; + unsigned char *pend = p + textlen; + + while (1) + { + while (1) + { + if (p + 4 >= pend) + return; + if (!(*p == ' ' || *p == '\t' || *p == '\n' || *p == ',')) + break; + p++; + } + if (p[0] != '/' || p[2] != '/') + return; + unsigned char c = p[1]; + p += 3; + unsigned char *start = p; + while (1) + { + if (p >= pend) + return; + if (*p == '/') + break; + p++; + } + size_t len = p - start; + char *s = (char *)memcpy(mem.malloc(len + 1), start, len); + s[len] = 0; + escapetable->strings[c] = s; + //printf("%c = '%s'\n", c, s); + p++; + } +} + + +/****************************************** + * Compare 0-terminated string with length terminated string. + * Return < 0, ==0, > 0 + */ + +int cmp(const char *stringz, void *s, size_t slen) +{ + size_t len1 = strlen(stringz); + + if (len1 != slen) + return len1 - slen; + return memcmp(stringz, s, slen); +} + +int icmp(const char *stringz, void *s, size_t slen) +{ + size_t len1 = strlen(stringz); + + if (len1 != slen) + return len1 - slen; + return memicmp(stringz, (char *)s, slen); +} + +/***************************************** + * Return !=0 if comment consists entirely of "ditto". + */ + +int isDitto(unsigned char *comment) +{ + if (comment) + { + unsigned char *p = skipwhitespace(comment); + + if (memicmp((char *)p, "ditto", 5) == 0 && *skipwhitespace(p + 5) == 0) + return 1; + } + return 0; +} + +/********************************************** + * Skip white space. + */ + +unsigned char *skipwhitespace(unsigned char *p) +{ + for (; 1; p++) + { switch (*p) + { + case ' ': + case '\t': + case '\n': + continue; + } + break; + } + return p; +} + + +/************************************************ + * Scan forward to one of: + * start of identifier + * beginning of next line + * end of buf + */ + +unsigned skiptoident(OutBuffer *buf, size_t i) +{ + while (i < buf->offset) + { dchar_t c; + + size_t oi = i; + if (utf_decodeChar((unsigned char *)buf->data, buf->offset, &i, &c)) + /* Ignore UTF errors, but still consume input + */ + break; + if (c >= 0x80) + { + if (!isUniAlpha(c)) + continue; + } + else if (!(isalpha(c) || c == '_' || c == '\n')) + continue; + i = oi; + break; + } + return i; +} + +/************************************************ + * Scan forward past end of identifier. + */ + +unsigned skippastident(OutBuffer *buf, size_t i) +{ + while (i < buf->offset) + { dchar_t c; + + size_t oi = i; + if (utf_decodeChar((unsigned char *)buf->data, buf->offset, &i, &c)) + /* Ignore UTF errors, but still consume input + */ + break; + if (c >= 0x80) + { + if (isUniAlpha(c)) + continue; + } + else if (isalnum(c) || c == '_') + continue; + i = oi; + break; + } + return i; +} + + +/************************************************ + * Scan forward past URL starting at i. + * We don't want to highlight parts of a URL. + * Returns: + * i if not a URL + * index just past it if it is a URL + */ + +unsigned skippastURL(OutBuffer *buf, size_t i) +{ unsigned length = buf->offset - i; + unsigned char *p = &buf->data[i]; + unsigned j; + unsigned sawdot = 0; + + if (length > 7 && memicmp((char *)p, "http://", 7) == 0) + { + j = 7; + } + else if (length > 8 && memicmp((char *)p, "https://", 8) == 0) + { + j = 8; + } + else + goto Lno; + + for (; j < length; j++) + { unsigned char c = p[j]; + if (isalnum(c)) + continue; + if (c == '-' || c == '_' || c == '?' || + c == '=' || c == '%' || c == '&' || + c == '/' || c == '+' || c == '#' || + c == '~') + continue; + if (c == '.') + { + sawdot = 1; + continue; + } + break; + } + if (sawdot) + return i + j; + +Lno: + return i; +} + + +/**************************************************** + */ + +int isKeyword(unsigned char *p, unsigned len) +{ + static const char *table[] = { "true", "false", "null" }; + + for (int i = 0; i < sizeof(table) / sizeof(table[0]); i++) + { + if (cmp(table[i], p, len) == 0) + return 1; + } + return 0; +} + +/**************************************************** + */ + +Parameter *isFunctionParameter(Dsymbol *s, unsigned char *p, unsigned len) +{ + FuncDeclaration *f = s->isFuncDeclaration(); + + /* f->type may be NULL for template members. + */ + if (f && f->type) + { + TypeFunction *tf; + if (f->originalType) + { + tf = (TypeFunction *)f->originalType; + } + else + tf = (TypeFunction *)f->type; + + if (tf->parameters) + { + for (size_t k = 0; k < tf->parameters->dim; k++) + { Parameter *arg = (*tf->parameters)[k]; + + if (arg->ident && cmp(arg->ident->toChars(), p, len) == 0) + { + return arg; + } + } + } + } + return NULL; +} + +/************************************************** + * Highlight text section. + */ + +void highlightText(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset) +{ + //printf("highlightText()\n"); + const char *sid = s->ident->toChars(); + FuncDeclaration *f = s->isFuncDeclaration(); + unsigned char *p; + const char *se; + + int leadingBlank = 1; + int inCode = 0; + int inComment = 0; // in comment + unsigned iCodeStart; // start of code section + + unsigned iLineStart = offset; + + for (unsigned i = offset; i < buf->offset; i++) + { unsigned char c = buf->data[i]; + + Lcont: + switch (c) + { + case ' ': + case '\t': + break; + + case '\n': + if (sc && !inCode && i == iLineStart && i + 1 < buf->offset) // if "\n\n" + { + static char blankline[] = "$(DDOC_BLANKLINE)\n"; + + i = buf->insert(i, blankline, sizeof(blankline) - 1); + } + leadingBlank = 1; + iLineStart = i + 1; + break; + + case '<': + leadingBlank = 0; + if (inCode) + break; + p = &buf->data[i]; + + // Skip over comments + if (p[1] == '!' && p[2] == '-' && p[3] == '-') + { unsigned j = i + 4; + p += 4; + while (1) + { + if (j == buf->offset) + goto L1; + if (p[0] == '-' && p[1] == '-' && p[2] == '>') + { + i = j + 2; // place on closing '>' + break; + } + j++; + p++; + } + break; + } + + // Skip over HTML tag + if (isalpha(p[1]) || (p[1] == '/' && isalpha(p[2]))) + { unsigned j = i + 2; + p += 2; + while (1) + { + if (j == buf->offset) + goto L1; + if (p[0] == '>') + { + i = j; // place on closing '>' + break; + } + j++; + p++; + } + break; + } + + L1: + // Replace '<' with '<' character entity + se = Escape::escapeChar('<'); + if (se) + { size_t len = strlen(se); + buf->remove(i, 1); + i = buf->insert(i, se, len); + i--; // point to ';' + } + break; + + case '>': + leadingBlank = 0; + if (inCode) + break; + // Replace '>' with '>' character entity + se = Escape::escapeChar('>'); + if (se) + { size_t len = strlen(se); + buf->remove(i, 1); + i = buf->insert(i, se, len); + i--; // point to ';' + } + break; + + case '&': + leadingBlank = 0; + if (inCode) + break; + p = &buf->data[i]; + if (p[1] == '#' || isalpha(p[1])) + break; // already a character entity + // Replace '&' with '&' character entity + se = Escape::escapeChar('&'); + if (se) + { size_t len = strlen(se); + buf->remove(i, 1); + i = buf->insert(i, se, len); + i--; // point to ';' + } + break; + + case '-': + /* A line beginning with --- delimits a code section. + * inCode tells us if it is start or end of a code section. + */ + if (leadingBlank) + { int istart = i; + int eollen = 0; + + leadingBlank = 0; + while (1) + { + ++i; + if (i >= buf->offset) + break; + c = buf->data[i]; + if (c == '\n') + { eollen = 1; + break; + } + if (c == '\r') + { + eollen = 1; + if (i + 1 >= buf->offset) + break; + if (buf->data[i + 1] == '\n') + { eollen = 2; + break; + } + } + // BUG: handle UTF PS and LS too + if (c != '-') + goto Lcont; + } + if (i - istart < 3) + goto Lcont; + + // We have the start/end of a code section + + // Remove the entire --- line, including blanks and \n + buf->remove(iLineStart, i - iLineStart + eollen); + i = iLineStart; + + if (inCode && (i <= iCodeStart)) + { // Empty code section, just remove it completely. + inCode = 0; + break; + } + + if (inCode) + { + inCode = 0; + // The code section is from iCodeStart to i + OutBuffer codebuf; + + codebuf.write(buf->data + iCodeStart, i - iCodeStart); + codebuf.writeByte(0); + highlightCode2(sc, s, &codebuf, 0); + buf->remove(iCodeStart, i - iCodeStart); + i = buf->insert(iCodeStart, codebuf.data, codebuf.offset); + i = buf->insert(i, ")\n", 2); + i--; + } + else + { static char pre[] = "$(D_CODE \n"; + + inCode = 1; + i = buf->insert(i, pre, sizeof(pre) - 1); + iCodeStart = i; + i--; // place i on > + leadingBlank = true; + } + } + break; + + default: + leadingBlank = 0; + if (sc && !inCode && isIdStart(&buf->data[i])) + { unsigned j; + + j = skippastident(buf, i); + if (j > i) + { + unsigned k = skippastURL(buf, i); + if (k > i) + { i = k - 1; + break; + } + + if (buf->data[i] == '_') // leading '_' means no highlight + { + buf->remove(i, 1); + i = j - 1; + } + else + { + if (cmp(sid, buf->data + i, j - i) == 0) + { + i = buf->bracket(i, "$(DDOC_PSYMBOL ", j, ")") - 1; + break; + } + else if (isKeyword(buf->data + i, j - i)) + { + i = buf->bracket(i, "$(DDOC_KEYWORD ", j, ")") - 1; + break; + } + else + { + if (f && isFunctionParameter(f, buf->data + i, j - i)) + { + //printf("highlighting arg '%s', i = %d, j = %d\n", arg->ident->toChars(), i, j); + i = buf->bracket(i, "$(DDOC_PARAM ", j, ")") - 1; + break; + } + } + i = j - 1; + } + } + } + break; + } + } + if (inCode) + s->error("unmatched --- in DDoc comment"); + ; +} + +/************************************************** + * Highlight code for DDOC section. + */ + +void highlightCode(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset) +{ + char *sid = s->ident->toChars(); + FuncDeclaration *f = s->isFuncDeclaration(); + + //printf("highlightCode(s = '%s', kind = %s)\n", sid, s->kind()); + for (unsigned i = offset; i < buf->offset; i++) + { unsigned char c = buf->data[i]; + const char *se; + + se = Escape::escapeChar(c); + if (se) + { + size_t len = strlen(se); + buf->remove(i, 1); + i = buf->insert(i, se, len); + i--; // point to ';' + } + else if (isIdStart(&buf->data[i])) + { unsigned j; + + j = skippastident(buf, i); + if (j > i) + { + if (cmp(sid, buf->data + i, j - i) == 0) + { + i = buf->bracket(i, "$(DDOC_PSYMBOL ", j, ")") - 1; + continue; + } + else if (f) + { + if (isFunctionParameter(f, buf->data + i, j - i)) + { + //printf("highlighting arg '%s', i = %d, j = %d\n", arg->ident->toChars(), i, j); + i = buf->bracket(i, "$(DDOC_PARAM ", j, ")") - 1; + continue; + } + } + i = j - 1; + } + } + } +} + +/**************************************** + */ + +void highlightCode3(OutBuffer *buf, unsigned char *p, unsigned char *pend) +{ + for (; p < pend; p++) + { const char *s = Escape::escapeChar(*p); + if (s) + buf->writestring(s); + else + buf->writeByte(*p); + } +} + +/************************************************** + * Highlight code for CODE section. + */ + + +void highlightCode2(Scope *sc, Dsymbol *s, OutBuffer *buf, unsigned offset) +{ + char *sid = s->ident->toChars(); + FuncDeclaration *f = s->isFuncDeclaration(); + unsigned errorsave = global.errors; + Lexer lex(NULL, buf->data, 0, buf->offset - 1, 0, 1); + Token tok; + OutBuffer res; + unsigned char *lastp = buf->data; + const char *highlight; + + //printf("highlightCode2('%.*s')\n", buf->offset - 1, buf->data); + res.reserve(buf->offset); + while (1) + { + lex.scan(&tok); + highlightCode3(&res, lastp, tok.ptr); + highlight = NULL; + switch (tok.value) + { + case TOKidentifier: + if (!sc) + break; + if (cmp(sid, tok.ptr, lex.p - tok.ptr) == 0) + { + highlight = "$(D_PSYMBOL "; + break; + } + else if (f) + { + if (isFunctionParameter(f, tok.ptr, lex.p - tok.ptr)) + { + //printf("highlighting arg '%s', i = %d, j = %d\n", arg->ident->toChars(), i, j); + highlight = "$(D_PARAM "; + break; + } + } + break; + + case TOKcomment: + highlight = "$(D_COMMENT "; + break; + + case TOKstring: + highlight = "$(D_STRING "; + break; + + default: + if (tok.isKeyword()) + highlight = "$(D_KEYWORD "; + break; + } + if (highlight) + res.writestring(highlight); + highlightCode3(&res, tok.ptr, lex.p); + if (highlight) + res.writeByte(')'); + if (tok.value == TOKeof) + break; + lastp = lex.p; + } + buf->setsize(offset); + buf->write(&res); + global.errors = errorsave; +} + +/*************************************** + * Find character string to replace c with. + */ + +const char *Escape::escapeChar(unsigned c) +{ const char *s; + + switch (c) + { + case '<': + s = "<"; + break; + case '>': + s = ">"; + break; + case '&': + s = "&"; + break; + default: + s = NULL; + break; + } + return s; +} + +/**************************************** + * Determine if p points to the start of an identifier. + */ + +int isIdStart(unsigned char *p) +{ + unsigned c = *p; + if (isalpha(c) || c == '_') + return 1; + if (c >= 0x80) + { size_t i = 0; + if (utf_decodeChar(p, 4, &i, &c)) + return 0; // ignore errors + if (isUniAlpha(c)) + return 1; + } + return 0; +} + +/**************************************** + * Determine if p points to the rest of an identifier. + */ + +int isIdTail(unsigned char *p) +{ + unsigned c = *p; + if (isalnum(c) || c == '_') + return 1; + if (c >= 0x80) + { size_t i = 0; + if (utf_decodeChar(p, 4, &i, &c)) + return 0; // ignore errors + if (isUniAlpha(c)) + return 1; + } + return 0; +} + +/***************************************** + * Return number of bytes in UTF character. + */ + +int utfStride(unsigned char *p) +{ + unsigned c = *p; + if (c < 0x80) + return 1; + size_t i = 0; + utf_decodeChar(p, 4, &i, &c); // ignore errors, but still consume input + return i; +} diff --git a/doc.h b/doc.h new file mode 100644 index 00000000..ffa97fb9 --- /dev/null +++ b/doc.h @@ -0,0 +1,20 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_DOC_H +#define DMD_DOC_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +void escapeDdocString(OutBuffer *buf, unsigned start); + +#endif diff --git a/dsymbol.c b/dsymbol.c new file mode 100644 index 00000000..be460198 --- /dev/null +++ b/dsymbol.c @@ -0,0 +1,1451 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "rmem.h" +#include "speller.h" +#include "aav.h" + +#include "mars.h" +#include "dsymbol.h" +#include "aggregate.h" +#include "identifier.h" +#include "module.h" +#include "mtype.h" +#include "expression.h" +#include "statement.h" +#include "declaration.h" +#include "id.h" +#include "scope.h" +#include "init.h" +#include "import.h" +#include "template.h" +#include "attrib.h" + +/****************************** Dsymbol ******************************/ + +Dsymbol::Dsymbol() +{ + //printf("Dsymbol::Dsymbol(%p)\n", this); + this->ident = NULL; + this->c_ident = NULL; + this->parent = NULL; + this->csym = NULL; + this->isym = NULL; + this->loc = 0; + this->comment = NULL; + this->scope = NULL; +} + +Dsymbol::Dsymbol(Identifier *ident) +{ + //printf("Dsymbol::Dsymbol(%p, ident)\n", this); + this->ident = ident; + this->c_ident = NULL; + this->parent = NULL; + this->csym = NULL; + this->isym = NULL; + this->loc = 0; + this->comment = NULL; + this->scope = NULL; +} + +int Dsymbol::equals(Object *o) +{ Dsymbol *s; + + if (this == o) + return TRUE; + s = (Dsymbol *)(o); + // Overload sets don't have an ident + if (s && ident && s->ident && ident->equals(s->ident)) + return TRUE; + return FALSE; +} + +/************************************** + * Copy the syntax. + * Used for template instantiations. + * If s is NULL, allocate the new object, otherwise fill it in. + */ + +Dsymbol *Dsymbol::syntaxCopy(Dsymbol *s) +{ + print(); + printf("%s %s\n", kind(), toChars()); + assert(0); + return NULL; +} + +/************************************** + * Determine if this symbol is only one. + * Returns: + * FALSE, *ps = NULL: There are 2 or more symbols + * TRUE, *ps = NULL: There are zero symbols + * TRUE, *ps = symbol: The one and only one symbol + */ + +int Dsymbol::oneMember(Dsymbol **ps, Identifier *ident) +{ + //printf("Dsymbol::oneMember()\n"); + *ps = this; + return TRUE; +} + +/***************************************** + * Same as Dsymbol::oneMember(), but look at an array of Dsymbols. + */ + +int Dsymbol::oneMembers(Dsymbols *members, Dsymbol **ps, Identifier *ident) +{ + //printf("Dsymbol::oneMembers() %d\n", members ? members->dim : 0); + Dsymbol *s = NULL; + + if (members) + { + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *sx = (*members)[i]; + + int x = sx->oneMember(ps, ident); + //printf("\t[%d] kind %s = %d, s = %p\n", i, sx->kind(), x, *ps); + if (!x) + { + //printf("\tfalse 1\n"); + assert(*ps == NULL); + return FALSE; + } + if (*ps) + { + if (ident) + { + if (!(*ps)->ident || !(*ps)->ident->equals(ident)) + continue; + } + if (s) // more than one symbol + { *ps = NULL; + //printf("\tfalse 2\n"); + return FALSE; + } + s = *ps; + } + } + } + *ps = s; // s is the one symbol, NULL if none + //printf("\ttrue\n"); + return TRUE; +} + +/***************************************** + * Is Dsymbol a variable that contains pointers? + */ + +int Dsymbol::hasPointers() +{ + //printf("Dsymbol::hasPointers() %s\n", toChars()); + return 0; +} + +bool Dsymbol::hasStaticCtorOrDtor() +{ + //printf("Dsymbol::hasStaticCtorOrDtor() %s\n", toChars()); + return FALSE; +} + +char *Dsymbol::toChars() +{ + return ident ? ident->toChars() : (char *)"__anonymous"; +} + +const char *Dsymbol::toPrettyChars() +{ Dsymbol *p; + char *s; + char *q; + size_t len; + + //printf("Dsymbol::toPrettyChars() '%s'\n", toChars()); + if (!parent) + return toChars(); + + len = 0; + for (p = this; p; p = p->parent) + len += strlen(p->toChars()) + 1; + + s = (char *)mem.malloc(len); + q = s + len - 1; + *q = 0; + for (p = this; p; p = p->parent) + { + char *t = p->toChars(); + len = strlen(t); + q -= len; + memcpy(q, t, len); + if (q == s) + break; + q--; +#if TARGET_NET + if (AggregateDeclaration* ad = p->isAggregateDeclaration()) + { + if (ad->isNested() && p->parent && p->parent->isAggregateDeclaration()) + { + *q = '/'; + continue; + } + } +#endif + *q = '.'; + } + return s; +} + +char *Dsymbol::locToChars() +{ + OutBuffer buf; + + if (!loc.filename) // avoid bug 5861. + { + Module *m = getModule(); + + if (m && m->srcfile) + loc.filename = m->srcfile->toChars(); + } + return loc.toChars(); +} + +const char *Dsymbol::kind() +{ + return "symbol"; +} + +/********************************* + * If this symbol is really an alias for another, + * return that other. + */ + +Dsymbol *Dsymbol::toAlias() +{ + return this; +} + +Dsymbol *Dsymbol::toParent() +{ + return parent ? parent->pastMixin() : NULL; +} + +Dsymbol *Dsymbol::pastMixin() +{ + Dsymbol *s = this; + + //printf("Dsymbol::pastMixin() %s\n", toChars()); + while (s && s->isTemplateMixin()) + s = s->parent; + return s; +} + +/********************************** + * Use this instead of toParent() when looking for the + * 'this' pointer of the enclosing function/class. + */ + +Dsymbol *Dsymbol::toParent2() +{ + Dsymbol *s = parent; + while (s && s->isTemplateInstance()) + s = s->parent; + return s; +} + +TemplateInstance *Dsymbol::inTemplateInstance() +{ + for (Dsymbol *parent = this->parent; parent; parent = parent->parent) + { + TemplateInstance *ti = parent->isTemplateInstance(); + if (ti) + return ti; + } + return NULL; +} + +int Dsymbol::isAnonymous() +{ + return ident ? 0 : 1; +} + +/************************************* + * Set scope for future semantic analysis so we can + * deal better with forward references. + */ + +void Dsymbol::setScope(Scope *sc) +{ + //printf("Dsymbol::setScope() %p %s\n", this, toChars()); + if (!sc->nofree) + sc->setNoFree(); // may need it even after semantic() finishes + scope = sc; +} + +void Dsymbol::importAll(Scope *sc) +{ +} + +/************************************* + * Does semantic analysis on the public face of declarations. + */ + +void Dsymbol::semantic0(Scope *sc) +{ +} + +void Dsymbol::semantic(Scope *sc) +{ + error("%p has no semantic routine", this); +} + +/************************************* + * Does semantic analysis on initializers and members of aggregates. + */ + +void Dsymbol::semantic2(Scope *sc) +{ + // Most Dsymbols have no further semantic analysis needed +} + +/************************************* + * Does semantic analysis on function bodies. + */ + +void Dsymbol::semantic3(Scope *sc) +{ + // Most Dsymbols have no further semantic analysis needed +} + +/************************************* + * Look for function inlining possibilities. + */ + +void Dsymbol::inlineScan() +{ + // Most Dsymbols aren't functions +} + +/********************************************* + * Search for ident as member of s. + * Input: + * flags: 1 don't find private members + * 2 don't give error messages + * 4 return NULL if ambiguous + * Returns: + * NULL if not found + */ + +Dsymbol *Dsymbol::search(Loc loc, Identifier *ident, int flags) +{ + //printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars()); + return NULL; +} + +/*************************************************** + * Search for symbol with correct spelling. + */ + +void *symbol_search_fp(void *arg, const char *seed) +{ + Dsymbol *s = (Dsymbol *)arg; + Identifier id(seed, 0); + Module::clearCache(); + s = s->search(0, &id, 4|2); + return s; +} + +Dsymbol *Dsymbol::search_correct(Identifier *ident) +{ + if (global.gag) + return NULL; // don't do it for speculative compiles; too time consuming + + return (Dsymbol *)speller(ident->toChars(), &symbol_search_fp, this, idchars); +} + +/*************************************** + * Search for identifier id as a member of 'this'. + * id may be a template instance. + * Returns: + * symbol found, NULL if not + */ + +Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, Identifier *id) +{ + //printf("Dsymbol::searchX(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars()); + Dsymbol *s = toAlias(); + Dsymbol *sm; + + switch (id->dyncast()) + { + case DYNCAST_IDENTIFIER: + sm = s->search(loc, id, 0); + break; + + case DYNCAST_DSYMBOL: + { // It's a template instance + //printf("\ttemplate instance id\n"); + Dsymbol *st = (Dsymbol *)id; + TemplateInstance *ti = st->isTemplateInstance(); + id = ti->name; + sm = s->search(loc, id, 0); + if (!sm) + { error("template identifier %s is not a member of %s %s", + id->toChars(), s->kind(), s->toChars()); + return NULL; + } + sm = sm->toAlias(); + TemplateDeclaration *td = sm->isTemplateDeclaration(); + if (!td) + { + error("%s is not a template, it is a %s", id->toChars(), sm->kind()); + return NULL; + } + ti->tempdecl = td; + if (!ti->semanticRun) + ti->semantic(sc); + sm = ti->toAlias(); + break; + } + + default: + assert(0); + } + return sm; +} + +int Dsymbol::overloadInsert(Dsymbol *s) +{ + //printf("Dsymbol::overloadInsert('%s')\n", s->toChars()); + return FALSE; +} + +void Dsymbol::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(toChars()); +} + +unsigned Dsymbol::size(Loc loc) +{ + error("Dsymbol '%s' has no size\n", toChars()); + return 0; +} + +int Dsymbol::isforwardRef() +{ + return FALSE; +} + +AggregateDeclaration *Dsymbol::isThis() +{ + return NULL; +} + +AggregateDeclaration *Dsymbol::isAggregateMember() // are we a member of an aggregate? +{ + Dsymbol *parent = toParent(); + if (parent && parent->isAggregateDeclaration()) + return (AggregateDeclaration *)parent; + return NULL; +} + +ClassDeclaration *Dsymbol::isClassMember() // are we a member of a class? +{ + AggregateDeclaration *ad = isAggregateMember(); + return ad ? ad->isClassDeclaration() : NULL; +} + +void Dsymbol::defineRef(Dsymbol *s) +{ + assert(0); +} + +int Dsymbol::isExport() +{ + return FALSE; +} + +int Dsymbol::isImportedSymbol() +{ + return FALSE; +} + +int Dsymbol::isDeprecated() +{ + return FALSE; +} + +#if DMDV2 +int Dsymbol::isOverloadable() +{ + return 0; +} +#endif + +LabelDsymbol *Dsymbol::isLabel() // is this a LabelDsymbol()? +{ + return NULL; +} + +AggregateDeclaration *Dsymbol::isMember() // is this a member of an AggregateDeclaration? +{ + //printf("Dsymbol::isMember() %s\n", toChars()); + Dsymbol *parent = toParent(); + //printf("parent is %s %s\n", parent->kind(), parent->toChars()); + return parent ? parent->isAggregateDeclaration() : NULL; +} + +Type *Dsymbol::getType() +{ + return NULL; +} + +int Dsymbol::needThis() +{ + return FALSE; +} + +int Dsymbol::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + //printf("Dsymbol::addMember('%s')\n", toChars()); + //printf("Dsymbol::addMember(this = %p, '%s' scopesym = '%s')\n", this, toChars(), sd->toChars()); + //printf("Dsymbol::addMember(this = %p, '%s' sd = %p, sd->symtab = %p)\n", this, toChars(), sd, sd->symtab); + parent = sd; + if (!isAnonymous()) // no name, so can't add it to symbol table + { + if (!sd->symtabInsert(this)) // if name is already defined + { + Dsymbol *s2; + + s2 = sd->symtab->lookup(ident); + if (!s2->overloadInsert(this)) + { + sd->multiplyDefined(0, this, s2); + } + } + if (sd->isAggregateDeclaration() || sd->isEnumDeclaration()) + { + if (ident == Id::__sizeof || ident == Id::__xalignof || ident == Id::mangleof) + error(".%s property cannot be redefined", ident->toChars()); + } + return 1; + } + return 0; +} + +void Dsymbol::error(const char *format, ...) +{ + //printf("Dsymbol::error()\n"); + if (!loc.filename) // avoid bug 5861. + { + Module *m = getModule(); + + if (m && m->srcfile) + loc.filename = m->srcfile->toChars(); + } + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end(ap); +} + +void Dsymbol::error(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end(ap); +} + +void Dsymbol::verror(Loc loc, const char *format, va_list ap) +{ + if (!global.gag) + { + char *p = loc.toChars(); + if (!*p) + p = locToChars(); + + if (*p) + fprintf(stdmsg, "%s: ", p); + mem.free(p); + + fprintf(stdmsg, "Error: "); + fprintf(stdmsg, "%s %s ", kind(), toPrettyChars()); + + vfprintf(stdmsg, format, ap); + + fprintf(stdmsg, "\n"); + fflush(stdmsg); +//halt(); + } + else + { + global.gaggedErrors++; + } + + global.errors++; + + //fatal(); +} + +void Dsymbol::checkDeprecated(Loc loc, Scope *sc) +{ + if (!global.params.useDeprecated && isDeprecated()) + { + // Don't complain if we're inside a deprecated symbol's scope + for (Dsymbol *sp = sc->parent; sp; sp = sp->parent) + { if (sp->isDeprecated()) + goto L1; + } + + for (Scope *sc2 = sc; sc2; sc2 = sc2->enclosing) + { + if (sc2->scopesym && sc2->scopesym->isDeprecated()) + goto L1; + + // If inside a StorageClassDeclaration that is deprecated + if (sc2->stc & STCdeprecated) + goto L1; + } + + error(loc, "is deprecated"); + } + + L1: + Declaration *d = isDeclaration(); + if (d && d->storage_class & STCdisable) + { + if (!(sc->func && sc->func->storage_class & STCdisable)) + { + if (d->ident == Id::cpctor && d->toParent()) + d->toParent()->error(loc, "is not copyable because it is annotated with @disable"); + else + error(loc, "is not callable because it is annotated with @disable"); + } + } +} + +/********************************** + * Determine which Module a Dsymbol is in. + */ + +Module *Dsymbol::getModule() +{ + //printf("Dsymbol::getModule()\n"); + TemplateDeclaration *td = getFuncTemplateDecl(this); + if (td) + return td->getModule(); + + Dsymbol *s = this; + while (s) + { + //printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars()); + Module *m = s->isModule(); + if (m) + return m; + s = s->parent; + } + return NULL; +} + +/********************************** + * Determine which Module a Dsymbol is in, as far as access rights go. + */ + +Module *Dsymbol::getAccessModule() +{ + //printf("Dsymbol::getAccessModule()\n"); + TemplateDeclaration *td = getFuncTemplateDecl(this); + if (td) + return td->getAccessModule(); + + Dsymbol *s = this; + while (s) + { + //printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars()); + Module *m = s->isModule(); + if (m) + return m; + TemplateInstance *ti = s->isTemplateInstance(); + if (ti && ti->isnested) + /* Because of local template instantiation, the parent isn't where the access + * rights come from - it's the template declaration + */ + s = ti->tempdecl; + else + s = s->parent; + } + return NULL; +} + +/************************************* + */ + +enum PROT Dsymbol::prot() +{ + return PROTpublic; +} + +/************************************* + * Do syntax copy of an array of Dsymbol's. + */ + + +Dsymbols *Dsymbol::arraySyntaxCopy(Dsymbols *a) +{ + + Dsymbols *b = NULL; + if (a) + { + b = a->copy(); + for (size_t i = 0; i < b->dim; i++) + { + Dsymbol *s = (*b)[i]; + + s = s->syntaxCopy(NULL); + (*b)[i] = s; + } + } + return b; +} + + +/**************************************** + * Add documentation comment to Dsymbol. + * Ignore NULL comments. + */ + +void Dsymbol::addComment(unsigned char *comment) +{ + //if (comment) + //printf("adding comment '%s' to symbol %p '%s'\n", comment, this, toChars()); + + if (!this->comment) + this->comment = comment; +#if 1 + else if (comment && strcmp((char *)comment, (char *)this->comment)) + { // Concatenate the two + this->comment = Lexer::combineComments(this->comment, comment); + } +#endif +} + +/********************************* OverloadSet ****************************/ + +#if DMDV2 +OverloadSet::OverloadSet() + : Dsymbol() +{ +} + +void OverloadSet::push(Dsymbol *s) +{ + a.push(s); +} + +const char *OverloadSet::kind() +{ + return "overloadset"; +} +#endif + + +/********************************* ScopeDsymbol ****************************/ + +ScopeDsymbol::ScopeDsymbol() + : Dsymbol() +{ + members = NULL; + symtab = NULL; + imports = NULL; + prots = NULL; +} + +ScopeDsymbol::ScopeDsymbol(Identifier *id) + : Dsymbol(id) +{ + members = NULL; + symtab = NULL; + imports = NULL; + prots = NULL; +} + +Dsymbol *ScopeDsymbol::syntaxCopy(Dsymbol *s) +{ + //printf("ScopeDsymbol::syntaxCopy('%s')\n", toChars()); + + ScopeDsymbol *sd; + if (s) + sd = (ScopeDsymbol *)s; + else + sd = new ScopeDsymbol(ident); + sd->members = arraySyntaxCopy(members); + return sd; +} + +Dsymbol *ScopeDsymbol::search(Loc loc, Identifier *ident, int flags) +{ + //printf("%s->ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident->toChars(), flags); + //if (strcmp(ident->toChars(),"c") == 0) *(char*)0=0; + + // Look in symbols declared in this module + Dsymbol *s = symtab ? symtab->lookup(ident) : NULL; + //printf("\ts = %p, imports = %p, %d\n", s, imports, imports ? imports->dim : 0); + if (s) + { + //printf("\ts = '%s.%s'\n",toChars(),s->toChars()); + } + else if (imports) + { + OverloadSet *a = NULL; + + // Look in imported modules + for (size_t i = 0; i < imports->dim; i++) + { Dsymbol *ss = (*imports)[i]; + Dsymbol *s2; + + // If private import, don't search it + if (flags & 1 && prots[i] == PROTprivate) + continue; + + //printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss->toChars(), prots[i], ss->isModule(), ss->isImport()); + /* Don't find private members if ss is a module + */ + s2 = ss->search(loc, ident, ss->isModule() ? 1 : 0); + if (!s) + s = s2; + else if (s2 && s != s2) + { + if (s->toAlias() == s2->toAlias()) + { + /* After following aliases, we found the same + * symbol, so it's not an ambiguity. But if one + * alias is deprecated or less accessible, prefer + * the other. + */ + if (s->isDeprecated() || + s2->prot() > s->prot() && s2->prot() != PROTnone) + s = s2; + } + else + { + /* Two imports of the same module should be regarded as + * the same. + */ + Import *i1 = s->isImport(); + Import *i2 = s2->isImport(); + if (!(i1 && i2 && + (i1->mod == i2->mod || + (!i1->parent->isImport() && !i2->parent->isImport() && + i1->ident->equals(i2->ident)) + ) + ) + ) + { + /* If both s2 and s are overloadable (though we only + * need to check s once) + */ + if (s2->isOverloadable() && (a || s->isOverloadable())) + { if (!a) + a = new OverloadSet(); + /* Don't add to a[] if s2 is alias of previous sym + */ + for (size_t j = 0; j < a->a.dim; j++) + { Dsymbol *s3 = a->a[j]; + if (s2->toAlias() == s3->toAlias()) + { + if (s3->isDeprecated() || + s2->prot() > s3->prot() && s2->prot() != PROTnone) + a->a[j] = s2; + goto Lcontinue; + } + } + a->push(s2); + Lcontinue: + continue; + } + if (flags & 4) // if return NULL on ambiguity + return NULL; + if (!(flags & 2)) + ScopeDsymbol::multiplyDefined(loc, s, s2); + break; + } + } + } + } + + /* Build special symbol if we had multiple finds + */ + if (a) + { assert(s); + a->push(s); + s = a; + } + + if (s) + { + Declaration *d = s->isDeclaration(); + if (d && d->protection == PROTprivate && + !d->parent->isTemplateMixin() && + !(flags & 2)) + error(loc, "%s is private", d->toPrettyChars()); + } + } + return s; +} + +void ScopeDsymbol::importScope(Dsymbol *s, enum PROT protection) +{ + //printf("%s->ScopeDsymbol::importScope(%s, %d)\n", toChars(), s->toChars(), protection); + + // No circular or redundant import's + if (s != this) + { + if (!imports) + imports = new Dsymbols(); + else + { + for (size_t i = 0; i < imports->dim; i++) + { Dsymbol *ss = (*imports)[i]; + if (ss == s) // if already imported + { + if (protection > prots[i]) + prots[i] = protection; // upgrade access + return; + } + } + } + imports->push(s); + prots = (unsigned char *)mem.realloc(prots, imports->dim * sizeof(prots[0])); + prots[imports->dim - 1] = protection; + } +} + +int ScopeDsymbol::isforwardRef() +{ + return (members == NULL); +} + +void ScopeDsymbol::defineRef(Dsymbol *s) +{ + ScopeDsymbol *ss; + + ss = s->isScopeDsymbol(); + members = ss->members; + ss->members = NULL; +} + +void ScopeDsymbol::multiplyDefined(Loc loc, Dsymbol *s1, Dsymbol *s2) +{ +#if 0 + printf("ScopeDsymbol::multiplyDefined()\n"); + printf("s1 = %p, '%s' kind = '%s', parent = %s\n", s1, s1->toChars(), s1->kind(), s1->parent ? s1->parent->toChars() : ""); + printf("s2 = %p, '%s' kind = '%s', parent = %s\n", s2, s2->toChars(), s2->kind(), s2->parent ? s2->parent->toChars() : ""); +#endif + if (loc.filename) + { ::error(loc, "%s at %s conflicts with %s at %s", + s1->toPrettyChars(), + s1->locToChars(), + s2->toPrettyChars(), + s2->locToChars()); + } + else + { + s1->error(loc, "conflicts with %s %s at %s", + s2->kind(), + s2->toPrettyChars(), + s2->locToChars()); + } +} + +Dsymbol *ScopeDsymbol::nameCollision(Dsymbol *s) +{ + Dsymbol *sprev; + + // Look to see if we are defining a forward referenced symbol + + sprev = symtab->lookup(s->ident); + assert(sprev); + if (s->equals(sprev)) // if the same symbol + { + if (s->isforwardRef()) // if second declaration is a forward reference + return sprev; + if (sprev->isforwardRef()) + { + sprev->defineRef(s); // copy data from s into sprev + return sprev; + } + } + multiplyDefined(0, s, sprev); + return sprev; +} + +const char *ScopeDsymbol::kind() +{ + return "ScopeDsymbol"; +} + +Dsymbol *ScopeDsymbol::symtabInsert(Dsymbol *s) +{ + return symtab->insert(s); +} + +/**************************************** + * Return true if any of the members are static ctors or static dtors, or if + * any members have members that are. + */ + +bool ScopeDsymbol::hasStaticCtorOrDtor() +{ + if (members) + { + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *member = (*members)[i]; + + if (member->hasStaticCtorOrDtor()) + return TRUE; + } + } + return FALSE; +} + +/*************************************** + * Determine number of Dsymbols, folding in AttribDeclaration members. + */ + +#if DMDV2 +static int dimDg(void *ctx, size_t n, Dsymbol *) +{ + ++*(size_t *)ctx; + return 0; +} + +size_t ScopeDsymbol::dim(Dsymbols *members) +{ + size_t n = 0; + foreach(members, &dimDg, &n); + return n; +} +#endif + +/*************************************** + * Get nth Dsymbol, folding in AttribDeclaration members. + * Returns: + * Dsymbol* nth Dsymbol + * NULL not found, *pn gets incremented by the number + * of Dsymbols + */ + +#if DMDV2 +struct GetNthSymbolCtx +{ + size_t nth; + Dsymbol *sym; +}; + +static int getNthSymbolDg(void *ctx, size_t n, Dsymbol *sym) +{ + GetNthSymbolCtx *p = (GetNthSymbolCtx *)ctx; + if (n == p->nth) + { p->sym = sym; + return 1; + } + return 0; +} + +Dsymbol *ScopeDsymbol::getNth(Dsymbols *members, size_t nth, size_t *pn) +{ + GetNthSymbolCtx ctx = { nth, NULL }; + int res = foreach(members, &getNthSymbolDg, &ctx); + return res ? ctx.sym : NULL; +} +#endif + +/*************************************** + * Expands attribute declarations in members in depth first + * order. Calls dg(void *ctx, size_t symidx, Dsymbol *sym) for each + * member. + * If dg returns !=0, stops and returns that value else returns 0. + * Use this function to avoid the O(N + N^2/2) complexity of + * calculating dim and calling N times getNth. + */ + +#if DMDV2 +int ScopeDsymbol::foreach(Dsymbols *members, ScopeDsymbol::ForeachDg dg, void *ctx, size_t *pn) +{ + assert(dg); + if (!members) + return 0; + + size_t n = pn ? *pn : 0; // take over index + int result = 0; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = (*members)[i]; + + if (AttribDeclaration *a = s->isAttribDeclaration()) + result = foreach(a->decl, dg, ctx, &n); + else if (TemplateMixin *tm = s->isTemplateMixin()) + result = foreach(tm->members, dg, ctx, &n); + else if (s->isTemplateInstance()) + ; + else + result = dg(ctx, n++, s); + + if (result) + break; + } + + if (pn) + *pn = n; // update index + return result; +} +#endif + +/******************************************* + * Look for member of the form: + * const(MemberInfo)[] getMembers(string); + * Returns NULL if not found + */ + +#if DMDV2 +FuncDeclaration *ScopeDsymbol::findGetMembers() +{ + Dsymbol *s = search_function(this, Id::getmembers); + FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL; + +#if 0 // Finish + static TypeFunction *tfgetmembers; + + if (!tfgetmembers) + { + Scope sc; + Parameters *arguments = new Parameters; + Parameters *arg = new Parameter(STCin, Type::tchar->constOf()->arrayOf(), NULL, NULL); + arguments->push(arg); + + Type *tret = NULL; + tfgetmembers = new TypeFunction(arguments, tret, 0, LINKd); + tfgetmembers = (TypeFunction *)tfgetmembers->semantic(0, &sc); + } + if (fdx) + fdx = fdx->overloadExactMatch(tfgetmembers); +#endif + if (fdx && fdx->isVirtual()) + fdx = NULL; + + return fdx; +} +#endif + + +/****************************** WithScopeSymbol ******************************/ + +WithScopeSymbol::WithScopeSymbol(WithStatement *withstate) + : ScopeDsymbol() +{ + this->withstate = withstate; +} + +Dsymbol *WithScopeSymbol::search(Loc loc, Identifier *ident, int flags) +{ + // Acts as proxy to the with class declaration + return withstate->exp->type->toDsymbol(NULL)->search(loc, ident, 0); +} + +/****************************** ArrayScopeSymbol ******************************/ + +ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, Expression *e) + : ScopeDsymbol() +{ + assert(e->op == TOKindex || e->op == TOKslice || e->op == TOKarray); + exp = e; + type = NULL; + td = NULL; + this->sc = sc; +} + +ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TypeTuple *t) + : ScopeDsymbol() +{ + exp = NULL; + type = t; + td = NULL; + this->sc = sc; +} + +ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TupleDeclaration *s) + : ScopeDsymbol() +{ + exp = NULL; + type = NULL; + td = s; + this->sc = sc; +} + +Dsymbol *ArrayScopeSymbol::search(Loc loc, Identifier *ident, int flags) +{ + //printf("ArrayScopeSymbol::search('%s', flags = %d)\n", ident->toChars(), flags); + if (ident == Id::length || ident == Id::dollar) + { VarDeclaration **pvar; + Expression *ce; + + if (ident == Id::length && !global.params.useDeprecated) + error("using 'length' inside [ ] is deprecated, use '$' instead"); + + L1: + + if (td) + { /* $ gives the number of elements in the tuple + */ + VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); + Expression *e = new IntegerExp(0, td->objects->dim, Type::tsize_t); + v->init = new ExpInitializer(0, e); + v->storage_class |= STCstatic | STCconst; + v->semantic(sc); + return v; + } + + if (type) + { /* $ gives the number of type entries in the type tuple + */ + VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); + Expression *e = new IntegerExp(0, type->arguments->dim, Type::tsize_t); + v->init = new ExpInitializer(0, e); + v->storage_class |= STCstatic | STCconst; + v->semantic(sc); + return v; + } + + if (exp->op == TOKindex) + { /* array[index] where index is some function of $ + */ + IndexExp *ie = (IndexExp *)exp; + + pvar = &ie->lengthVar; + ce = ie->e1; + } + else if (exp->op == TOKslice) + { /* array[lwr .. upr] where lwr or upr is some function of $ + */ + SliceExp *se = (SliceExp *)exp; + + pvar = &se->lengthVar; + ce = se->e1; + } + else if (exp->op == TOKarray) + { /* array[e0, e1, e2, e3] where e0, e1, e2 are some function of $ + * $ is a opDollar!(dim)() where dim is the dimension(0,1,2,...) + */ + ArrayExp *ae = (ArrayExp *)exp; + AggregateDeclaration *ad = NULL; + + Type *t = ae->e1->type->toBasetype(); + if (t->ty == Tclass) + { + ad = ((TypeClass *)t)->sym; + } + else if (t->ty == Tstruct) + { + ad = ((TypeStruct *)t)->sym; + } + assert(ad); + + Dsymbol *dsym = search_function(ad, Id::opDollar); + if (!dsym) // no dollar exists -- search in higher scope + return NULL; + VarDeclaration *v = ae->lengthVar; + if (!v) + { // $ is lazily initialized. Create it now. + TemplateDeclaration *td = dsym->isTemplateDeclaration(); + if (td) + { // Instantiate opDollar!(dim) with the index as a template argument + Objects *tdargs = new Objects(); + tdargs->setDim(1); + + Expression *x = new IntegerExp(0, ae->currentDimension, Type::tsize_t); + x = x->semantic(sc); + tdargs->data[0] = x; + + //TemplateInstance *ti = new TemplateInstance(loc, td, tdargs); + //ti->semantic(sc); + + DotTemplateInstanceExp *dte = new DotTemplateInstanceExp(loc, ae->e1, td->ident, tdargs); + + v = new VarDeclaration(loc, NULL, Id::dollar, new ExpInitializer(0, dte)); + } + else + { /* opDollar exists, but it's a function, not a template. + * This is acceptable ONLY for single-dimension indexing. + * Note that it's impossible to have both template & function opDollar, + * because both take no arguments. + */ + if (ae->arguments->dim != 1) { + ae->error("%s only defines opDollar for one dimension", ad->toChars()); + return NULL; + } + FuncDeclaration *fd = dsym->isFuncDeclaration(); + assert(fd); + Expression * x = new DotVarExp(loc, ae->e1, fd); + + v = new VarDeclaration(loc, NULL, Id::dollar, new ExpInitializer(0, x)); + } + v->semantic(sc); + ae->lengthVar = v; + } + return v; + } + else + /* Didn't find $, look in enclosing scope(s). + */ + return NULL; + + /* If we are indexing into an array that is really a type + * tuple, rewrite this as an index into a type tuple and + * try again. + */ + if (ce->op == TOKtype) + { + Type *t = ((TypeExp *)ce)->type; + if (t->ty == Ttuple) + { type = (TypeTuple *)t; + goto L1; + } + } + + /* *pvar is lazily initialized, so if we refer to $ + * multiple times, it gets set only once. + */ + if (!*pvar) // if not already initialized + { /* Create variable v and set it to the value of $ + */ + VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); + if (ce->op == TOKtuple) + { /* It is for an expression tuple, so the + * length will be a const. + */ + Expression *e = new IntegerExp(0, ((TupleExp *)ce)->exps->dim, Type::tsize_t); + v->init = new ExpInitializer(0, e); + v->storage_class |= STCstatic | STCconst; + } + else + { /* For arrays, $ will either be a compile-time constant + * (in which case its value in set during constant-folding), + * or a variable (in which case an expression is created in + * toir.c). + */ + VoidInitializer *e = new VoidInitializer(0); + e->type = Type::tsize_t; + v->init = e; + } + *pvar = v; + } + (*pvar)->semantic(sc); + return (*pvar); + } + return NULL; +} + + +/****************************** DsymbolTable ******************************/ + +DsymbolTable::DsymbolTable() +{ +#if STRINGTABLE + tab = new StringTable; + tab->init(); +#else + tab = NULL; +#endif +} + +DsymbolTable::~DsymbolTable() +{ +#if STRINGTABLE + delete tab; +#endif +} + +Dsymbol *DsymbolTable::lookup(Identifier *ident) +{ +#if STRINGTABLE +#ifdef DEBUG + assert(ident); + assert(tab); +#endif + //printf("DsymbolTable::lookup(%s)\n", (char*)ident->string); + StringValue *sv = tab->lookup((char*)ident->string, ident->len); + return (Dsymbol *)(sv ? sv->ptrvalue : NULL); +#else + //printf("DsymbolTable::lookup(%s)\n", (char*)ident->string); + return (Dsymbol *)_aaGetRvalue(tab, ident); +#endif +} + +Dsymbol *DsymbolTable::insert(Dsymbol *s) +{ + //printf("DsymbolTable::insert(this = %p, '%s')\n", this, s->ident->toChars()); + Identifier *ident = s->ident; +#if STRINGTABLE +#ifdef DEBUG + assert(ident); + assert(tab); +#endif + StringValue *sv = tab->insert(ident->toChars(), ident->len); + if (!sv) + return NULL; // already in table + sv->ptrvalue = s; + return s; +#else + Dsymbol **ps = (Dsymbol **)_aaGet(&tab, ident); + if (*ps) + return NULL; // already in table + *ps = s; + return s; +#endif +} + +Dsymbol *DsymbolTable::insert(Identifier *ident, Dsymbol *s) +{ + //printf("DsymbolTable::insert()\n"); +#if STRINGTABLE + StringValue *sv = tab->insert(ident->toChars(), ident->len); + if (!sv) + return NULL; // already in table + sv->ptrvalue = s; + return s; +#else + Dsymbol **ps = (Dsymbol **)_aaGet(&tab, ident); + if (*ps) + return NULL; // already in table + *ps = s; + return s; +#endif +} + +Dsymbol *DsymbolTable::update(Dsymbol *s) +{ + Identifier *ident = s->ident; +#if STRINGTABLE + StringValue *sv = tab->update(ident->toChars(), ident->len); + sv->ptrvalue = s; + return s; +#else + Dsymbol **ps = (Dsymbol **)_aaGet(&tab, ident); + *ps = s; + return s; +#endif +} + + + + diff --git a/dsymbol.h b/dsymbol.h new file mode 100644 index 00000000..97406f0b --- /dev/null +++ b/dsymbol.h @@ -0,0 +1,348 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_DSYMBOL_H +#define DMD_DSYMBOL_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "stringtable.h" + +#include "mars.h" +#include "arraytypes.h" + +struct Identifier; +struct Scope; +struct DsymbolTable; +struct Declaration; +struct ThisDeclaration; +struct TupleDeclaration; +struct TypedefDeclaration; +struct AliasDeclaration; +struct AggregateDeclaration; +struct EnumDeclaration; +struct ClassDeclaration; +struct InterfaceDeclaration; +struct StructDeclaration; +struct UnionDeclaration; +struct FuncDeclaration; +struct FuncAliasDeclaration; +struct FuncLiteralDeclaration; +struct CtorDeclaration; +struct PostBlitDeclaration; +struct DtorDeclaration; +struct StaticCtorDeclaration; +struct StaticDtorDeclaration; +struct SharedStaticCtorDeclaration; +struct SharedStaticDtorDeclaration; +struct InvariantDeclaration; +struct UnitTestDeclaration; +struct NewDeclaration; +struct VarDeclaration; +struct AttribDeclaration; +struct Symbol; +struct Package; +struct Module; +struct Import; +struct Type; +struct TypeTuple; +struct WithStatement; +struct LabelDsymbol; +struct ScopeDsymbol; +struct TemplateDeclaration; +struct TemplateInstance; +struct TemplateMixin; +struct EnumMember; +struct ScopeDsymbol; +struct WithScopeSymbol; +struct ArrayScopeSymbol; +struct SymbolDeclaration; +struct Expression; +struct DeleteDeclaration; +struct HdrGenState; +struct OverloadSet; +struct AA; +#if TARGET_NET +struct PragmaScope; +#endif +#if IN_GCC +union tree_node; +typedef union tree_node TYPE; +#else +struct TYPE; +#endif + +// Back end +struct Classsym; + +enum PROT +{ + PROTundefined, + PROTnone, // no access + PROTprivate, + PROTpackage, + PROTprotected, + PROTpublic, + PROTexport, +}; + +/* State of symbol in winding its way through the passes of the compiler + */ +enum PASS +{ + PASSinit, // initial state + PASSsemantic, // semantic() started + PASSsemanticdone, // semantic() done + PASSsemantic2, // semantic2() run + PASSsemantic3, // semantic3() started + PASSsemantic3done, // semantic3() done + PASSobj, // toObjFile() run +}; + +struct Dsymbol : Object +{ + Identifier *ident; + Identifier *c_ident; + Dsymbol *parent; + Symbol *csym; // symbol for code generator + Symbol *isym; // import version of csym + unsigned char *comment; // documentation comment for this Dsymbol + Loc loc; // where defined + Scope *scope; // !=NULL means context to use for semantic() + + Dsymbol(); + Dsymbol(Identifier *); + char *toChars(); + char *locToChars(); + int equals(Object *o); + int isAnonymous(); + void error(Loc loc, const char *format, ...); + void error(const char *format, ...); + void verror(Loc loc, const char *format, va_list ap); + void checkDeprecated(Loc loc, Scope *sc); + Module *getModule(); + Module *getAccessModule(); + Dsymbol *pastMixin(); + Dsymbol *toParent(); + Dsymbol *toParent2(); + TemplateInstance *inTemplateInstance(); + + int dyncast() { return DYNCAST_DSYMBOL; } // kludge for template.isSymbol() + + static Dsymbols *arraySyntaxCopy(Dsymbols *a); + + virtual const char *toPrettyChars(); + virtual const char *kind(); + virtual Dsymbol *toAlias(); // resolve real symbol + virtual int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + virtual void setScope(Scope *sc); + virtual void importAll(Scope *sc); + virtual void semantic0(Scope *sc); + virtual void semantic(Scope *sc); + virtual void semantic2(Scope *sc); + virtual void semantic3(Scope *sc); + virtual void inlineScan(); + virtual Dsymbol *search(Loc loc, Identifier *ident, int flags); + Dsymbol *search_correct(Identifier *id); + Dsymbol *searchX(Loc loc, Scope *sc, Identifier *id); + virtual int overloadInsert(Dsymbol *s); + char *toHChars(); + virtual void toHBuffer(OutBuffer *buf, HdrGenState *hgs); + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + virtual void toDocBuffer(OutBuffer *buf); + virtual void toJsonBuffer(OutBuffer *buf); + virtual unsigned size(Loc loc); + virtual int isforwardRef(); + virtual void defineRef(Dsymbol *s); + virtual AggregateDeclaration *isThis(); // is a 'this' required to access the member + AggregateDeclaration *isAggregateMember(); // are we a member of an aggregate? + ClassDeclaration *isClassMember(); // are we a member of a class? + virtual int isExport(); // is Dsymbol exported? + virtual int isImportedSymbol(); // is Dsymbol imported? + virtual int isDeprecated(); // is Dsymbol deprecated? +#if DMDV2 + virtual int isOverloadable(); +#endif + virtual LabelDsymbol *isLabel(); // is this a LabelDsymbol? + virtual AggregateDeclaration *isMember(); // is this symbol a member of an AggregateDeclaration? + virtual Type *getType(); // is this a type? + virtual char *mangle(); + virtual int needThis(); // need a 'this' pointer? + virtual enum PROT prot(); + virtual Dsymbol *syntaxCopy(Dsymbol *s); // copy only syntax trees + virtual int oneMember(Dsymbol **ps, Identifier *ident); + static int oneMembers(Dsymbols *members, Dsymbol **ps, Identifier *ident = NULL); + virtual int hasPointers(); + virtual bool hasStaticCtorOrDtor(); + virtual void addLocalClass(ClassDeclarations *) { } + virtual void checkCtorConstInit() { } + + virtual void addComment(unsigned char *comment); + virtual void emitComment(Scope *sc); + void emitDitto(Scope *sc); + + // Backend + + virtual Symbol *toSymbol(); // to backend symbol + virtual void toObjFile(int multiobj); // compile to .obj file + virtual int cvMember(unsigned char *p); // emit cv debug info for member + + Symbol *toImport(); // to backend import symbol + static Symbol *toImport(Symbol *s); // to backend import symbol + + Symbol *toSymbolX(const char *prefix, int sclass, TYPE *t, const char *suffix); // helper + + // Eliminate need for dynamic_cast + virtual Package *isPackage() { return NULL; } + virtual Module *isModule() { return NULL; } + virtual EnumMember *isEnumMember() { return NULL; } + virtual TemplateDeclaration *isTemplateDeclaration() { return NULL; } + virtual TemplateInstance *isTemplateInstance() { return NULL; } + virtual TemplateMixin *isTemplateMixin() { return NULL; } + virtual Declaration *isDeclaration() { return NULL; } + virtual ThisDeclaration *isThisDeclaration() { return NULL; } + virtual TupleDeclaration *isTupleDeclaration() { return NULL; } + virtual TypedefDeclaration *isTypedefDeclaration() { return NULL; } + virtual AliasDeclaration *isAliasDeclaration() { return NULL; } + virtual AggregateDeclaration *isAggregateDeclaration() { return NULL; } + virtual FuncDeclaration *isFuncDeclaration() { return NULL; } + virtual FuncAliasDeclaration *isFuncAliasDeclaration() { return NULL; } + virtual FuncLiteralDeclaration *isFuncLiteralDeclaration() { return NULL; } + virtual CtorDeclaration *isCtorDeclaration() { return NULL; } + virtual PostBlitDeclaration *isPostBlitDeclaration() { return NULL; } + virtual DtorDeclaration *isDtorDeclaration() { return NULL; } + virtual StaticCtorDeclaration *isStaticCtorDeclaration() { return NULL; } + virtual StaticDtorDeclaration *isStaticDtorDeclaration() { return NULL; } + virtual SharedStaticCtorDeclaration *isSharedStaticCtorDeclaration() { return NULL; } + virtual SharedStaticDtorDeclaration *isSharedStaticDtorDeclaration() { return NULL; } + virtual InvariantDeclaration *isInvariantDeclaration() { return NULL; } + virtual UnitTestDeclaration *isUnitTestDeclaration() { return NULL; } + virtual NewDeclaration *isNewDeclaration() { return NULL; } + virtual VarDeclaration *isVarDeclaration() { return NULL; } + virtual ClassDeclaration *isClassDeclaration() { return NULL; } + virtual StructDeclaration *isStructDeclaration() { return NULL; } + virtual UnionDeclaration *isUnionDeclaration() { return NULL; } + virtual InterfaceDeclaration *isInterfaceDeclaration() { return NULL; } + virtual ScopeDsymbol *isScopeDsymbol() { return NULL; } + virtual WithScopeSymbol *isWithScopeSymbol() { return NULL; } + virtual ArrayScopeSymbol *isArrayScopeSymbol() { return NULL; } + virtual Import *isImport() { return NULL; } + virtual EnumDeclaration *isEnumDeclaration() { return NULL; } + virtual DeleteDeclaration *isDeleteDeclaration() { return NULL; } + virtual SymbolDeclaration *isSymbolDeclaration() { return NULL; } + virtual AttribDeclaration *isAttribDeclaration() { return NULL; } + virtual OverloadSet *isOverloadSet() { return NULL; } +#if TARGET_NET + virtual PragmaScope* isPragmaScope() { return NULL; } +#endif +}; + +// Dsymbol that generates a scope + +struct ScopeDsymbol : Dsymbol +{ + Dsymbols *members; // all Dsymbol's in this scope + DsymbolTable *symtab; // members[] sorted into table + + Dsymbols *imports; // imported Dsymbol's + unsigned char *prots; // array of PROT, one for each import + + ScopeDsymbol(); + ScopeDsymbol(Identifier *id); + Dsymbol *syntaxCopy(Dsymbol *s); + Dsymbol *search(Loc loc, Identifier *ident, int flags); + void importScope(Dsymbol *s, enum PROT protection); + int isforwardRef(); + void defineRef(Dsymbol *s); + static void multiplyDefined(Loc loc, Dsymbol *s1, Dsymbol *s2); + Dsymbol *nameCollision(Dsymbol *s); + const char *kind(); + FuncDeclaration *findGetMembers(); + virtual Dsymbol *symtabInsert(Dsymbol *s); + bool hasStaticCtorOrDtor(); + + void emitMemberComments(Scope *sc); + + static size_t dim(Dsymbols *members); + static Dsymbol *getNth(Dsymbols *members, size_t nth, size_t *pn = NULL); + + typedef int (*ForeachDg)(void *ctx, size_t idx, Dsymbol *s); + static int foreach(Dsymbols *members, ForeachDg dg, void *ctx, size_t *pn=NULL); + + ScopeDsymbol *isScopeDsymbol() { return this; } +}; + +// With statement scope + +struct WithScopeSymbol : ScopeDsymbol +{ + WithStatement *withstate; + + WithScopeSymbol(WithStatement *withstate); + Dsymbol *search(Loc loc, Identifier *ident, int flags); + + WithScopeSymbol *isWithScopeSymbol() { return this; } +}; + +// Array Index/Slice scope + +struct ArrayScopeSymbol : ScopeDsymbol +{ + Expression *exp; // IndexExp or SliceExp + TypeTuple *type; // for tuple[length] + TupleDeclaration *td; // for tuples of objects + Scope *sc; + + ArrayScopeSymbol(Scope *sc, Expression *e); + ArrayScopeSymbol(Scope *sc, TypeTuple *t); + ArrayScopeSymbol(Scope *sc, TupleDeclaration *td); + Dsymbol *search(Loc loc, Identifier *ident, int flags); + + ArrayScopeSymbol *isArrayScopeSymbol() { return this; } +}; + +// Overload Sets + +#if DMDV2 +struct OverloadSet : Dsymbol +{ + Dsymbols a; // array of Dsymbols + + OverloadSet(); + void push(Dsymbol *s); + OverloadSet *isOverloadSet() { return this; } + const char *kind(); +}; +#endif + +// Table of Dsymbol's + +struct DsymbolTable : Object +{ + AA *tab; + + DsymbolTable(); + ~DsymbolTable(); + + // Look up Identifier. Return Dsymbol if found, NULL if not. + Dsymbol *lookup(Identifier *ident); + + // Insert Dsymbol in table. Return NULL if already there. + Dsymbol *insert(Dsymbol *s); + + // Look for Dsymbol in table. If there, return it. If not, insert s and return that. + Dsymbol *update(Dsymbol *s); + Dsymbol *insert(Identifier *ident, Dsymbol *s); // when ident and s are not the same +}; + +#endif /* DMD_DSYMBOL_H */ diff --git a/dump.c b/dump.c new file mode 100644 index 00000000..4fd0d04e --- /dev/null +++ b/dump.c @@ -0,0 +1,152 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "mars.h" +#include "mtype.h" +#include "declaration.h" +#include "expression.h" +#include "template.h" + +static void indent(int indent) +{ + int i; + + for (i = 0; i < indent; i++) + printf(" "); +} + +static char *type_print(Type *type) +{ + return type ? type->toChars() : (char *) "null"; +} + +void dumpExpressions(int i, Expressions *exps) +{ + if (exps) + { + for (size_t j = 0; j < exps->dim; j++) + { Expression *e = exps->tdata()[j]; + indent(i); + printf("(\n"); + e->dump(i + 2); + indent(i); + printf(")\n"); + } + } +} + +void Expression::dump(int i) +{ + indent(i); + printf("%p %s type=%s\n", this, Token::toChars(op), type_print(type)); +} + +void IntegerExp::dump(int i) +{ + indent(i); + printf("%p %jd type=%s\n", this, (intmax_t)value, type_print(type)); +} + +void IdentifierExp::dump(int i) +{ + indent(i); + printf("%p ident '%s' type=%s\n", this, ident->toChars(), type_print(type)); +} + +void DsymbolExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s\n", this, s->toChars(), type_print(type)); +} + +void VarExp::dump(int i) +{ + indent(i); + printf("%p %s var=%s type=%s\n", this, Token::toChars(op), var->toChars(), type_print(type)); +} + +void UnaExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s e1=%p\n", this, Token::toChars(op), type_print(type), e1); + if (e1) + e1->dump(i + 2); +} + +void CallExp::dump(int i) +{ + UnaExp::dump(i); + dumpExpressions(i, arguments); +} + +void SliceExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s e1=%p\n", this, Token::toChars(op), type_print(type), e1); + if (e1) + e1->dump(i + 2); + if (lwr) + lwr->dump(i + 2); + if (upr) + upr->dump(i + 2); +} + +void DotIdExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s ident=%s e1=%p\n", this, Token::toChars(op), type_print(type), ident->toChars(), e1); + if (e1) + e1->dump(i + 2); +} + +void DotVarExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s var='%s' e1=%p\n", this, Token::toChars(op), type_print(type), var->toChars(), e1); + if (e1) + e1->dump(i + 2); +} + +void DotTemplateInstanceExp::dump(int i) +{ + indent(i); + printf("%p %s type=%s ti='%s' e1=%p\n", this, Token::toChars(op), type_print(type), ti->toChars(), e1); + if (e1) + e1->dump(i + 2); +} + +void DelegateExp::dump(int i) +{ + indent(i); + printf("%p %s func=%s type=%s e1=%p\n", this, Token::toChars(op), func->toChars(), type_print(type), e1); + if (e1) + e1->dump(i + 2); +} + +void BinExp::dump(int i) +{ + indent(i); + const char *sop = Token::toChars(op); + if (op == TOKblit) + sop = "blit"; + else if (op == TOKconstruct) + sop = "construct"; + printf("%p %s type=%s e1=%p e2=%p\n", this, sop, type_print(type), e1, e2); + if (e1) + e1->dump(i + 2); + if (e2) + e2->dump(i + 2); +} + + diff --git a/e2ir.c b/e2ir.c new file mode 100644 index 00000000..35060b81 --- /dev/null +++ b/e2ir.c @@ -0,0 +1,5146 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#include "port.h" + +#include "lexer.h" +#include "expression.h" +#include "mtype.h" +#include "dsymbol.h" +#include "declaration.h" +#include "enum.h" +#include "aggregate.h" +#include "attrib.h" +#include "module.h" +#include "init.h" +#include "template.h" + +#include "mem.h" // for tk/mem_malloc + +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "irstate.h" +#include "id.h" +#include "type.h" +#include "toir.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +typedef ArrayBase Elems; + +elem *addressElem(elem *e, Type *t); +elem *array_toPtr(Type *t, elem *e); +elem *appendDtors(IRState *irs, elem *er, size_t starti, size_t endi); + +#define el_setLoc(e,loc) ((e)->Esrcpos.Sfilename = (char *)(loc).filename, \ + (e)->Esrcpos.Slinnum = (loc).linnum) + +/* If variable var of type typ is a reference + */ +#if SARRAYVALUE +#define ISREF(var, tb) (var->isOut() || var->isRef()) +#else +#define ISREF(var, tb) ((var->isParameter() && tb->ty == Tsarray) || var->isOut() || var->isRef()) +#endif + +/************************************ + * Call a function. + */ + +elem *callfunc(Loc loc, + IRState *irs, + int directcall, // 1: don't do virtual call + Type *tret, // return type + elem *ec, // evaluates to function address + Type *ectype, // original type of ec + FuncDeclaration *fd, // if !=NULL, this is the function being called + Type *t, // TypeDelegate or TypeFunction for this function + elem *ehidden, // if !=NULL, this is the 'hidden' argument + Expressions *arguments) +{ + elem *ep; + elem *e; + elem *ethis = NULL; + elem *eside = NULL; + tym_t ty; + tym_t tyret; + enum RET retmethod; + int reverse; + TypeFunction *tf; + int op; + +#if 0 + printf("callfunc(directcall = %d, tret = '%s', ec = %p, fd = %p)\n", + directcall, tret->toChars(), ec, fd); + printf("ec: "); elem_print(ec); + if (fd) + printf("fd = '%s', vtblIndex = %d, isVirtual() = %d\n", fd->toChars(), fd->vtblIndex, fd->isVirtual()); + if (ehidden) + { printf("ehidden: "); elem_print(ehidden); } +#endif + + t = t->toBasetype(); + if (t->ty == Tdelegate) + { + // A delegate consists of: + // { Object *this; Function *funcptr; } + assert(!fd); + assert(t->nextOf()->ty == Tfunction); + tf = (TypeFunction *)(t->nextOf()); + ethis = ec; + ec = el_same(ðis); + ethis = el_una(I64 ? OP128_64 : OP64_32, TYnptr, ethis); // get this + ec = array_toPtr(t, ec); // get funcptr + ec = el_una(OPind, tf->totym(), ec); + } + else + { assert(t->ty == Tfunction); + tf = (TypeFunction *)(t); + } + retmethod = tf->retStyle(); + ty = ec->Ety; + if (fd) + ty = fd->toSymbol()->Stype->Tty; + reverse = tyrevfunc(ty); + ep = NULL; + if (arguments) + { + // j=1 if _arguments[] is first argument + int j = (tf->linkage == LINKd && tf->varargs == 1); + + for (size_t i = 0; i < arguments->dim ; i++) + { Expression *arg = arguments->tdata()[i]; + elem *ea; + + //printf("\targ[%d]: %s\n", i, arg->toChars()); + + size_t nparams = Parameter::dim(tf->parameters); + if (i - j < nparams && i >= j) + { + Parameter *p = Parameter::getNth(tf->parameters, i - j); + + if (p->storageClass & (STCout | STCref)) + { + // Convert argument to a pointer, + // use AddrExp::toElem() + Expression *ae = arg->addressOf(NULL); + ea = ae->toElem(irs); + goto L1; + } + } + ea = arg->toElem(irs); + L1: + if (tybasic(ea->Ety) == TYstruct || tybasic(ea->Ety) == TYarray) + { + ea = el_una(OPstrpar, TYstruct, ea); + ea->ET = ea->E1->ET; + } + if (reverse) + ep = el_param(ep,ea); + else + ep = el_param(ea,ep); + } + } + + if (retmethod == RETstack) + { + if (!ehidden) + { // Don't have one, so create one + type *tc; + + Type *tret = tf->next; + if (tret->toBasetype()->ty == Tstruct || + tret->toBasetype()->ty == Tsarray) + tc = tret->toCtype(); + else + tc = type_fake(tret->totym()); + Symbol *stmp = symbol_genauto(tc); + ehidden = el_ptr(stmp); + } + if ((global.params.isLinux || + global.params.isOSX || + global.params.isFreeBSD || + global.params.isSolaris) && tf->linkage != LINKd) + ; // ehidden goes last on Linux/OSX C++ + else + { + if (ep) + { +#if 0 // BUG: implement + if (reverse && type_mangle(tfunc) == mTYman_cpp) + ep = el_param(ehidden,ep); + else +#endif + ep = el_param(ep,ehidden); + } + else + ep = ehidden; + ehidden = NULL; + } + } + + if (fd && fd->isMember2()) + { + Symbol *sfunc; + AggregateDeclaration *ad; + + ad = fd->isThis(); + if (ad) + { + ethis = ec; + if (ad->isStructDeclaration() && tybasic(ec->Ety) != TYnptr) + { + ethis = addressElem(ec, ectype); + } + } + else + { + // Evaluate ec for side effects + eside = ec; + } + sfunc = fd->toSymbol(); + + if (!fd->isVirtual() || + directcall || // BUG: fix + fd->isFinal() + /* Future optimization: || (whole program analysis && not overridden) + */ + ) + { + // make static call + ec = el_var(sfunc); + } + else + { + // make virtual call + elem *ev; + unsigned vindex; + + assert(ethis); + ev = el_same(ðis); + ev = el_una(OPind, TYnptr, ev); + vindex = fd->vtblIndex; + assert((int)vindex >= 0); + + // Build *(ev + vindex * 4) +if (I32) assert(tysize[TYnptr] == 4); + ec = el_bin(OPadd,TYnptr,ev,el_long(TYsize_t, vindex * tysize[TYnptr])); + ec = el_una(OPind,TYnptr,ec); + ec = el_una(OPind,tybasic(sfunc->Stype->Tty),ec); + } + } + else if (fd && fd->isNested()) + { + assert(!ethis); + ethis = getEthis(0, irs, fd); + } + + ep = el_param(ep, ethis); + if (ehidden) + ep = el_param(ep, ehidden); // if ehidden goes last + + tyret = tret->totym(); + + // Look for intrinsic functions + if (ec->Eoper == OPvar && (op = intrinsic_op(ec->EV.sp.Vsym->Sident)) != -1) + { + el_free(ec); + if (OTbinary(op)) + { + ep->Eoper = op; + ep->Ety = tyret; + e = ep; + if (op == OPscale) + { + elem *et = e->E1; + e->E1 = el_una(OPs32_d, TYdouble, e->E2); + e->E1 = el_una(OPd_ld, TYldouble, e->E1); + e->E2 = et; + } + else if (op == OPyl2x || op == OPyl2xp1) + { + elem *et = e->E1; + e->E1 = e->E2; + e->E2 = et; + } + } + else + e = el_una(op,tyret,ep); + } + else + { /* Do not do "no side effect" calls if a hidden parameter is passed, + * as the return value is stored through the hidden parameter, which + * is a side effect. + */ + //printf("1: fd = %p prity = %d, nothrow = %d, retmethod = %d, use-assert = %d\n", + // fd, (fd ? fd->isPure() : tf->purity), tf->isnothrow, retmethod, global.params.useAssert); + //printf("\tfd = %s, tf = %s\n", fd->toChars(), tf->toChars()); + /* assert() has 'implicit side effect' so disable this optimization. + */ + int ns = ((fd ? fd->isPure() : tf->purity) == PUREstrong && + tf->isnothrow && (retmethod != RETstack) && + !global.params.useAssert && global.params.optimize); + if (ep) + e = el_bin(ns ? OPcallns : OPcall, tyret, ec, ep); + else + e = el_una(ns ? OPucallns : OPucall, tyret, ec); + + if (tf->varargs) + e->Eflags |= EFLAGS_variadic; + } + + if (retmethod == RETstack) + { + e->Ety = TYnptr; + e = el_una(OPind, tyret, e); + } + +#if DMDV2 + if (tf->isref) + { + e->Ety = TYnptr; + e = el_una(OPind, tyret, e); + } +#endif + + if (tybasic(tyret) == TYstruct) + { + e->ET = tret->toCtype(); + } + e = el_combine(eside, e); + return e; +} + +/******************************************* + * Take address of an elem. + */ + +elem *addressElem(elem *e, Type *t) +{ + elem **pe; + + //printf("addressElem()\n"); + + for (pe = &e; (*pe)->Eoper == OPcomma; pe = &(*pe)->E2) + ; + if ((*pe)->Eoper != OPvar && (*pe)->Eoper != OPind) + { Symbol *stmp; + elem *eeq; + elem *e2 = *pe; + type *tx; + + // Convert to ((tmp=e2),tmp) + TY ty; + if (t && ((ty = t->toBasetype()->ty) == Tstruct || ty == Tsarray)) + tx = t->toCtype(); + else + tx = type_fake(e2->Ety); + stmp = symbol_genauto(tx); + eeq = el_bin(OPeq,e2->Ety,el_var(stmp),e2); + if (tybasic(e2->Ety) == TYstruct) + { + eeq->Eoper = OPstreq; + eeq->ET = e2->ET; + } + else if (tybasic(e2->Ety) == TYarray) + { + eeq->Eoper = OPstreq; + eeq->Ejty = eeq->Ety = TYstruct; + eeq->ET = t ? t->toCtype() : tx; + } + *pe = el_bin(OPcomma,e2->Ety,eeq,el_var(stmp)); + } + e = el_una(OPaddr,TYnptr,e); + return e; +} + +/***************************************** + * Convert array to a pointer to the data. + */ + +elem *array_toPtr(Type *t, elem *e) +{ + //printf("array_toPtr()\n"); + //elem_print(e); + t = t->toBasetype(); + switch (t->ty) + { + case Tpointer: + break; + + case Tarray: + case Tdelegate: + if (e->Eoper == OPcomma) + { + e->Ety = TYnptr; + e->E2 = array_toPtr(t, e->E2); + } + else if (e->Eoper == OPpair) + { + e->Eoper = OPcomma; + e->Ety = TYnptr; + } + else + { +#if 1 + e = el_una(OPmsw, TYnptr, e); +#else + e = el_una(OPaddr, TYnptr, e); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, 4)); + e = el_una(OPind, TYnptr, e); +#endif + } + break; + + case Tsarray: + e = el_una(OPaddr, TYnptr, e); + break; + + default: + t->print(); + assert(0); + } + return e; +} + +/***************************************** + * Convert array to a dynamic array. + */ + +elem *array_toDarray(Type *t, elem *e) +{ + unsigned dim; + elem *ef = NULL; + elem *ex; + + //printf("array_toDarray(t = %s)\n", t->toChars()); + //elem_print(e); + t = t->toBasetype(); + switch (t->ty) + { + case Tarray: + break; + + case Tsarray: + e = addressElem(e, t); + dim = ((TypeSArray *)t)->dim->toInteger(); + e = el_pair(TYdarray, el_long(TYsize_t, dim), e); + break; + + default: + L1: + switch (e->Eoper) + { + case OPconst: + { + size_t len = tysize[tybasic(e->Ety)]; + elem *es = el_calloc(); + es->Eoper = OPstring; + + // freed in el_free + es->EV.ss.Vstring = (char *)mem_malloc(len); + memcpy(es->EV.ss.Vstring, &e->EV, len); + + es->EV.ss.Vstrlen = len; + es->Ety = TYnptr; + e = es; + break; + } + + case OPvar: + e = el_una(OPaddr, TYnptr, e); + break; + + case OPcomma: + ef = el_combine(ef, e->E1); + ex = e; + e = e->E2; + ex->E1 = NULL; + ex->E2 = NULL; + el_free(ex); + goto L1; + + case OPind: + ex = e; + e = e->E1; + ex->E1 = NULL; + ex->E2 = NULL; + el_free(ex); + break; + + default: + { + // Copy expression to a variable and take the + // address of that variable. + Symbol *stmp; + tym_t ty = tybasic(e->Ety); + + if (ty == TYstruct) + { unsigned sz = type_size(e->ET); + if (sz <= 4) + ty = TYint; + else if (sz <= 8) + ty = TYllong; + } + e->Ety = ty; + stmp = symbol_genauto(type_fake(ty)); + e = el_bin(OPeq, e->Ety, el_var(stmp), e); + e = el_bin(OPcomma, TYnptr, e, el_una(OPaddr, TYnptr, el_var(stmp))); + break; + } + } + dim = 1; + e = el_pair(TYdarray, el_long(TYsize_t, dim), e); + break; + } + return el_combine(ef, e); +} + +/***************************************** + * Evaluate elem and convert to dynamic array. + */ + +elem *eval_Darray(IRState *irs, Expression *e) +{ + elem *ex; + + ex = e->toElem(irs); + return array_toDarray(e->type, ex); +} + +/************************************ + */ + +elem *sarray_toDarray(Loc loc, Type *tfrom, Type *tto, elem *e) +{ + //printf("sarray_toDarray()\n"); + //elem_print(e); + + dinteger_t dim = ((TypeSArray *)tfrom)->dim->toInteger(); + + if (tto) + { + unsigned fsize = tfrom->nextOf()->size(); + unsigned tsize = tto->nextOf()->size(); + + if ((dim * fsize) % tsize != 0) + { + error(loc, "cannot cast %s to %s since sizes don't line up", tfrom->toChars(), tto->toChars()); + } + dim = (dim * fsize) / tsize; + } + elem *elen = el_long(TYsize_t, dim); + e = addressElem(e, tfrom); + e = el_pair(TYdarray, elen, e); + return e; +} + +/******************************************** + * Determine if t is an array of structs that need a postblit. + */ + +StructDeclaration *needsPostblit(Type *t) +{ + t = t->toBasetype(); + while (t->ty == Tsarray) + t = t->nextOf()->toBasetype(); + if (t->ty == Tstruct) + { StructDeclaration *sd = ((TypeStruct *)t)->sym; + if (sd->postblit) + return sd; + } + return NULL; +} + +/******************************************* + * Set an array pointed to by eptr to evalue: + * eptr[0..edim] = evalue; + * Input: + * eptr where to write the data to + * evalue value to write + * edim number of times to write evalue to eptr[] + * tb type of evalue + */ + +elem *setArray(elem *eptr, elem *edim, Type *tb, elem *evalue, IRState *irs, int op) +{ int r; + elem *e; + unsigned sz = tb->size(); + + switch (tb->ty) + { + case Tfloat80: + case Timaginary80: + r = RTLSYM_MEMSET80; + break; + case Tcomplex80: + r = RTLSYM_MEMSET160; + break; + case Tcomplex64: + r = RTLSYM_MEMSET128; + break; + case Tfloat32: + case Timaginary32: + if (I32) + goto Ldefault; // legacy binary compatibility + r = RTLSYM_MEMSETFLOAT; + break; + case Tfloat64: + case Timaginary64: + if (I32) + goto Ldefault; // legacy binary compatibility + r = RTLSYM_MEMSETDOUBLE; + break; + + default: + Ldefault: + switch (sz) + { + case 1: r = RTLSYM_MEMSET8; break; + case 2: r = RTLSYM_MEMSET16; break; + case 4: r = RTLSYM_MEMSET32; break; + case 8: r = RTLSYM_MEMSET64; break; + case 16: r = RTLSYM_MEMSET128; break; + default: r = RTLSYM_MEMSETN; break; + } + + /* Determine if we need to do postblit + */ + if (op != TOKblit) + { + StructDeclaration *sd = needsPostblit(tb); + if (sd) + { /* Need to do postblit. + * void *_d_arraysetassign(void *p, void *value, int dim, TypeInfo ti); + */ + r = (op == TOKconstruct) ? RTLSYM_ARRAYSETCTOR : RTLSYM_ARRAYSETASSIGN; + evalue = el_una(OPaddr, TYnptr, evalue); + Expression *ti = tb->getTypeInfo(NULL); + elem *eti = ti->toElem(irs); + e = el_params(eti, edim, evalue, eptr, NULL); + e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e); + return e; + } + } + + if (r == RTLSYM_MEMSETN) + { + // void *_memsetn(void *p, void *value, int dim, int sizelem) + evalue = el_una(OPaddr, TYnptr, evalue); + elem *esz = el_long(TYsize_t, sz); + e = el_params(esz, edim, evalue, eptr, NULL); + e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e); + return e; + } + break; + } + if (sz > 1 && sz <= 8 && + evalue->Eoper == OPconst && el_allbits(evalue, 0)) + { + r = RTLSYM_MEMSET8; + edim = el_bin(OPmul, TYsize_t, edim, el_long(TYsize_t, sz)); + } + + if (tybasic(evalue->Ety) == TYstruct || tybasic(evalue->Ety) == TYarray) + { + evalue = el_una(OPstrpar, TYstruct, evalue); + evalue->ET = evalue->E1->ET; + } + + // Be careful about parameter side effect ordering + if (r == RTLSYM_MEMSET8) + { + e = el_param(edim, evalue); + e = el_bin(OPmemset,TYnptr,eptr,e); + } + else + { + e = el_params(edim, evalue, eptr, NULL); + e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e); + } + return e; +} + +/*************************************** + */ + +elem *Expression::toElem(IRState *irs) +{ + print(); + assert(0); + return NULL; +} + +/******************************************* + * Evaluate Expression, then call destructors on any temporaries in it. + */ + +elem *Expression::toElemDtor(IRState *irs) +{ + //printf("Expression::toElemDtor() %s\n", toChars()); + size_t starti = irs->varsInScope ? irs->varsInScope->dim : 0; + elem *er = toElem(irs); + size_t endi = irs->varsInScope ? irs->varsInScope->dim : 0; + + // Add destructors + er = appendDtors(irs, er, starti, endi); + return er; +} + +/************************************ + */ +#if DMDV2 +elem *SymbolExp::toElem(IRState *irs) +{ Symbol *s; + elem *e; + tym_t tym; + Type *tb = (op == TOKsymoff) ? var->type->toBasetype() : type->toBasetype(); + int offset = (op == TOKsymoff) ? ((SymOffExp*)this)->offset : 0; + FuncDeclaration *fd; + VarDeclaration *v = var->isVarDeclaration(); + + //printf("SymbolExp::toElem('%s') %p\n", toChars(), this); + //printf("\tparent = '%s'\n", var->parent ? var->parent->toChars() : "null"); + if (op == TOKvar && var->needThis()) + { + error("need 'this' to access member %s", toChars()); + return el_long(TYsize_t, 0); + } + + /* The magic variable __ctfe is always false at runtime + */ + if (op == TOKvar && v && v->ident == Id::ctfe) + return el_long(type->totym(), 0); + + s = var->toSymbol(); + fd = NULL; + if (var->toParent2()) + fd = var->toParent2()->isFuncDeclaration(); + + int nrvo = 0; + if (fd && fd->nrvo_can && fd->nrvo_var == var) + { + s = fd->shidden; + nrvo = 1; + } + + if (s->Sclass == SCauto || s->Sclass == SCparameter) + { + if (fd && fd != irs->getFunc()) + { // 'var' is a variable in an enclosing function. + elem *ethis; + int soffset; + + ethis = getEthis(loc, irs, fd); + ethis = el_una(OPaddr, TYnptr, ethis); + + if (v && v->offset) + soffset = v->offset; + else + { + soffset = 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) + { + soffset -= fd->vthis->toSymbol()->Soffset; + } + //printf("\tSoffset = x%x, sthis->Soffset = x%x\n", s->Soffset, irs->sthis->Soffset); + } + + if (!nrvo) + soffset += offset; + + e = el_bin(OPadd, TYnptr, ethis, el_long(TYnptr, soffset)); + if (op == TOKvar) + e = el_una(OPind, TYnptr, e); + if (ISREF(var, tb)) + e = el_una(OPind, s->ty(), e); + else if (op == TOKsymoff && 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 + */ + if (v && v->offset) + { assert(irs->sclosure); + e = el_var(irs->sclosure); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, v->offset)); + if (op == TOKvar) + { e = el_una(OPind, type->totym(), e); + if (tybasic(e->Ety) == TYstruct) + e->ET = type->toCtype(); + el_setLoc(e, loc); + } + if (ISREF(var, tb)) + { e->Ety = TYnptr; + e = el_una(OPind, s->ty(), e); + } + else if (op == TOKsymoff && nrvo) + { e = el_una(OPind, TYnptr, e); + e = el_bin(OPadd, e->Ety, e, el_long(TYsize_t, offset)); + } + else if (op == TOKsymoff) + { + e = el_bin(OPadd, e->Ety, e, el_long(TYsize_t, offset)); + } + goto L1; + } + + if (s->Sclass == SCauto && s->Ssymnum == -1) + { + //printf("\tadding symbol %s\n", s->Sident); + symbol_add(s); + } + + if (var->isImportedSymbol()) + { + assert(op == TOKvar); + e = el_var(var->toImport()); + e = el_una(OPind,s->ty(),e); + } + else if (ISREF(var, tb)) + { // Static arrays are really passed as pointers to the array + // Out parameters are really references + e = el_var(s); + e->Ety = TYnptr; + if (op == TOKvar) + e = el_una(OPind, s->ty(), e); + else if (offset) + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, offset)); + } + else if (op == TOKvar) + 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 (op == TOKvar) + { + if (nrvo) + { + e->Ety = TYnptr; + e = el_una(OPind, 0, e); + } + if (tb->ty == Tfunction) + { + tym = s->Stype->Tty; + } + else + tym = type->totym(); + e->Ejty = e->Ety = tym; + if (tybasic(tym) == TYstruct) + { + e->ET = type->toCtype(); + } + else if (tybasic(tym) == TYarray) + { + e->Ejty = e->Ety = TYstruct; + e->ET = type->toCtype(); + } + } + el_setLoc(e,loc); + return e; +} +#endif + +#if DMDV1 +elem *VarExp::toElem(IRState *irs) +{ Symbol *s; + elem *e; + tym_t tym; + Type *tb = type->toBasetype(); + FuncDeclaration *fd; + VarDeclaration *v = var->isVarDeclaration(); + + //printf("VarExp::toElem('%s') %p\n", toChars(), this); + //printf("\tparent = '%s'\n", var->parent ? var->parent->toChars() : "null"); + if (var->needThis()) + { + error("need 'this' to access member %s", toChars()); + return el_long(TYsize_t, 0); + } + s = var->toSymbol(); + fd = NULL; + if (var->toParent2()) + fd = var->toParent2()->isFuncDeclaration(); + + int nrvo = 0; + if (fd && fd->nrvo_can && fd->nrvo_var == var) + { + s = fd->shidden; + nrvo = 1; + } + + if (s->Sclass == SCauto || s->Sclass == SCparameter) + { + if (fd && fd != irs->getFunc()) + { // 'var' is a variable in an enclosing function. + elem *ethis; + int soffset; + + ethis = getEthis(loc, irs, fd); + ethis = el_una(OPaddr, TYnptr, ethis); + + if (v && v->offset) + soffset = v->offset; + else + { + soffset = 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) + { + soffset -= fd->vthis->toSymbol()->Soffset; + } + //printf("\tSoffset = x%x, sthis->Soffset = x%x\n", s->Soffset, irs->sthis->Soffset); + } + + ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYnptr, soffset)); + e = el_una(OPind, 0, ethis); + if (ISREF(var, tb)) + goto L2; + goto L1; + } + } + + /* If var is a member of a closure + */ + if (v && v->offset) + { assert(irs->sclosure); + e = el_var(irs->sclosure); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, v->offset)); + e = el_una(OPind, type->totym(), e); + if (tybasic(e->Ety) == TYstruct) + e->ET = type->toCtype(); + el_setLoc(e, loc); + + if (ISREF(var, tb)) + goto L2; + goto L1; + } + + if (s->Sclass == SCauto && s->Ssymnum == -1) + { + //printf("\tadding symbol\n"); + symbol_add(s); + } + + if (var->isImportedSymbol()) + { + e = el_var(var->toImport()); + e = el_una(OPind,s->ty(),e); + } + else if (ISREF(var, tb)) + { // Static arrays are really passed as pointers to the array + // Out parameters are really references + e = el_var(s); +L2: + e->Ety = TYnptr; + e = el_una(OPind, s->ty(), e); + } + else + e = el_var(s); +L1: + if (nrvo) + { + e->Ety = TYnptr; + e = el_una(OPind, 0, e); + } + if (tb->ty == Tfunction) + { + tym = s->Stype->Tty; + } + else + tym = type->totym(); + e->Ejty = e->Ety = tym; + if (tybasic(tym) == TYstruct) + { + e->ET = type->toCtype(); + } + else if (tybasic(tym) == TYarray) + { + e->Ejty = e->Ety = TYstruct; + e->ET = type->toCtype(); + } + el_setLoc(e,loc); + return e; +} +#endif + +#if 0 +elem *SymOffExp::toElem(IRState *irs) +{ Symbol *s; + elem *e; + Type *tb = var->type->toBasetype(); + VarDeclaration *v = var->isVarDeclaration(); + FuncDeclaration *fd = NULL; + if (var->toParent2()) + fd = var->toParent2()->isFuncDeclaration(); + + //printf("SymOffExp::toElem(): %s\n", toChars()); + s = var->toSymbol(); + + int nrvo = 0; + if (fd && fd->nrvo_can && fd->nrvo_var == var) + { s = fd->shidden; + nrvo = 1; + } + + if (s->Sclass == SCauto && s->Ssymnum == -1) + symbol_add(s); + assert(!var->isImportedSymbol()); + + // This code closely parallels that in VarExp::toElem() + if (s->Sclass == SCauto || s->Sclass == SCparameter) + { + if (fd && fd != irs->getFunc()) + { // 'var' is a variable in an enclosing function. + elem *ethis; + int soffset; + + ethis = getEthis(loc, irs, fd); + ethis = el_una(OPaddr, TYnptr, ethis); + + if (v && v->offset) + soffset = v->offset; + else + { + soffset = 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) + { + soffset -= fd->vthis->toSymbol()->Soffset; + } + //printf("\tSoffset = x%x, sthis->Soffset = x%x\n", s->Soffset, irs->sthis->Soffset); + } + + if (!nrvo) + soffset += offset; + e = el_bin(OPadd, TYnptr, ethis, el_long(TYnptr, soffset)); + if (ISREF(var, tb)) + e = el_una(OPind, s->ty(), e); + else if (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 + */ + if (v && v->offset) + { assert(irs->sclosure); + e = el_var(irs->sclosure); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, v->offset)); + if (ISREF(var, tb)) + e = el_una(OPind, s->ty(), e); + else if (nrvo) + { e = el_una(OPind, TYnptr, e); + e = el_bin(OPadd, e->Ety, e, el_long(TYsize_t, offset)); + } + goto L1; + } + + if (ISREF(var, tb)) + { // Static arrays are really passed as pointers to the array + // Out parameters are really references + e = el_var(s); + e->Ety = TYnptr; + if (offset) + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, offset)); + } + else + { e = nrvo ? el_var(s) : el_ptr(s); + e = el_bin(OPadd, e->Ety, e, el_long(TYsize_t, offset)); + } + +L1: + el_setLoc(e,loc); + return e; +} +#endif + +/************************************** + */ + +elem *FuncExp::toElem(IRState *irs) +{ + elem *e; + Symbol *s; + + //printf("FuncExp::toElem() %s\n", toChars()); + if (fd->tok == TOKreserved && type->ty == Tpointer && fd->vthis) + { fd->tok = TOKfunction; + fd->vthis = NULL; + } + s = fd->toSymbol(); + e = el_ptr(s); + if (fd->isNested()) + { + elem *ethis = getEthis(loc, irs, fd); + e = el_pair(TYdelegate, ethis, e); + } + + irs->deferToObj->push(fd); + el_setLoc(e,loc); + return e; +} + +/************************************** + * Mirrors logic in Dsymbol_canThrow(). + */ + +elem *Dsymbol_toElem(Dsymbol *s, IRState *irs) +{ + elem *e = NULL; + Symbol *sp; + AttribDeclaration *ad; + VarDeclaration *vd; + ClassDeclaration *cd; + StructDeclaration *sd; + FuncDeclaration *fd; + TemplateMixin *tm; + TupleDeclaration *td; + TypedefDeclaration *tyd; + + //printf("Dsymbol_toElem() %s\n", s->toChars()); + ad = s->isAttribDeclaration(); + if (ad) + { + Dsymbols *decl = ad->include(NULL, NULL); + if (decl && decl->dim) + { + for (size_t i = 0; i < decl->dim; i++) + { + s = decl->tdata()[i]; + e = el_combine(e, Dsymbol_toElem(s, irs)); + } + } + } + else if ((vd = s->isVarDeclaration()) != NULL) + { + s = s->toAlias(); + if (s != vd) + return Dsymbol_toElem(s, irs); + if (vd->storage_class & STCmanifest) + return NULL; + else if (vd->isStatic() || vd->storage_class & (STCextern | STCtls | STCgshared)) + vd->toObjFile(0); + else + { + sp = s->toSymbol(); + symbol_add(sp); + //printf("\tadding symbol '%s'\n", sp->Sident); + if (vd->init) + { + ExpInitializer *ie; + + ie = vd->init->isExpInitializer(); + if (ie) + e = ie->exp->toElem(irs); + } + + /* Mark the point of construction of a variable that needs to be destructed. + */ + if (vd->edtor && !vd->noscope) + { + e = el_dctor(e, vd); + + // Put vd on list of things needing destruction + if (!irs->varsInScope) + irs->varsInScope = new VarDeclarations(); + irs->varsInScope->push(vd); + } + } + } + else if ((cd = s->isClassDeclaration()) != NULL) + { + irs->deferToObj->push(s); + } + else if ((sd = s->isStructDeclaration()) != NULL) + { + irs->deferToObj->push(sd); + } + else if ((fd = s->isFuncDeclaration()) != NULL) + { + //printf("function %s\n", fd->toChars()); + irs->deferToObj->push(fd); + } + else if ((tm = s->isTemplateMixin()) != NULL) + { + //printf("%s\n", tm->toChars()); + if (tm->members) + { + for (size_t i = 0; i < tm->members->dim; i++) + { + Dsymbol *sm = tm->members->tdata()[i]; + e = el_combine(e, Dsymbol_toElem(sm, irs)); + } + } + } + else if ((td = s->isTupleDeclaration()) != NULL) + { + for (size_t i = 0; i < td->objects->dim; i++) + { Object *o = td->objects->tdata()[i]; + if (o->dyncast() == DYNCAST_EXPRESSION) + { Expression *eo = (Expression *)o; + if (eo->op == TOKdsymbol) + { DsymbolExp *se = (DsymbolExp *)eo; + e = el_combine(e, Dsymbol_toElem(se->s, irs)); + } + } + } + } + else if ((tyd = s->isTypedefDeclaration()) != NULL) + { + irs->deferToObj->push(tyd); + } + return e; +} + +elem *DeclarationExp::toElem(IRState *irs) +{ + //printf("DeclarationExp::toElem() %s\n", toChars()); + elem *e = Dsymbol_toElem(declaration, irs); + return e; +} + +/*************************************** + */ + +elem *ThisExp::toElem(IRState *irs) +{ elem *ethis; + FuncDeclaration *fd; + + //printf("ThisExp::toElem()\n"); + assert(irs->sthis); + + if (var) + { + assert(var->parent); + fd = var->toParent2()->isFuncDeclaration(); + assert(fd); + ethis = getEthis(loc, irs, fd); + } + else + ethis = el_var(irs->sthis); + +#if STRUCTTHISREF + if (type->ty == Tstruct) + { ethis = el_una(OPind, TYstruct, ethis); + ethis->ET = type->toCtype(); + } +#endif + el_setLoc(ethis,loc); + return ethis; +} + +/*************************************** + */ + +elem *IntegerExp::toElem(IRState *irs) +{ + elem *e = el_long(type->totym(), value); + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *RealExp::toElem(IRState *irs) +{ union eve c; + tym_t ty; + + //printf("RealExp::toElem(%p) %s\n", this, toChars()); + memset(&c, 0, sizeof(c)); + ty = type->toBasetype()->totym(); + switch (tybasic(ty)) + { + case TYfloat: + case TYifloat: + /* This assignment involves a conversion, which + * unfortunately also converts SNAN to QNAN. + */ + c.Vfloat = value; + if (Port::isSignallingNan(value)) + // Put SNAN back + c.Vuns &= 0xFFBFFFFFL; + break; + + case TYdouble: + case TYidouble: + /* This assignment involves a conversion, which + * unfortunately also converts SNAN to QNAN. + */ + c.Vdouble = value; + if (Port::isSignallingNan(value)) + // Put SNAN back + c.Vullong &= 0xFFF7FFFFFFFFFFFFULL; + break; + + case TYldouble: + case TYildouble: + c.Vldouble = value; + break; + + default: + print(); + type->print(); + type->toBasetype()->print(); + printf("ty = %d, tym = %x\n", type->ty, ty); + assert(0); + } + return el_const(ty, &c); +} + + +/*************************************** + */ + +elem *ComplexExp::toElem(IRState *irs) +{ union eve c; + tym_t ty; + real_t re; + real_t im; + + //printf("ComplexExp::toElem(%p) %s\n", this, toChars()); + + memset(&c, 0, sizeof(c)); + re = creall(value); + im = cimagl(value); + + ty = type->totym(); + switch (tybasic(ty)) + { + case TYcfloat: + c.Vcfloat.re = (float) re; + if (Port::isSignallingNan(re)) + { union { float f; unsigned i; } u; + u.f = c.Vcfloat.re; + u.i &= 0xFFBFFFFFL; + c.Vcfloat.re = u.f; + } + c.Vcfloat.im = (float) im; + if (Port::isSignallingNan(im)) + { union { float f; unsigned i; } u; + u.f = c.Vcfloat.im; + u.i &= 0xFFBFFFFFL; + c.Vcfloat.im = u.f; + } + break; + + case TYcdouble: + c.Vcdouble.re = (double) re; + if (Port::isSignallingNan(re)) + { union { double d; unsigned long long i; } u; + u.d = c.Vcdouble.re; + u.i &= 0xFFF7FFFFFFFFFFFFULL; + c.Vcdouble.re = u.d; + } + c.Vcdouble.im = (double) im; + if (Port::isSignallingNan(re)) + { union { double d; unsigned long long i; } u; + u.d = c.Vcdouble.im; + u.i &= 0xFFF7FFFFFFFFFFFFULL; + c.Vcdouble.im = u.d; + } + break; + + case TYcldouble: +#if 1 + c.Vcldouble.re = re; + c.Vcldouble.im = im; +#else +{unsigned short *p = (unsigned short *)&c.Vcldouble; +for (int i = 0; i < (LNGDBLSIZE*2)/2; i++) printf("%04x ", p[i]); +printf("\n");} + c.Vcldouble.im = im; +{unsigned short *p = (unsigned short *)&c.Vcldouble; +for (int i = 0; i < (LNGDBLSIZE*2)/2; i++) printf("%04x ", p[i]); +printf("\n");} + c.Vcldouble.re = re; +{unsigned short *p = (unsigned short *)&c.Vcldouble; +for (int i = 0; i < (LNGDBLSIZE*2)/2; i++) printf("%04x ", p[i]); +printf("\n");} +#endif + break; + + default: + assert(0); + } + return el_const(ty, &c); +} + +/*************************************** + */ + +elem *NullExp::toElem(IRState *irs) +{ + return el_long(type->totym(), 0); +} + +/*************************************** + */ + +struct StringTab +{ + Module *m; // module we're generating code for + Symbol *si; + void *string; + size_t sz; + size_t len; +}; + +#define STSIZE 16 +StringTab stringTab[STSIZE]; +size_t stidx; + +static Symbol *assertexp_sfilename = NULL; +static const char *assertexp_name = NULL; +static Module *assertexp_mn = NULL; + +void clearStringTab() +{ + //printf("clearStringTab()\n"); + memset(stringTab, 0, sizeof(stringTab)); + stidx = 0; + + assertexp_sfilename = NULL; + assertexp_name = NULL; + assertexp_mn = NULL; +} + +elem *StringExp::toElem(IRState *irs) +{ + elem *e; + Type *tb= type->toBasetype(); + + +#if 0 + printf("StringExp::toElem() %s, type = %s\n", toChars(), type->toChars()); +#endif + + if (tb->ty == Tarray) + { + Symbol *si; + dt_t *dt; + StringTab *st; + +#if 0 + printf("irs->m = %p\n", irs->m); + printf(" m = %s\n", irs->m->toChars()); + printf(" len = %d\n", len); + printf(" sz = %d\n", sz); +#endif + for (size_t i = 0; i < STSIZE; i++) + { + st = &stringTab[(stidx + i) % STSIZE]; + //if (!st->m) continue; + //printf(" st.m = %s\n", st->m->toChars()); + //printf(" st.len = %d\n", st->len); + //printf(" st.sz = %d\n", st->sz); + if (st->m == irs->m && + st->si && + st->len == len && + st->sz == sz && + memcmp(st->string, string, sz * len) == 0) + { + //printf("use cached value\n"); + si = st->si; // use cached value + goto L1; + } + } + + stidx = (stidx + 1) % STSIZE; + st = &stringTab[stidx]; + + dt = NULL; + toDt(&dt); + + si = symbol_generate(SCstatic,type_fake(TYdarray)); + si->Sdt = dt; + si->Sfl = FLdata; +#if ELFOBJ // Burton + si->Sseg = CDATA; +#endif +#if MACHOBJ + si->Sseg = DATA; +#endif + outdata(si); + + st->m = irs->m; + st->si = si; + st->string = string; + st->len = len; + st->sz = sz; + L1: + e = el_var(si); + } + else if (tb->ty == Tsarray) + { + dt_t *dt = NULL; + + toDt(&dt); + dtnzeros(&dt, sz); // leave terminating 0 + + ::type *t = type_allocn(TYarray, tschar); + t->Tdim = sz * len; + Symbol *si = symbol_generate(SCstatic, t); + si->Sdt = dt; + si->Sfl = FLdata; + +#if ELFOBJ || MACHOBJ // Burton + si->Sseg = CDATA; +#endif + outdata(si); + + e = el_var(si); + e->ET = t; + t->Tcount++; + } + else if (tb->ty == Tpointer) + { + e = el_calloc(); + e->Eoper = OPstring; + // freed in el_free + e->EV.ss.Vstring = (char *)mem_malloc((len + 1) * sz); + memcpy(e->EV.ss.Vstring, string, (len + 1) * sz); + e->EV.ss.Vstrlen = (len + 1) * sz; + e->Ety = TYnptr; + } + else + { + printf("type is %s\n", type->toChars()); + assert(0); + } + el_setLoc(e,loc); + return e; +} + +elem *NewExp::toElem(IRState *irs) +{ elem *e; + Type *t; + Type *ectype; + + //printf("NewExp::toElem() %s\n", toChars()); + t = type->toBasetype(); + //printf("\ttype = %s\n", t->toChars()); + //if (member) + //printf("\tmember = %s\n", member->toChars()); + if (t->ty == Tclass) + { + Symbol *csym; + + t = newtype->toBasetype(); + assert(t->ty == Tclass); + TypeClass *tclass = (TypeClass *)(t); + ClassDeclaration *cd = tclass->sym; + + /* Things to do: + * 1) ex: call allocator + * 2) ey: set vthis for nested classes + * 3) ez: call constructor + */ + + elem *ex = NULL; + elem *ey = NULL; + elem *ez = NULL; + + if (allocator || onstack) + { elem *ei; + Symbol *si; + + if (onstack) + { + /* Create an instance of the class on the stack, + * and call it stmp. + * Set ex to be the &stmp. + */ + Symbol *s = symbol_calloc(tclass->sym->toChars()); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= 0; + s->Sstruct->Salignsize = tclass->sym->alignsize; + s->Sstruct->Sstructalign = tclass->sym->structalign; + s->Sstruct->Sstructsize = tclass->sym->structsize; + + ::type *tc = type_alloc(TYstruct); + tc->Ttag = (Classsym *)s; // structure tag name + tc->Tcount++; + s->Stype = tc; + + Symbol *stmp = symbol_genauto(tc); + ex = el_ptr(stmp); + } + else + { + ex = el_var(allocator->toSymbol()); + ex = callfunc(loc, irs, 1, type, ex, allocator->type, + allocator, allocator->type, NULL, newargs); + } + + si = tclass->sym->toInitializer(); + ei = el_var(si); + + if (cd->isNested()) + { + ey = el_same(&ex); + ez = el_copytree(ey); + } + else if (member) + ez = el_same(&ex); + + ex = el_una(OPind, TYstruct, ex); + ex = el_bin(OPstreq, TYnptr, ex, ei); + ex->ET = tclass->toCtype()->Tnext; + ex = el_una(OPaddr, TYnptr, ex); + ectype = tclass; + } + else + { + csym = cd->toSymbol(); + ex = el_bin(OPcall,TYnptr,el_var(rtlsym[RTLSYM_NEWCLASS]),el_ptr(csym)); + ectype = NULL; + + if (cd->isNested()) + { + ey = el_same(&ex); + ez = el_copytree(ey); + } + else if (member) + ez = el_same(&ex); +//elem_print(ex); +//elem_print(ey); +//elem_print(ez); + } + + if (thisexp) + { ClassDeclaration *cdthis = thisexp->type->isClassHandle(); + assert(cdthis); + //printf("cd = %s\n", cd->toChars()); + //printf("cdthis = %s\n", cdthis->toChars()); + assert(cd->isNested()); + int offset = 0; + Dsymbol *cdp = cd->toParent2(); // class we're nested in + elem *ethis; + +//printf("member = %p\n", member); +//printf("cdp = %s\n", cdp->toChars()); +//printf("cdthis = %s\n", cdthis->toChars()); + if (cdp != cdthis) + { int i = cdp->isClassDeclaration()->isBaseOf(cdthis, &offset); + assert(i); + } + ethis = thisexp->toElem(irs); + if (offset) + ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYsize_t, offset)); + + if (!cd->vthis) + { + error("forward reference to %s", cd->toChars()); + } + else + { + ey = el_bin(OPadd, TYnptr, ey, el_long(TYsize_t, cd->vthis->offset)); + ey = el_una(OPind, TYnptr, ey); + ey = el_bin(OPeq, TYnptr, ey, ethis); + } +//printf("ex: "); elem_print(ex); +//printf("ey: "); elem_print(ey); +//printf("ez: "); elem_print(ez); + } + else if (cd->isNested()) + { /* Initialize cd->vthis: + * *(ey + cd.vthis.offset) = this; + */ + ey = setEthis(loc, irs, ey, cd); + } + + if (member) + // Call constructor + ez = callfunc(loc, irs, 1, type, ez, ectype, member, member->type, NULL, arguments); + + e = el_combine(ex, ey); + e = el_combine(e, ez); + } +#if DMDV2 + else if (t->ty == Tpointer && t->nextOf()->toBasetype()->ty == Tstruct) + { + t = newtype->toBasetype(); + assert(t->ty == Tstruct); + TypeStruct *tclass = (TypeStruct *)(t); + StructDeclaration *cd = tclass->sym; + + /* Things to do: + * 1) ex: call allocator + * 2) ey: set vthis for nested classes + * 3) ez: call constructor + */ + + elem *ex = NULL; + elem *ey = NULL; + elem *ez = NULL; + + if (allocator) + { elem *ei; + Symbol *si; + + ex = el_var(allocator->toSymbol()); + ex = callfunc(loc, irs, 1, type, ex, allocator->type, + allocator, allocator->type, NULL, newargs); + + si = tclass->sym->toInitializer(); + ei = el_var(si); + + if (cd->isNested()) + { + ey = el_same(&ex); + ez = el_copytree(ey); + } + else if (member) + ez = el_same(&ex); + + if (!member) + { /* Statically intialize with default initializer + */ + ex = el_una(OPind, TYstruct, ex); + ex = el_bin(OPstreq, TYnptr, ex, ei); + ex->ET = tclass->toCtype(); + ex = el_una(OPaddr, TYnptr, ex); + } + ectype = tclass; + } + else + { + d_uns64 elemsize = cd->size(loc); + + // call _d_newarrayT(ti, 1) + e = el_long(TYsize_t, 1); + e = el_param(e, type->getTypeInfo(NULL)->toElem(irs)); + + int rtl = t->isZeroInit() ? RTLSYM_NEWARRAYT : RTLSYM_NEWARRAYIT; + e = el_bin(OPcall,TYdarray,el_var(rtlsym[rtl]),e); + + // The new functions return an array, so convert to a pointer + // ex -> (unsigned)(e >> 32) + e = el_bin(OPshr, TYdarray, e, el_long(TYint, PTRSIZE * 8)); + ex = el_una(OP64_32, TYnptr, e); + + ectype = NULL; + + if (cd->isNested()) + { + ey = el_same(&ex); + ez = el_copytree(ey); + } + else if (member) + ez = el_same(&ex); +//elem_print(ex); +//elem_print(ey); +//elem_print(ez); + } + + if (cd->isNested()) + { /* Initialize cd->vthis: + * *(ey + cd.vthis.offset) = this; + */ + ey = setEthis(loc, irs, ey, cd); + } + + if (member) + { // Call constructor + ez = callfunc(loc, irs, 1, type, ez, ectype, member, member->type, NULL, arguments); +#if STRUCTTHISREF + /* Structs return a ref, which gets automatically dereferenced. + * But we want a pointer to the instance. + */ + ez = el_una(OPaddr, TYnptr, ez); +#endif + } + + e = el_combine(ex, ey); + e = el_combine(e, ez); + } +#endif + else if (t->ty == Tarray) + { + TypeDArray *tda = (TypeDArray *)(t); + + assert(arguments && arguments->dim >= 1); + if (arguments->dim == 1) + { // Single dimension array allocations + Expression *arg = arguments->tdata()[0]; // gives array length + e = arg->toElem(irs); + d_uns64 elemsize = tda->next->size(); + + // call _d_newT(ti, arg) + e = el_param(e, type->getTypeInfo(NULL)->toElem(irs)); + int rtl = tda->next->isZeroInit() ? RTLSYM_NEWARRAYT : RTLSYM_NEWARRAYIT; + e = el_bin(OPcall,TYdarray,el_var(rtlsym[rtl]),e); + } + else + { // Multidimensional array allocations + e = el_long(TYsize_t, arguments->dim); + for (size_t i = 0; i < arguments->dim; i++) + { + Expression *arg = arguments->tdata()[i]; // gives array length + e = el_param(arg->toElem(irs), e); + assert(t->ty == Tarray); + t = t->nextOf(); + assert(t); + } + + e = el_param(e, type->getTypeInfo(NULL)->toElem(irs)); + + int rtl = t->isZeroInit() ? RTLSYM_NEWARRAYMT : RTLSYM_NEWARRAYMIT; + e = el_bin(OPcall,TYdarray,el_var(rtlsym[rtl]),e); + e->Eflags |= EFLAGS_variadic; + } + } + else if (t->ty == Tpointer) + { + TypePointer *tp = (TypePointer *)t; + d_uns64 elemsize = tp->next->size(); + Expression *di = tp->next->defaultInit(); + d_uns64 disize = di->type->size(); + + // call _d_newarrayT(ti, 1) + e = el_long(TYsize_t, 1); + e = el_param(e, type->getTypeInfo(NULL)->toElem(irs)); + + int rtl = tp->next->isZeroInit() ? RTLSYM_NEWARRAYT : RTLSYM_NEWARRAYIT; + e = el_bin(OPcall,TYdarray,el_var(rtlsym[rtl]),e); + + // The new functions return an array, so convert to a pointer + // e -> (unsigned)(e >> 32) + e = el_bin(OPshr, TYdarray, e, el_long(TYsize_t, PTRSIZE * 8)); + e = el_una(I64 ? OP128_64 : OP64_32, t->totym(), e); + } + else + { + assert(0); + } + + el_setLoc(e,loc); + return e; +} + +//////////////////////////// Unary /////////////////////////////// + +/*************************************** + */ + +elem *NegExp::toElem(IRState *irs) +{ + elem *e = e1->toElem(irs); + Type *tb1 = e1->type->toBasetype(); + switch (tb1->ty) + { + case Tarray: + case Tsarray: + error("Array operation %s not implemented", toChars()); + e = el_long(type->totym(), 0); // error recovery + break; + + case Tvector: + { // rewrite (-e) as (0-e) + elem *ez = el_calloc(); + ez->Eoper = OPconst; + ez->Ety = e->Ety; + ez->EV.Vcent.lsw = 0; + ez->EV.Vcent.msw = 0; + e = el_bin(OPmin, type->totym(), ez, e); + break; + } + + default: + e = el_una(OPneg, type->totym(), e); + break; + } + + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *ComExp::toElem(IRState *irs) +{ + elem *e1 = this->e1->toElem(irs); + Type *tb1 = this->e1->type->toBasetype(); + tym_t ty = type->totym(); + + elem *e; + switch (tb1->ty) + { + case Tbool: + e = el_bin(OPxor, ty, e1, el_long(ty, 1)); + break; + + case Tvector: + { // rewrite (~e) as (e^~0) + elem *ec = el_calloc(); + ec->Eoper = OPconst; + ec->Ety = e1->Ety; + ec->EV.Vcent.lsw = ~0LL; + ec->EV.Vcent.msw = ~0LL; + e = el_bin(OPxor, ty, e1, ec); + break; + } + + default: + e = el_una(OPcom,ty,e1); + break; + } + + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *NotExp::toElem(IRState *irs) +{ + elem *e = el_una(OPnot, type->totym(), e1->toElem(irs)); + el_setLoc(e,loc); + return e; +} + + +/*************************************** + */ + +elem *HaltExp::toElem(IRState *irs) +{ elem *e; + + e = el_calloc(); + e->Ety = TYvoid; + e->Eoper = OPhalt; + el_setLoc(e,loc); + return e; +} + +/******************************************** + */ + +elem *AssertExp::toElem(IRState *irs) +{ elem *e; + elem *ea; + Type *t1 = e1->type->toBasetype(); + + //printf("AssertExp::toElem() %s\n", toChars()); + if (global.params.useAssert) + { + e = e1->toElem(irs); + symbol *ts = NULL; + elem *einv = NULL; + + InvariantDeclaration *inv = (InvariantDeclaration *)(void *)1; + + // If e1 is a class object, call the class invariant on it + if (global.params.useInvariants && t1->ty == Tclass && + !((TypeClass *)t1)->sym->isInterfaceDeclaration()) + { + ts = symbol_genauto(t1->toCtype()); +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_SOLARIS + einv = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM__DINVARIANT]), el_var(ts)); +#else + einv = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DINVARIANT]), el_var(ts)); +#endif + } + // If e1 is a struct object, call the struct invariant on it + else if (global.params.useInvariants && + t1->ty == Tpointer && + t1->nextOf()->ty == Tstruct && + (inv = ((TypeStruct *)t1->nextOf())->sym->inv) != NULL) + { + ts = symbol_genauto(t1->toCtype()); + einv = callfunc(loc, irs, 1, inv->type->nextOf(), el_var(ts), e1->type, inv, inv->type, NULL, NULL); + } + + // Construct: (e1 || ModuleAssert(line)) + Module *m = irs->blx->module; + char *mname = m->srcfile->toChars(); + + //printf("filename = '%s'\n", loc.filename); + //printf("module = '%s'\n", m->srcfile->toChars()); + + /* Determine if we are in a unittest + */ + FuncDeclaration *fd = irs->getFunc(); + UnitTestDeclaration *ud = fd ? fd->isUnitTestDeclaration() : NULL; + + /* If the source file name has changed, probably due + * to a #line directive. + */ + if (loc.filename && (msg || strcmp(loc.filename, mname) != 0)) + { elem *efilename; + + /* Cache values. + */ + //static Symbol *assertexp_sfilename = NULL; + //static char *assertexp_name = NULL; + //static Module *assertexp_mn = NULL; + + if (!assertexp_sfilename || strcmp(loc.filename, assertexp_name) != 0 || assertexp_mn != m) + { + dt_t *dt = NULL; + const char *id; + int len; + + id = loc.filename; + len = strlen(id); + dtsize_t(&dt, len); + dtabytes(&dt,TYnptr, 0, len + 1, id); + + assertexp_sfilename = symbol_generate(SCstatic,type_fake(TYdarray)); + assertexp_sfilename->Sdt = dt; + assertexp_sfilename->Sfl = FLdata; +#if ELFOBJ + assertexp_sfilename->Sseg = CDATA; +#endif +#if MACHOBJ + assertexp_sfilename->Sseg = DATA; +#endif + outdata(assertexp_sfilename); + + assertexp_mn = m; + assertexp_name = id; + } + + efilename = el_var(assertexp_sfilename); + + if (msg) + { elem *emsg = msg->toElem(irs); + ea = el_var(rtlsym[ud ? RTLSYM_DUNITTEST_MSG : RTLSYM_DASSERT_MSG]); + ea = el_bin(OPcall, TYvoid, ea, el_params(el_long(TYint, loc.linnum), efilename, emsg, NULL)); + } + else + { + ea = el_var(rtlsym[ud ? RTLSYM_DUNITTEST : RTLSYM_DASSERT]); + ea = el_bin(OPcall, TYvoid, ea, el_param(el_long(TYint, loc.linnum), efilename)); + } + } + else + { + Symbol *sassert = ud ? m->toModuleUnittest() : m->toModuleAssert(); + ea = el_bin(OPcall,TYvoid,el_var(sassert), + el_long(TYint, loc.linnum)); + } + if (einv) + { // tmp = e, e || assert, e->inv + elem *eassign = el_bin(OPeq, e->Ety, el_var(ts), e); + e = el_combine(eassign, el_bin(OPoror, TYvoid, el_var(ts), ea)); + e = el_combine(e, einv); + } + else + e = el_bin(OPoror,TYvoid,e,ea); + } + else + { // BUG: should replace assert(0); with a HLT instruction + e = el_long(TYint, 0); + } + el_setLoc(e,loc); + return e; +} + +elem *PostExp::toElem(IRState *irs) +{ + elem *e = e1->toElem(irs); + elem *einc = e2->toElem(irs); + e = el_bin((op == TOKplusplus) ? OPpostinc : OPpostdec, + e->Ety,e,einc); + el_setLoc(e,loc); + return e; +} + +//////////////////////////// Binary /////////////////////////////// + +/******************************************** + */ + +elem *BinExp::toElemBin(IRState *irs,int op) +{ + //printf("toElemBin() '%s'\n", toChars()); + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + if ((tb1->ty == Tarray || tb1->ty == Tsarray || + tb2->ty == Tarray || tb2->ty == Tsarray) && + tb2->ty != Tvoid && + op != OPeq && op != OPandand && op != OPoror + ) + { + error("Array operation %s not implemented", toChars()); + return el_long(type->totym(), 0); // error recovery + } + + tym_t tym = type->totym(); + + elem *el = e1->toElem(irs); + elem *er = e2->toElem(irs); + elem *e = el_bin(op,tym,el,er); + + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *AddExp::toElem(IRState *irs) +{ + elem *e = toElemBin(irs,OPadd); + return e; +} + +/*************************************** + */ + +elem *MinExp::toElem(IRState *irs) +{ + elem *e = toElemBin(irs,OPmin); + return e; +} + +/*************************************** + */ + +elem *CatExp::toElem(IRState *irs) +{ elem *e; + +#if 0 + printf("CatExp::toElem()\n"); + print(); +#endif + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + Type *ta = (tb1->ty == Tarray || tb1->ty == Tsarray) ? tb1 : tb2; + Type *tn = ta->nextOf(); + + if (e1->op == TOKcat) + { + elem *ep; + CatExp *ce = this; + int n = 2; + + ep = eval_Darray(irs, ce->e2); + do + { + n++; + ce = (CatExp *)ce->e1; + ep = el_param(ep, eval_Darray(irs, ce->e2)); + } while (ce->e1->op == TOKcat); + ep = el_param(ep, eval_Darray(irs, ce->e1)); + ep = el_params( + ep, + el_long(TYsize_t, n), + ta->getTypeInfo(NULL)->toElem(irs), + NULL); + e = el_bin(OPcall, TYdarray, el_var(rtlsym[RTLSYM_ARRAYCATNT]), ep); + e->Eflags |= EFLAGS_variadic; + } + else + { + elem *e1; + elem *e2; + elem *ep; + + e1 = eval_Darray(irs, this->e1); + e2 = eval_Darray(irs, this->e2); + ep = el_params(e2, e1, ta->getTypeInfo(NULL)->toElem(irs), NULL); + e = el_bin(OPcall, TYdarray, el_var(rtlsym[RTLSYM_ARRAYCATT]), ep); + } + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *MulExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPmul); +} + +/************************************ + */ + +elem *DivExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPdiv); +} + +/*************************************** + */ + +elem *ModExp::toElem(IRState *irs) +{ + elem *e; + elem *e1; + elem *e2; + tym_t tym; + + tym = type->totym(); + + e1 = this->e1->toElem(irs); + e2 = this->e2->toElem(irs); + +#if 0 // Now inlined + if (this->e1->type->isfloating()) + { elem *ep; + + switch (this->e1->type->ty) + { + case Tfloat32: + case Timaginary32: + e1 = el_una(OPf_d, TYdouble, e1); + e2 = el_una(OPf_d, TYdouble, e2); + case Tfloat64: + case Timaginary64: + e1 = el_una(OPd_ld, TYldouble, e1); + e2 = el_una(OPd_ld, TYldouble, e2); + break; + case Tfloat80: + case Timaginary80: + break; + default: + assert(0); + break; + } + ep = el_param(e2,e1); + e = el_bin(OPcall,tym,el_var(rtlsym[RTLSYM_MODULO]),ep); + } + else +#endif + e = el_bin(OPmod,tym,e1,e2); + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *CmpExp::toElem(IRState *irs) +{ + elem *e; + enum OPER eop; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + + switch (op) + { + case TOKlt: eop = OPlt; break; + case TOKgt: eop = OPgt; break; + case TOKle: eop = OPle; break; + case TOKge: eop = OPge; break; + case TOKequal: eop = OPeqeq; break; + case TOKnotequal: eop = OPne; break; + + // NCEG floating point compares + case TOKunord: eop = OPunord; break; + case TOKlg: eop = OPlg; break; + case TOKleg: eop = OPleg; break; + case TOKule: eop = OPule; break; + case TOKul: eop = OPul; break; + case TOKuge: eop = OPuge; break; + case TOKug: eop = OPug; break; + case TOKue: eop = OPue; break; + default: + dump(0); + assert(0); + } + if (!t1->isfloating()) + { + // Convert from floating point compare to equivalent + // integral compare + eop = (enum OPER)rel_integral(eop); + } + if ((int)eop > 1 && t1->ty == Tclass && t2->ty == Tclass) + { +#if 1 + assert(0); +#else + elem *ec1; + elem *ec2; + + ec1 = e1->toElem(irs); + ec2 = e2->toElem(irs); + e = el_bin(OPcall,TYint,el_var(rtlsym[RTLSYM_OBJ_CMP]),el_param(ec1, ec2)); + e = el_bin(eop, TYint, e, el_long(TYint, 0)); +#endif + } + else if ((int)eop > 1 && + (t1->ty == Tarray || t1->ty == Tsarray) && + (t2->ty == Tarray || t2->ty == Tsarray)) + { + elem *ea1; + elem *ea2; + elem *ep; + Type *telement = t1->nextOf()->toBasetype(); + int rtlfunc; + + ea1 = e1->toElem(irs); + ea1 = array_toDarray(t1, ea1); + ea2 = e2->toElem(irs); + ea2 = array_toDarray(t2, ea2); + +#if DMDV2 + ep = el_params(telement->arrayOf()->getInternalTypeInfo(NULL)->toElem(irs), + ea2, ea1, NULL); + rtlfunc = RTLSYM_ARRAYCMP2; +#else + ep = el_params(telement->getInternalTypeInfo(NULL)->toElem(irs), ea2, ea1, NULL); + rtlfunc = RTLSYM_ARRAYCMP; +#endif + e = el_bin(OPcall, TYint, el_var(rtlsym[rtlfunc]), ep); + e = el_bin(eop, TYint, e, el_long(TYint, 0)); + el_setLoc(e,loc); + } + else + { + if ((int)eop <= 1) + { + /* The result is determinate, create: + * (e1 , e2) , eop + */ + e = toElemBin(irs,OPcomma); + e = el_bin(OPcomma,e->Ety,e,el_long(e->Ety,(int)eop)); + } + else + e = toElemBin(irs,eop); + } + return e; +} + +elem *EqualExp::toElem(IRState *irs) +{ + //printf("EqualExp::toElem() %s\n", toChars()); + + elem *e; + enum OPER eop; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + + switch (op) + { + case TOKequal: eop = OPeqeq; break; + case TOKnotequal: eop = OPne; break; + default: + dump(0); + assert(0); + } + + //printf("EqualExp::toElem()\n"); + if (t1->ty == Tstruct) + { // Do bit compare of struct's + + elem *es1 = e1->toElem(irs); + elem *es2 = e2->toElem(irs); + es1 = addressElem(es1, t1); + es2 = addressElem(es2, t2); + e = el_param(es1, es2); + elem *ecount = el_long(TYsize_t, t1->size()); + e = el_bin(OPmemcmp, TYint, e, ecount); + e = el_bin(eop, TYint, e, el_long(TYint, 0)); + el_setLoc(e,loc); + } +#if 0 + else if (t1->ty == Tclass && t2->ty == Tclass) + { + elem *ec1 = e1->toElem(irs); + elem *ec2 = e2->toElem(irs); + e = el_bin(OPcall,TYint,el_var(rtlsym[RTLSYM_OBJ_EQ]),el_param(ec1, ec2)); + } +#endif + else if ((t1->ty == Tarray || t1->ty == Tsarray) && + (t2->ty == Tarray || t2->ty == Tsarray)) + { + Type *telement = t1->nextOf()->toBasetype(); + + elem *ea1 = e1->toElem(irs); + ea1 = array_toDarray(t1, ea1); + elem *ea2 = e2->toElem(irs); + ea2 = array_toDarray(t2, ea2); + +#if DMDV2 + elem *ep = el_params(telement->arrayOf()->getInternalTypeInfo(NULL)->toElem(irs), + ea2, ea1, NULL); + int rtlfunc = RTLSYM_ARRAYEQ2; +#else + elem *ep = el_params(telement->getInternalTypeInfo(NULL)->toElem(irs), ea2, ea1, NULL); + int rtlfunc = RTLSYM_ARRAYEQ; +#endif + e = el_bin(OPcall, TYint, el_var(rtlsym[rtlfunc]), ep); + if (op == TOKnotequal) + e = el_bin(OPxor, TYint, e, el_long(TYint, 1)); + el_setLoc(e,loc); + } + else if (t1->ty == Taarray && t2->ty == Taarray) + { TypeAArray *taa = (TypeAArray *)t1; + Symbol *s = taa->aaGetSymbol("Equal", 0); + elem *ti = taa->getTypeInfo(NULL)->toElem(irs); + elem *ea1 = e1->toElem(irs); + elem *ea2 = e2->toElem(irs); + // aaEqual(ti, e1, e2) + elem *ep = el_params(ea2, ea1, ti, NULL); + e = el_bin(OPcall, TYnptr, el_var(s), ep); + if (op == TOKnotequal) + e = el_bin(OPxor, TYint, e, el_long(TYint, 1)); + el_setLoc(e,loc); + return e; + } + else + e = toElemBin(irs, eop); + return e; +} + +elem *IdentityExp::toElem(IRState *irs) +{ + elem *e; + enum OPER eop; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + + switch (op) + { + case TOKidentity: eop = OPeqeq; break; + case TOKnotidentity: eop = OPne; break; + default: + dump(0); + assert(0); + } + + //printf("IdentityExp::toElem() %s\n", toChars()); + + if (t1->ty == Tstruct || t1->isfloating()) + { // Do bit compare of struct's + elem *es1; + elem *es2; + elem *ecount; + + es1 = e1->toElem(irs); + es1 = addressElem(es1, e1->type); + //es1 = el_una(OPaddr, TYnptr, es1); + es2 = e2->toElem(irs); + es2 = addressElem(es2, e2->type); + //es2 = el_una(OPaddr, TYnptr, es2); + e = el_param(es1, es2); + ecount = el_long(TYsize_t, t1->size()); + e = el_bin(OPmemcmp, TYint, e, ecount); + e = el_bin(eop, TYint, e, el_long(TYint, 0)); + el_setLoc(e,loc); + } + else if ((t1->ty == Tarray || t1->ty == Tsarray) && + (t2->ty == Tarray || t2->ty == Tsarray)) + { + elem *ea1; + elem *ea2; + + ea1 = e1->toElem(irs); + ea1 = array_toDarray(t1, ea1); + ea2 = e2->toElem(irs); + ea2 = array_toDarray(t2, ea2); + + e = el_bin(eop, type->totym(), ea1, ea2); + el_setLoc(e,loc); + } + else + e = toElemBin(irs, eop); + + return e; +} + + +/*************************************** + */ + +elem *InExp::toElem(IRState *irs) +{ elem *e; + elem *key = e1->toElem(irs); + elem *aa = e2->toElem(irs); + elem *ep; + elem *keyti; + TypeAArray *taa = (TypeAArray *)e2->type->toBasetype(); + + // aaInX(aa, keyti, key); + key = addressElem(key, e1->type); + Symbol *s = taa->aaGetSymbol("InX", 0); + keyti = taa->index->getInternalTypeInfo(NULL)->toElem(irs); + ep = el_params(key, keyti, aa, NULL); + e = el_bin(OPcall, type->totym(), el_var(s), ep); + + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *RemoveExp::toElem(IRState *irs) +{ elem *e; + Type *tb = e1->type->toBasetype(); + assert(tb->ty == Taarray); + TypeAArray *taa = (TypeAArray *)tb; + elem *ea = e1->toElem(irs); + elem *ekey = e2->toElem(irs); + elem *ep; + elem *keyti; + + ekey = addressElem(ekey, e1->type); + Symbol *s = taa->aaGetSymbol("DelX", 0); + keyti = taa->index->getInternalTypeInfo(NULL)->toElem(irs); + ep = el_params(ekey, keyti, ea, NULL); + e = el_bin(OPcall, TYnptr, el_var(s), ep); + + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *AssignExp::toElem(IRState *irs) +{ + //printf("AssignExp::toElem('%s')\n", toChars()); + Type *t1b = e1->type->toBasetype(); + + // Look for array.length = n + if (e1->op == TOKarraylength) + { + // Generate: + // _d_arraysetlength(e2, sizeelem, &ale->e1); + + ArrayLengthExp *ale = (ArrayLengthExp *)e1; + + elem *p1 = e2->toElem(irs); + elem *p3 = ale->e1->toElem(irs); + p3 = addressElem(p3, NULL); + Type *t1 = ale->e1->type->toBasetype(); + + // call _d_arraysetlengthT(ti, e2, &ale->e1); + elem *p2 = t1->getTypeInfo(NULL)->toElem(irs); + elem *ep = el_params(p3, p1, p2, NULL); // c function + int r = t1->nextOf()->isZeroInit() ? RTLSYM_ARRAYSETLENGTHT : RTLSYM_ARRAYSETLENGTHIT; + + elem *e = el_bin(OPcall, type->totym(), el_var(rtlsym[r]), ep); + el_setLoc(e, loc); + return e; + } + + elem *e; + IndexExp *ae; + + // Look for array[]=n + if (e1->op == TOKslice) + { + SliceExp *are = (SliceExp *)(e1); + Type *t1 = t1b; + Type *t2 = e2->type->toBasetype(); + + // which we do if the 'next' types match + if (ismemset) + { // Do a memset for array[]=v + //printf("Lpair %s\n", toChars()); + elem *evalue; + elem *enbytes; + elem *elength; + elem *einit; + Type *ta = are->e1->type->toBasetype(); + Type *tb = ta->nextOf()->toBasetype(); + unsigned sz = tb->size(); + tym_t tym = type->totym(); + + elem *n1 = are->e1->toElem(irs); + elem *elwr = are->lwr ? are->lwr->toElem(irs) : NULL; + elem *eupr = are->upr ? are->upr->toElem(irs) : NULL; + + elem *n1x = n1; + + // Look for array[]=n + if (ta->ty == Tsarray) + { + TypeSArray *ts = (TypeSArray *) ta; + n1 = array_toPtr(ta, n1); + enbytes = ts->dim->toElem(irs); + n1x = n1; + n1 = el_same(&n1x); + einit = resolveLengthVar(are->lengthVar, &n1, ta); + } + else if (ta->ty == Tarray) + { + n1 = el_same(&n1x); + einit = resolveLengthVar(are->lengthVar, &n1, ta); + enbytes = el_copytree(n1); + n1 = array_toPtr(ta, n1); + enbytes = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, enbytes); + } + else if (ta->ty == Tpointer) + { + n1 = el_same(&n1x); + enbytes = el_long(TYsize_t, -1); // largest possible index + einit = NULL; + } + + // Enforce order of evaluation of n1[elwr..eupr] as n1,elwr,eupr + elem *elwrx = elwr; + if (elwr) elwr = el_same(&elwrx); + elem *euprx = eupr; + if (eupr) eupr = el_same(&euprx); + +#if 0 + printf("sz = %d\n", sz); + printf("n1x\n"); + elem_print(n1x); + printf("einit\n"); + elem_print(einit); + printf("elwrx\n"); + elem_print(elwrx); + printf("euprx\n"); + elem_print(euprx); + printf("n1\n"); + elem_print(n1); + printf("elwr\n"); + elem_print(elwr); + printf("eupr\n"); + elem_print(eupr); + printf("enbytes\n"); + elem_print(enbytes); +#endif + einit = el_combine(n1x, einit); + einit = el_combine(einit, elwrx); + einit = el_combine(einit, euprx); + + evalue = this->e2->toElem(irs); + +#if 0 + printf("n1\n"); + elem_print(n1); + printf("enbytes\n"); + elem_print(enbytes); +#endif + + if (irs->arrayBoundsCheck() && eupr && ta->ty != Tpointer) + { + elem *c1; + elem *c2; + elem *ea; + elem *eb; + elem *enbytesx; + + assert(elwr); + enbytesx = enbytes; + enbytes = el_same(&enbytesx); + c1 = el_bin(OPle, TYint, el_copytree(eupr), enbytesx); + c2 = el_bin(OPle, TYint, el_copytree(elwr), el_copytree(eupr)); + c1 = el_bin(OPandand, TYint, c1, c2); + + // Construct: (c1 || ModuleArray(line)) + Symbol *sassert; + + sassert = irs->blx->module->toModuleArray(); + ea = el_bin(OPcall,TYvoid,el_var(sassert), el_long(TYint, loc.linnum)); + eb = el_bin(OPoror,TYvoid,c1,ea); + einit = el_combine(einit, eb); + } + + if (elwr) + { elem *elwr2; + + el_free(enbytes); + elwr2 = el_copytree(elwr); + elwr2 = el_bin(OPmul, TYsize_t, elwr2, el_long(TYsize_t, sz)); + n1 = el_bin(OPadd, TYnptr, n1, elwr2); + enbytes = el_bin(OPmin, TYsize_t, eupr, elwr); + elength = el_copytree(enbytes); + } + else + elength = el_copytree(enbytes); + e = setArray(n1, enbytes, tb, evalue, irs, op); + e = el_pair(TYdarray, elength, e); + e = el_combine(einit, e); + //elem_print(e); + goto Lret; + } +#if 0 + else if (e2->op == TOKadd || e2->op == TOKmin) + { + /* It's ea[] = eb[] +- ec[] + */ + BinExp *e2a = (BinExp *)e2; + Type *t = e2->type->toBasetype()->nextOf()->toBasetype(); + if (t->ty != Tfloat32 && t->ty != Tfloat64 && t->ty != Tfloat80) + { + e2->error("array add/min for %s not supported", t->toChars()); + return el_long(TYint, 0); + } + elem *ea = e1->toElem(irs); + ea = array_toDarray(e1->type, ea); + elem *eb = e2a->e1->toElem(irs); + eb = array_toDarray(e2a->e1->type, eb); + elem *ec = e2a->e2->toElem(irs); + ec = array_toDarray(e2a->e2->type, ec); + + int rtl = RTLSYM_ARRAYASSADDFLOAT; + if (t->ty == Tfloat64) + rtl = RTLSYM_ARRAYASSADDDOUBLE; + else if (t->ty == Tfloat80) + rtl = RTLSYM_ARRAYASSADDREAL; + if (e2->op == TOKmin) + { + rtl = RTLSYM_ARRAYASSMINFLOAT; + if (t->ty == Tfloat64) + rtl = RTLSYM_ARRAYASSMINDOUBLE; + else if (t->ty == Tfloat80) + rtl = RTLSYM_ARRAYASSMINREAL; + } + + /* Set parameters so the order of evaluation is eb, ec, ea + */ + elem *ep = el_params(eb, ec, ea, NULL); + e = el_bin(OPcall, type->totym(), el_var(rtlsym[rtl]), ep); + goto Lret; + } +#endif + else + { + /* It's array1[]=array2[] + * which is a memcpy + */ + elem *ep; + + elem *eto = e1->toElem(irs); + elem *efrom = e2->toElem(irs); + + unsigned size = t1->nextOf()->size(); + elem *esize = el_long(TYsize_t, size); + + /* Determine if we need to do postblit + */ + int postblit = 0; + if (needsPostblit(t1)) + postblit = 1; + + assert(e2->type->ty != Tpointer); + + if (!postblit && !irs->arrayBoundsCheck()) + { + elem *ex = el_same(&eto); + + // Determine if elen is a constant + elem *elen; + if (eto->Eoper == OPpair && + eto->E1->Eoper == OPconst) + { + elen = el_copytree(eto->E1); + } + else + { + // It's not a constant, so pull it from the dynamic array + elen = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, el_copytree(ex)); + } + + esize = el_bin(OPmul, TYsize_t, elen, esize); + elem *epto = array_toPtr(e1->type, ex); + elem *epfr = array_toPtr(e2->type, efrom); +#if 1 + // memcpy() is faster, so if we can't beat 'em, join 'em + e = el_params(esize, epfr, epto, NULL); + e = el_bin(OPcall,TYnptr,el_var(rtlsym[RTLSYM_MEMCPY]),e); +#else + e = el_bin(OPmemcpy, TYnptr, epto, el_param(epfr, esize)); +#endif + e = el_pair(eto->Ety, el_copytree(elen), e); + e = el_combine(eto, e); + } +#if DMDV2 + else if (postblit && op != TOKblit) + { + /* Generate: + * _d_arrayassign(ti, efrom, eto) + * or: + * _d_arrayctor(ti, efrom, eto) + */ + el_free(esize); + Expression *ti = t1->nextOf()->toBasetype()->getTypeInfo(NULL); + ep = el_params(eto, efrom, ti->toElem(irs), NULL); + int rtl = (op == TOKconstruct) ? RTLSYM_ARRAYCTOR : RTLSYM_ARRAYASSIGN; + e = el_bin(OPcall, type->totym(), el_var(rtlsym[rtl]), ep); + } +#endif + else + { + // Generate: + // _d_arraycopy(eto, efrom, esize) + + ep = el_params(eto, efrom, esize, NULL); + e = el_bin(OPcall, type->totym(), el_var(rtlsym[RTLSYM_ARRAYCOPY]), ep); + } + el_setLoc(e, loc); + return e; + } + } + + if (e1->op == TOKindex) + { + ae = (IndexExp *)(e1); + } + +#if DMDV2 + /* Look for reference initializations + */ + if (op == TOKconstruct && e1->op == TOKvar) + { + VarExp *ve = (VarExp *)e1; + Declaration *s = ve->var; + if (s->storage_class & (STCout | STCref)) + { +#if 0 + Expression *ae = e2->addressOf(NULL); + e = ae->toElem(irs); +#else + e = e2->toElem(irs); + e = addressElem(e, e2->type); +#endif + elem *es = el_var(s->toSymbol()); + es->Ety = TYnptr; + e = el_bin(OPeq, TYnptr, es, e); +// BUG: type is struct, and e2 is TOKint64 + goto Lret; + } + } +#endif + +#if 1 + /* This will work if we can distinguish an assignment from + * an initialization of the lvalue. It'll work if the latter. + * If the former, because of aliasing of the return value with + * function arguments, it'll fail. + */ + if (op == TOKconstruct && e2->op == TOKcall) + { CallExp *ce = (CallExp *)e2; + + TypeFunction *tf = (TypeFunction *)ce->e1->type->toBasetype(); + if (tf->ty == Tfunction && tf->retStyle() == RETstack) + { + elem *ehidden = e1->toElem(irs); + ehidden = el_una(OPaddr, TYnptr, ehidden); + assert(!irs->ehidden); + irs->ehidden = ehidden; + e = e2->toElem(irs); + goto Lret; + } + } +#endif +//if (op == TOKconstruct) printf("construct\n"); + if (t1b->ty == Tstruct || t1b->ty == Tsarray) + { elem *eleft = e1->toElem(irs); + + if (e2->op == TOKint64) + { /* Implement: + * (struct = 0) + * with: + * memset(&struct, 0, struct.sizeof) + */ + elem *ey = NULL; + unsigned sz = e1->type->size(); + StructDeclaration *sd = ((TypeStruct *)t1b)->sym; + if (sd->isnested && op == TOKconstruct) + { + ey = el_una(OPaddr, TYnptr, eleft); + eleft = el_same(&ey); + ey = setEthis(loc, irs, ey, sd); + sz = sd->vthis->offset; + } + + elem *el = eleft; + elem *enbytes = el_long(TYsize_t, sz); + elem *evalue = el_long(TYsize_t, 0); + + if (!(sd->isnested && op == TOKconstruct)) + el = el_una(OPaddr, TYnptr, el); + e = el_param(enbytes, evalue); + e = el_bin(OPmemset,TYnptr,el,e); + e = el_combine(ey, e); + el_setLoc(e, loc); + //e = el_una(OPind, TYstruct, e); + } + else + { + //printf("toElemBin() '%s'\n", toChars()); + + tym_t tym = type->totym(); + + elem *e1 = eleft; + elem *ex = e1; + if (e1->Eoper == OPind) + ex = e1->E1; + if (this->e2->op == TOKstructliteral && + ex->Eoper == OPvar && ex->EV.sp.Voffset == 0) + { StructLiteralExp *se = (StructLiteralExp *)this->e2; + + Symbol *symSave = se->sym; + size_t soffsetSave = se->soffset; + int fillHolesSave = se->fillHoles; + + se->sym = ex->EV.sp.Vsym; + se->soffset = 0; + se->fillHoles = (op == TOKconstruct || op == TOKblit) ? 1 : 0; + + el_free(e1); + e = this->e2->toElem(irs); + + se->sym = symSave; + se->soffset = soffsetSave; + se->fillHoles = fillHolesSave; + } + else + { + elem *e2 = this->e2->toElem(irs); + e = el_bin(OPstreq,tym,e1,e2); + e->ET = this->e1->type->toCtype(); + if (type_size(e->ET) == 0) + e->Eoper = OPcomma; + } + goto Lret; + } + } + else + e = toElemBin(irs,OPeq); + return e; + + Lret: + el_setLoc(e,loc); + return e; +} + +/*************************************** + */ + +elem *AddAssignExp::toElem(IRState *irs) +{ + //printf("AddAssignExp::toElem() %s\n", toChars()); + elem *e = toElemBin(irs,OPaddass); + return e; +} + + +/*************************************** + */ + +elem *MinAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPminass); +} + +/*************************************** + */ + +elem *CatAssignExp::toElem(IRState *irs) +{ + //printf("CatAssignExp::toElem('%s')\n", toChars()); + elem *e; + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + if (tb1->ty == Tarray && tb2->ty == Tdchar && + (tb1->nextOf()->ty == Tchar || tb1->nextOf()->ty == Twchar)) + { // Append dchar to char[] or wchar[] + + elem *e1 = this->e1->toElem(irs); + e1 = el_una(OPaddr, TYnptr, e1); + + elem *e2 = this->e2->toElem(irs); + + elem *ep = el_params(e2, e1, NULL); + int rtl = (tb1->nextOf()->ty == Tchar) + ? RTLSYM_ARRAYAPPENDCD + : RTLSYM_ARRAYAPPENDWD; + e = el_bin(OPcall, TYdarray, el_var(rtlsym[rtl]), ep); + el_setLoc(e,loc); + } + else if (tb1->ty == Tarray || tb2->ty == Tsarray) + { + elem *e1 = this->e1->toElem(irs); + elem *e2 = this->e2->toElem(irs); + + Type *tb1n = tb1->nextOf()->toBasetype(); + if ((tb2->ty == Tarray || tb2->ty == Tsarray) && + tb1n->equals(tb2->nextOf()->toBasetype())) + { // Append array + e1 = el_una(OPaddr, TYnptr, e1); + if (tybasic(e2->Ety) == TYstruct || tybasic(e2->Ety) == TYarray) + { + e2 = el_una(OPstrpar, TYstruct, e2); + e2->ET = e2->E1->ET; + } + elem *ep = el_params(e2, e1, this->e1->type->getTypeInfo(NULL)->toElem(irs), NULL); + e = el_bin(OPcall, TYdarray, el_var(rtlsym[RTLSYM_ARRAYAPPENDT]), ep); + } + else if (I64) + { // Append element + + elem *e2x = NULL; + + if (e2->Eoper != OPvar && e2->Eoper != OPconst) + { + // Evaluate e2 and assign result to temporary s2. + // Do this because of: + // a ~= a[$-1] + // because $ changes its value + symbol *s2 = symbol_genauto(tb2->toCtype()); + e2x = el_bin(OPeq, e2->Ety, el_var(s2), e2); + if (tybasic(e2->Ety) == TYstruct) + { + e2x->Eoper = OPstreq; + e2x->ET = tb1n->toCtype(); + } + else if (tybasic(e2->Ety) == TYarray) + { + e2x->Eoper = OPstreq; + e2x->Ejty = e2x->Ety = TYstruct; + e2x->ET = tb1n->toCtype(); + } + e2 = el_var(s2); + } + + // Extend array with _d_arrayappendcTX(TypeInfo ti, e1, 1) + e1 = el_una(OPaddr, TYnptr, e1); + elem *ep = el_param(e1, this->e1->type->getTypeInfo(NULL)->toElem(irs)); + ep = el_param(el_long(TYsize_t, 1), ep); + e = el_bin(OPcall, TYdarray, el_var(rtlsym[RTLSYM_ARRAYAPPENDCTX]), ep); + symbol *stmp = symbol_genauto(tb1->toCtype()); + e = el_bin(OPeq, TYdarray, el_var(stmp), e); + + // Assign e2 to last element in stmp[] + // *(stmp.ptr + (stmp.length - 1) * szelem) = e2 + + elem *eptr = array_toPtr(tb1, el_var(stmp)); + elem *elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, el_var(stmp)); + elength = el_bin(OPmin, TYsize_t, elength, el_long(TYsize_t, 1)); + elength = el_bin(OPmul, TYsize_t, elength, el_long(TYsize_t, this->e2->type->size())); + eptr = el_bin(OPadd, TYnptr, eptr, elength); + StructDeclaration *sd = needsPostblit(tb2); + elem *epost = NULL; + if (sd) + epost = el_same(&eptr); + elem *ederef = el_una(OPind, e2->Ety, eptr); + elem *eeq = el_bin(OPeq, e2->Ety, ederef, e2); + + if (tybasic(e2->Ety) == TYstruct) + { + eeq->Eoper = OPstreq; + eeq->ET = tb1n->toCtype(); + } + else if (tybasic(e2->Ety) == TYarray) + { + eeq->Eoper = OPstreq; + eeq->Ejty = eeq->Ety = TYstruct; + eeq->ET = tb1n->toCtype(); + } + + /* Need to call postblit on eeq + */ + if (sd) + { FuncDeclaration *fd = sd->postblit; + epost = callfunc(loc, irs, 1, Type::tvoid, epost, sd->type->pointerTo(), fd, fd->type, NULL, NULL); + eeq = el_bin(OPcomma, epost->Ety, eeq, epost); + } + + e = el_combine(e2x, e); + e = el_combine(e, eeq); + e = el_combine(e, el_var(stmp)); + } + else + { // Append element + e1 = el_una(OPaddr, TYnptr, e1); + if (tybasic(e2->Ety) == TYstruct || tybasic(e2->Ety) == TYarray) + { + e2 = el_una(OPstrpar, TYstruct, e2); + e2->ET = e2->E1->ET; + } + elem *ep = el_params(e2, e1, this->e1->type->getTypeInfo(NULL)->toElem(irs), NULL); + e = el_bin(OPcall, TYdarray, el_var(rtlsym[RTLSYM_ARRAYAPPENDCT]), ep); + e->Eflags |= EFLAGS_variadic; + } + + el_setLoc(e,loc); + } + else + assert(0); + return e; +} + + +/*************************************** + */ + +elem *DivAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPdivass); +} + + +/*************************************** + */ + +elem *ModAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPmodass); +} + + +/*************************************** + */ + +elem *MulAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPmulass); +} + + +/*************************************** + */ + +elem *ShlAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPshlass); +} + + +/*************************************** + */ + +elem *ShrAssignExp::toElem(IRState *irs) +{ + //printf("ShrAssignExp::toElem() %s, %s\n", e1->type->toChars(), e1->toChars()); + Type *t1 = e1->type; + if (e1->op == TOKcast) + { /* Use the type before it was integrally promoted to int + */ + CastExp *ce = (CastExp *)e1; + t1 = ce->e1->type; + } + return toElemBin(irs, t1->isunsigned() ? OPshrass : OPashrass); +} + + +/*************************************** + */ + +elem *UshrAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs, OPshrass); +} + + +/*************************************** + */ + +elem *AndAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPandass); +} + + +/*************************************** + */ + +elem *OrAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPorass); +} + + +/*************************************** + */ + +elem *XorAssignExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPxorass); +} + + +/*************************************** + */ + +elem *PowAssignExp::toElem(IRState *irs) +{ + Type *tb1 = e1->type->toBasetype(); + if (tb1->ty == Tarray || tb1->ty == Tsarray) + { + error("Array operation %s not implemented", toChars()); + return el_long(type->totym(), 0); // error recovery + } + else + { assert(0); + return NULL; + } +} + + +/*************************************** + */ + +elem *AndAndExp::toElem(IRState *irs) +{ + tym_t tym = type->totym(); + + elem *el = e1->toElem(irs); + elem *er = e2->toElemDtor(irs); + elem *e = el_bin(OPandand,tym,el,er); + + el_setLoc(e,loc); + + if (global.params.cov && e2->loc.linnum) + e->E2 = el_combine(incUsageElem(irs, e2->loc), e->E2); + return e; +} + + +/*************************************** + */ + +elem *OrOrExp::toElem(IRState *irs) +{ + tym_t tym = type->totym(); + + elem *el = e1->toElem(irs); + elem *er = e2->toElemDtor(irs); + elem *e = el_bin(OPoror,tym,el,er); + + el_setLoc(e,loc); + + if (global.params.cov && e2->loc.linnum) + e->E2 = el_combine(incUsageElem(irs, e2->loc), e->E2); + return e; +} + + +/*************************************** + */ + +elem *XorExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPxor); +} + + +/*************************************** + */ + +elem *PowExp::toElem(IRState *irs) +{ + Type *tb1 = e1->type->toBasetype(); + if (tb1->ty == Tarray || tb1->ty == Tsarray) + { + error("Array operation %s not implemented", toChars()); + return el_long(type->totym(), 0); // error recovery + } + assert(0); + return NULL; +} + + +/*************************************** + */ + +elem *AndExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPand); +} + + +/*************************************** + */ + +elem *OrExp::toElem(IRState *irs) +{ + return toElemBin(irs,OPor); +} + + +/*************************************** + */ + +elem *ShlExp::toElem(IRState *irs) +{ + return toElemBin(irs, OPshl); +} + + +/*************************************** + */ + +elem *ShrExp::toElem(IRState *irs) +{ + return toElemBin(irs, e1->type->isunsigned() ? OPshr : OPashr); +} + + +/*************************************** + */ + +elem *UshrExp::toElem(IRState *irs) +{ + //return toElemBin(irs, OPshr); + elem *eleft = e1->toElem(irs); + eleft->Ety = touns(eleft->Ety); + elem *eright = e2->toElem(irs); + elem *e = el_bin(OPshr, type->totym(), eleft, eright); + el_setLoc(e, loc); + return e; +} + +/**************************************** + */ + +elem *CommaExp::toElem(IRState *irs) +{ + assert(e1 && e2); + elem *eleft = e1->toElem(irs); + elem *eright = e2->toElem(irs); + elem *e = el_combine(eleft, eright); + if (e) + el_setLoc(e, loc); + return e; +} + + +/*************************************** + */ + +elem *CondExp::toElem(IRState *irs) +{ + elem *ec = econd->toElem(irs); + + elem *eleft = e1->toElemDtor(irs); + tym_t ty = eleft->Ety; + if (global.params.cov && e1->loc.linnum) + eleft = el_combine(incUsageElem(irs, e1->loc), eleft); + + elem *eright = e2->toElemDtor(irs); + if (global.params.cov && e2->loc.linnum) + eright = el_combine(incUsageElem(irs, e2->loc), eright); + + elem *e = el_bin(OPcond, ty, ec, el_bin(OPcolon, ty, eleft, eright)); + if (tybasic(ty) == TYstruct) + e->ET = e1->type->toCtype(); + el_setLoc(e, loc); + return e; +} + + +/*************************************** + */ + +elem *TypeExp::toElem(IRState *irs) +{ +#ifdef DEBUG + printf("TypeExp::toElem()\n"); +#endif + error("type %s is not an expression", toChars()); + return el_long(TYint, 0); +} + +elem *ScopeExp::toElem(IRState *irs) +{ + error("%s is not an expression", sds->toChars()); + return el_long(TYint, 0); +} + +elem *DotVarExp::toElem(IRState *irs) +{ + // *(&e + offset) + + //printf("DotVarExp::toElem('%s')\n", toChars()); + + VarDeclaration *v = var->isVarDeclaration(); + if (!v) + { + error("%s is not a field, but a %s", var->toChars(), var->kind()); + } + + elem *e = e1->toElem(irs); + Type *tb1 = e1->type->toBasetype(); + if (tb1->ty != Tclass && tb1->ty != Tpointer) + //e = el_una(OPaddr, TYnptr, e); + e = addressElem(e, tb1); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, v ? v->offset : 0)); + e = el_una(OPind, type->totym(), e); + if (tybasic(e->Ety) == TYstruct) + { + e->ET = type->toCtype(); + } + el_setLoc(e,loc); + return e; +} + +elem *DelegateExp::toElem(IRState *irs) +{ + elem *e; + elem *ethis; + elem *ep; + Symbol *sfunc; + int directcall = 0; + + //printf("DelegateExp::toElem() '%s'\n", toChars()); + sfunc = func->toSymbol(); + if (func->isNested()) + { + ep = el_ptr(sfunc); + ethis = getEthis(loc, irs, func); + } + else + { + ethis = e1->toElem(irs); + if (e1->type->ty != Tclass && e1->type->ty != Tpointer) + ethis = addressElem(ethis, e1->type); + + if (e1->op == TOKsuper || e1->op == TOKdottype) + directcall = 1; + + if (!func->isThis()) + error("delegates are only for non-static functions"); + + if (!func->isVirtual() || + directcall || + func->isFinal()) + { + ep = el_ptr(sfunc); + } + else + { + // Get pointer to function out of virtual table + unsigned vindex; + + assert(ethis); + ep = el_same(ðis); + ep = el_una(OPind, TYnptr, ep); + vindex = func->vtblIndex; + + if ((int)vindex < 0) + error("Internal compiler error: malformed delegate. See Bugzilla 4860"); + + // Build *(ep + vindex * 4) + ep = el_bin(OPadd,TYnptr,ep,el_long(TYsize_t, vindex * PTRSIZE)); + ep = el_una(OPind,TYnptr,ep); + } + +// if (func->tintro) +// func->error(loc, "cannot form delegate due to covariant return type"); + } + if (ethis->Eoper == OPcomma) + { + ethis->E2 = el_pair(TYdelegate, ethis->E2, ep); + ethis->Ety = TYdelegate; + e = ethis; + } + else + e = el_pair(TYdelegate, ethis, ep); + el_setLoc(e,loc); + return e; +} + +elem *DotTypeExp::toElem(IRState *irs) +{ + // Just a pass-thru to e1 + elem *e; + + //printf("DotTypeExp::toElem() %s\n", toChars()); + e = e1->toElem(irs); + el_setLoc(e,loc); + return e; +} + +elem *CallExp::toElem(IRState *irs) +{ + //printf("CallExp::toElem('%s')\n", toChars()); + assert(e1->type); + elem *ec; + int directcall; + FuncDeclaration *fd; + Type *t1 = e1->type->toBasetype(); + Type *ectype = t1; + elem *eeq = NULL; + + elem *ehidden = irs->ehidden; + irs->ehidden = NULL; + + directcall = 0; + fd = NULL; + if (e1->op == TOKdotvar && t1->ty != Tdelegate) + { DotVarExp *dve = (DotVarExp *)e1; + + fd = dve->var->isFuncDeclaration(); + Expression *ex = dve->e1; + while (1) + { + switch (ex->op) + { + case TOKsuper: // super.member() calls directly + case TOKdottype: // type.member() calls directly + directcall = 1; + break; + + case TOKcast: + ex = ((CastExp *)ex)->e1; + continue; + + default: + //ex->dump(0); + break; + } + break; + } + ec = dve->e1->toElem(irs); + ectype = dve->e1->type->toBasetype(); + } + else if (e1->op == TOKvar) + { + fd = ((VarExp *)e1)->var->isFuncDeclaration(); + + if (fd && fd->ident == Id::alloca && + !fd->fbody && fd->linkage == LINKc && + arguments && arguments->dim == 1) + { Expression *arg = arguments->tdata()[0]; + arg = arg->optimize(WANTvalue); + if (arg->isConst() && arg->type->isintegral()) + { dinteger_t sz = arg->toInteger(); + if (sz > 0 && sz < 0x40000) + { + // It's an alloca(sz) of a fixed amount. + // Replace with an array allocated on the stack + // of the same size: char[sz] tmp; + + Symbol *stmp; + ::type *t; + + assert(!ehidden); + t = type_allocn(TYarray, tschar); + t->Tdim = sz; + stmp = symbol_genauto(t); + ec = el_ptr(stmp); + el_setLoc(ec,loc); + return ec; + } + } + } + + ec = e1->toElem(irs); + } + else + { + ec = e1->toElem(irs); + if (arguments && arguments->dim) + { + /* The idea is to enforce expressions being evaluated left to right, + * even though call trees are evaluated parameters first. + * We just do a quick hack to catch the more obvious cases, though + * we need to solve this generally. + */ + if (ec->Eoper == OPind && el_sideeffect(ec->E1)) + { /* Rewrite (*exp)(arguments) as: + * tmp=exp, (*tmp)(arguments) + */ + elem *ec1 = ec->E1; + Symbol *stmp = symbol_genauto(type_fake(ec1->Ety)); + eeq = el_bin(OPeq, ec->Ety, el_var(stmp), ec1); + ec->E1 = el_var(stmp); + } + else if (tybasic(ec->Ety) == TYdelegate && el_sideeffect(ec)) + { /* Rewrite (exp)(arguments) as: + * tmp=exp, (tmp)(arguments) + */ + Symbol *stmp = symbol_genauto(type_fake(ec->Ety)); + eeq = el_bin(OPeq, ec->Ety, el_var(stmp), ec); + ec = el_var(stmp); + } + } + } + ec = callfunc(loc, irs, directcall, type, ec, ectype, fd, t1, ehidden, arguments); + el_setLoc(ec,loc); + if (eeq) + ec = el_combine(eeq, ec); + return ec; +} + +elem *AddrExp::toElem(IRState *irs) +{ + //printf("AddrExp::toElem('%s')\n", toChars()); + elem *e = e1->toElem(irs); + e = addressElem(e, e1->type); + e->Ety = type->totym(); + el_setLoc(e,loc); + return e; +} + +elem *PtrExp::toElem(IRState *irs) +{ + //printf("PtrExp::toElem() %s\n", toChars()); + elem *e = e1->toElem(irs); + e = el_una(OPind,type->totym(),e); + if (tybasic(e->Ety) == TYstruct) + { + e->ET = type->toCtype(); + } + el_setLoc(e,loc); + return e; +} + +elem *BoolExp::toElem(IRState *irs) +{ + elem *e1 = this->e1->toElem(irs); + return el_una(OPbool,type->totym(),e1); +} + +elem *DeleteExp::toElem(IRState *irs) +{ elem *e; + int rtl; + Type *tb; + + //printf("DeleteExp::toElem()\n"); + if (e1->op == TOKindex) + { + IndexExp *ae = (IndexExp *)(e1); + tb = ae->e1->type->toBasetype(); + if (tb->ty == Taarray) + { + TypeAArray *taa = (TypeAArray *)tb; + elem *ea = ae->e1->toElem(irs); + elem *ekey = ae->e2->toElem(irs); + elem *ep; + elem *keyti; + + if (tybasic(ekey->Ety) == TYstruct || tybasic(ekey->Ety) == TYarray) + { + ekey = el_una(OPstrpar, TYstruct, ekey); + ekey->ET = ekey->E1->ET; + } + + Symbol *s = taa->aaGetSymbol("Del", 0); + keyti = taa->index->getInternalTypeInfo(NULL)->toElem(irs); + ep = el_params(ekey, keyti, ea, NULL); + e = el_bin(OPcall, TYnptr, el_var(s), ep); + goto Lret; + } + } + //e1->type->print(); + e = e1->toElem(irs); + tb = e1->type->toBasetype(); + switch (tb->ty) + { + case Tarray: + { e = addressElem(e, e1->type); + rtl = RTLSYM_DELARRAYT; + + /* See if we need to run destructors on the array contents + */ + elem *et = NULL; + Type *tv = tb->nextOf()->toBasetype(); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->dtor) + et = tb->nextOf()->getTypeInfo(NULL)->toElem(irs); + } + if (!et) // if no destructors needed + et = el_long(TYnptr, 0); // pass null for TypeInfo + e = el_params(et, e, NULL); + // call _d_delarray_t(e, et); + e = el_bin(OPcall, TYvoid, el_var(rtlsym[rtl]), e); + goto Lret; + } + case Tclass: + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + if (ve->var->isVarDeclaration() && + ve->var->isVarDeclaration()->onstack) + { + rtl = RTLSYM_CALLFINALIZER; + if (tb->isClassHandle()->isInterfaceDeclaration()) + rtl = RTLSYM_CALLINTERFACEFINALIZER; + break; + } + } + e = addressElem(e, e1->type); + rtl = RTLSYM_DELCLASS; + if (tb->isClassHandle()->isInterfaceDeclaration()) + rtl = RTLSYM_DELINTERFACE; + break; + + case Tpointer: + e = addressElem(e, e1->type); + rtl = RTLSYM_DELMEMORY; + break; + + default: + assert(0); + break; + } + e = el_bin(OPcall, TYvoid, el_var(rtlsym[rtl]), e); + + Lret: + el_setLoc(e,loc); + return e; +} + +elem *VectorExp::toElem(IRState *irs) +{ +#if 0 + printf("VectorExp::toElem()\n"); + print(); + printf("\tfrom: %s\n", e1->type->toChars()); + printf("\tto : %s\n", to->toChars()); +#endif + + dinteger_t d; + real_t r; + if (e1->type->isfloating()) + r = e1->toReal(); + else if (e1->type->isintegral()) + d = e1->toInteger(); + else + assert(0); + elem *e = el_calloc(); + e->Eoper = OPconst; + e->Ety = type->totym(); + switch (tybasic(e->Ety)) + { + case TYfloat4: + for (size_t i = 0; i < 4; i++) + ((targ_float *)&e->EV.Vcent)[i] = r; + break; + case TYdouble2: + ((targ_double *)&e->EV.Vcent.lsw)[0] = r; + ((targ_double *)&e->EV.Vcent.msw)[0] = r; + break; + case TYschar16: + case TYuchar16: + for (size_t i = 0; i < 16; i++) + ((targ_uchar *)&e->EV.Vcent)[i] = d; + break; + case TYshort8: + case TYushort8: + for (size_t i = 0; i < 8; i++) + ((targ_ushort *)&e->EV.Vcent)[i] = d; + break; + case TYlong4: + case TYulong4: + for (size_t i = 0; i < 4; i++) + ((targ_ulong *)&e->EV.Vcent)[i] = d; + break; + case TYllong2: + case TYullong2: e->EV.Vcent.lsw = d; + e->EV.Vcent.msw = d; + break; + default: + assert(0); + } + el_setLoc(e, loc); + return e; +} + +elem *CastExp::toElem(IRState *irs) +{ + TY fty; + TY tty; + tym_t ftym; + tym_t ttym; + enum OPER eop; + +#if 0 + printf("CastExp::toElem()\n"); + print(); + printf("\tfrom: %s\n", e1->type->toChars()); + printf("\tto : %s\n", to->toChars()); +#endif + + elem *e = e1->toElem(irs); + Type *tfrom = e1->type->toBasetype(); + Type *t = to->toBasetype(); // skip over typedef's + +#if DMDV2 + if (tfrom->ty == Taarray) + tfrom = ((TypeAArray*)tfrom)->getImpl()->type; + if (t->ty == Taarray) + t = ((TypeAArray*)t)->getImpl()->type; +#endif + + if (t->equals(tfrom)) + goto Lret; + + fty = tfrom->ty; + //printf("fty = %d\n", fty); + tty = t->ty; + + if (tty == Tpointer && fty == Tarray +#if 0 + && (t->next->ty == Tvoid || t->next->equals(e1->type->next)) +#endif + ) + { + if (e->Eoper == OPvar) + { + // e1 -> *(&e1 + 4) + e = el_una(OPaddr, TYnptr, e); + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, tysize[TYnptr])); + e = el_una(OPind,t->totym(),e); + } + else + { + // e1 -> (unsigned)(e1 >> 32) + if (I64) + { + e = el_bin(OPshr, TYucent, e, el_long(TYint, 64)); + e = el_una(OP128_64, t->totym(), e); + } + else + { + e = el_bin(OPshr, TYullong, e, el_long(TYint, 32)); + e = el_una(OP64_32, t->totym(), e); + } + } + goto Lret; + } + + if (tty == Tpointer && fty == Tsarray +#if 0 + && (t->next->ty == Tvoid || t->next->equals(e1->type->next)) +#endif + ) + { + // e1 -> &e1 + e = el_una(OPaddr, TYnptr, e); + goto Lret; + } + + // Convert from static array to dynamic array + if (tty == Tarray && fty == Tsarray) + { + e = sarray_toDarray(loc, tfrom, t, e); + goto Lret; + } + + // Convert from dynamic array to dynamic array + if (tty == Tarray && fty == Tarray) + { + unsigned fsize = tfrom->nextOf()->size(); + unsigned tsize = t->nextOf()->size(); + + if (fsize != tsize) + { // Array element sizes do not match, so we must adjust the dimensions + elem *ep = el_params(e, el_long(TYsize_t, fsize), el_long(TYsize_t, tsize), NULL); + e = el_bin(OPcall, type->totym(), el_var(rtlsym[RTLSYM_ARRAYCAST]), ep); + } + goto Lret; + } + + // Casting from base class to derived class requires a runtime check + if (fty == Tclass && tty == Tclass) + { + // Casting from derived class to base class is a no-op + int offset; + int rtl = RTLSYM_DYNAMIC_CAST; + + ClassDeclaration *cdfrom = tfrom->isClassHandle(); + ClassDeclaration *cdto = t->isClassHandle(); + if (cdfrom->isInterfaceDeclaration()) + { + rtl = RTLSYM_INTERFACE_CAST; + if (cdfrom->isCPPinterface()) + { + if (cdto->isCPPinterface()) + { + /* Casting from a C++ interface to a C++ interface + * is always a 'paint' operation + */ + goto Lret; // no-op + } + + /* Casting from a C++ interface to a class + * always results in null because there is no runtime + * information available to do it. + * + * Casting from a C++ interface to a non-C++ interface + * always results in null because there's no way one + * can be derived from the other. + */ + e = el_bin(OPcomma, TYnptr, e, el_long(TYnptr, 0)); + goto Lret; + } + } + if (cdto->isBaseOf(cdfrom, &offset) && offset != OFFSET_RUNTIME) + { + /* The offset from cdfrom=>cdto is known at compile time. + */ + + //printf("offset = %d\n", offset); + if (offset) + { /* Rewrite cast as (e ? e + offset : null) + */ + if (e1->op == TOKthis) + { // Assume 'this' is never null, so skip null check + e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, offset)); + } + else + { + elem *etmp = el_same(&e); + elem *ex = el_bin(OPadd, TYnptr, etmp, el_long(TYsize_t, offset)); + ex = el_bin(OPcolon, TYnptr, ex, el_long(TYnptr, 0)); + e = el_bin(OPcond, TYnptr, e, ex); + } + } + goto Lret; // no-op + } + + /* The offset from cdfrom=>cdto can only be determined at runtime. + */ + elem *ep = el_param(el_ptr(cdto->toSymbol()), e); + e = el_bin(OPcall, TYnptr, el_var(rtlsym[rtl]), ep); + goto Lret; + } + + if (fty == Tvector && tty == Tsarray) + { + if (tfrom->size() == t->size()) + goto Lret; + } + + ftym = tybasic(e->Ety); + ttym = tybasic(t->totym()); + if (ftym == ttym) + goto Lret; + + /* Reduce combinatorial explosion by rewriting the 'to' and 'from' types to a + * generic equivalent (as far as casting goes) + */ + switch (tty) + { + case Tpointer: + if (fty == Tdelegate) + goto Lpaint; + tty = I64 ? Tuns64 : Tuns32; + break; + + case Tchar: tty = Tuns8; break; + case Twchar: tty = Tuns16; break; + case Tdchar: tty = Tuns32; break; + case Tvoid: goto Lpaint; + + case Tbool: + { + // Construct e?true:false + e = el_una(OPbool, ttym, e); + goto Lret; + } + } + + switch (fty) + { + case Tpointer: fty = I64 ? Tuns64 : Tuns32; break; + case Tchar: fty = Tuns8; break; + case Twchar: fty = Tuns16; break; + case Tdchar: fty = Tuns32; break; + } + + #define X(fty, tty) ((fty) * TMAX + (tty)) +Lagain: + switch (X(fty,tty)) + { + /* ============================= */ + + case X(Tbool,Tint8): + case X(Tbool,Tuns8): + goto Lpaint; + case X(Tbool,Tint16): + case X(Tbool,Tuns16): + case X(Tbool,Tint32): + case X(Tbool,Tuns32): eop = OPu8_16; goto Leop; + case X(Tbool,Tint64): + case X(Tbool,Tuns64): + case X(Tbool,Tfloat32): + case X(Tbool,Tfloat64): + case X(Tbool,Tfloat80): + case X(Tbool,Tcomplex32): + case X(Tbool,Tcomplex64): + case X(Tbool,Tcomplex80): + e = el_una(OPu8_16, TYuint, e); + fty = Tuns32; + goto Lagain; + case X(Tbool,Timaginary32): + case X(Tbool,Timaginary64): + case X(Tbool,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tint8,Tuns8): goto Lpaint; + case X(Tint8,Tint16): + case X(Tint8,Tuns16): + case X(Tint8,Tint32): + case X(Tint8,Tuns32): eop = OPs8_16; goto Leop; + case X(Tint8,Tint64): + case X(Tint8,Tuns64): + case X(Tint8,Tfloat32): + case X(Tint8,Tfloat64): + case X(Tint8,Tfloat80): + case X(Tint8,Tcomplex32): + case X(Tint8,Tcomplex64): + case X(Tint8,Tcomplex80): + e = el_una(OPs8_16, TYint, e); + fty = Tint32; + goto Lagain; + case X(Tint8,Timaginary32): + case X(Tint8,Timaginary64): + case X(Tint8,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tuns8,Tint8): goto Lpaint; + case X(Tuns8,Tint16): + case X(Tuns8,Tuns16): + case X(Tuns8,Tint32): + case X(Tuns8,Tuns32): eop = OPu8_16; goto Leop; + case X(Tuns8,Tint64): + case X(Tuns8,Tuns64): + case X(Tuns8,Tfloat32): + case X(Tuns8,Tfloat64): + case X(Tuns8,Tfloat80): + case X(Tuns8,Tcomplex32): + case X(Tuns8,Tcomplex64): + case X(Tuns8,Tcomplex80): + e = el_una(OPu8_16, TYuint, e); + fty = Tuns32; + goto Lagain; + case X(Tuns8,Timaginary32): + case X(Tuns8,Timaginary64): + case X(Tuns8,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tint16,Tint8): + case X(Tint16,Tuns8): eop = OP16_8; goto Leop; + case X(Tint16,Tuns16): goto Lpaint; + case X(Tint16,Tint32): + case X(Tint16,Tuns32): eop = OPs16_32; goto Leop; + case X(Tint16,Tint64): + case X(Tint16,Tuns64): e = el_una(OPs16_32, TYint, e); + fty = Tint32; + goto Lagain; + case X(Tint16,Tfloat32): + case X(Tint16,Tfloat64): + case X(Tint16,Tfloat80): + case X(Tint16,Tcomplex32): + case X(Tint16,Tcomplex64): + case X(Tint16,Tcomplex80): + e = el_una(OPs16_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tint16,Timaginary32): + case X(Tint16,Timaginary64): + case X(Tint16,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tuns16,Tint8): + case X(Tuns16,Tuns8): eop = OP16_8; goto Leop; + case X(Tuns16,Tint16): goto Lpaint; + case X(Tuns16,Tint32): + case X(Tuns16,Tuns32): eop = OPu16_32; goto Leop; + case X(Tuns16,Tint64): + case X(Tuns16,Tuns64): + case X(Tuns16,Tfloat64): + case X(Tuns16,Tfloat32): + case X(Tuns16,Tfloat80): + case X(Tuns16,Tcomplex32): + case X(Tuns16,Tcomplex64): + case X(Tuns16,Tcomplex80): + e = el_una(OPu16_32, TYuint, e); + fty = Tuns32; + goto Lagain; + case X(Tuns16,Timaginary32): + case X(Tuns16,Timaginary64): + case X(Tuns16,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tint32,Tint8): + case X(Tint32,Tuns8): e = el_una(OP32_16, TYshort, e); + fty = Tint16; + goto Lagain; + case X(Tint32,Tint16): + case X(Tint32,Tuns16): eop = OP32_16; goto Leop; + case X(Tint32,Tuns32): goto Lpaint; + case X(Tint32,Tint64): + case X(Tint32,Tuns64): eop = OPs32_64; goto Leop; + case X(Tint32,Tfloat32): + case X(Tint32,Tfloat64): + case X(Tint32,Tfloat80): + case X(Tint32,Tcomplex32): + case X(Tint32,Tcomplex64): + case X(Tint32,Tcomplex80): + e = el_una(OPs32_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tint32,Timaginary32): + case X(Tint32,Timaginary64): + case X(Tint32,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tuns32,Tint8): + case X(Tuns32,Tuns8): e = el_una(OP32_16, TYshort, e); + fty = Tuns16; + goto Lagain; + case X(Tuns32,Tint16): + case X(Tuns32,Tuns16): eop = OP32_16; goto Leop; + case X(Tuns32,Tint32): goto Lpaint; + case X(Tuns32,Tint64): + case X(Tuns32,Tuns64): eop = OPu32_64; goto Leop; + case X(Tuns32,Tfloat32): + case X(Tuns32,Tfloat64): + case X(Tuns32,Tfloat80): + case X(Tuns32,Tcomplex32): + case X(Tuns32,Tcomplex64): + case X(Tuns32,Tcomplex80): + e = el_una(OPu32_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tuns32,Timaginary32): + case X(Tuns32,Timaginary64): + case X(Tuns32,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tint64,Tint8): + case X(Tint64,Tuns8): + case X(Tint64,Tint16): + case X(Tint64,Tuns16): e = el_una(OP64_32, TYint, e); + fty = Tint32; + goto Lagain; + case X(Tint64,Tint32): + case X(Tint64,Tuns32): eop = OP64_32; goto Leop; + case X(Tint64,Tuns64): goto Lpaint; + case X(Tint64,Tfloat32): + case X(Tint64,Tfloat64): + case X(Tint64,Tfloat80): + case X(Tint64,Tcomplex32): + case X(Tint64,Tcomplex64): + case X(Tint64,Tcomplex80): + e = el_una(OPs64_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tint64,Timaginary32): + case X(Tint64,Timaginary64): + case X(Tint64,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tuns64,Tint8): + case X(Tuns64,Tuns8): + case X(Tuns64,Tint16): + case X(Tuns64,Tuns16): e = el_una(OP64_32, TYint, e); + fty = Tint32; + goto Lagain; + case X(Tuns64,Tint32): + case X(Tuns64,Tuns32): eop = OP64_32; goto Leop; + case X(Tuns64,Tint64): goto Lpaint; + case X(Tuns64,Tfloat32): + case X(Tuns64,Tfloat64): + case X(Tuns64,Tfloat80): + case X(Tuns64,Tcomplex32): + case X(Tuns64,Tcomplex64): + case X(Tuns64,Tcomplex80): + e = el_una(OPu64_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tuns64,Timaginary32): + case X(Tuns64,Timaginary64): + case X(Tuns64,Timaginary80): goto Lzero; + + /* ============================= */ + + case X(Tfloat32,Tint8): + case X(Tfloat32,Tuns8): + case X(Tfloat32,Tint16): + case X(Tfloat32,Tuns16): + case X(Tfloat32,Tint32): + case X(Tfloat32,Tuns32): + case X(Tfloat32,Tint64): + case X(Tfloat32,Tuns64): + case X(Tfloat32,Tfloat80): e = el_una(OPf_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tfloat32,Tfloat64): eop = OPf_d; goto Leop; + case X(Tfloat32,Timaginary32): goto Lzero; + case X(Tfloat32,Timaginary64): goto Lzero; + case X(Tfloat32,Timaginary80): goto Lzero; + case X(Tfloat32,Tcomplex32): + case X(Tfloat32,Tcomplex64): + case X(Tfloat32,Tcomplex80): + e = el_bin(OPadd,TYcfloat,el_long(TYifloat,0),e); + fty = Tcomplex32; + goto Lagain; + + /* ============================= */ + + case X(Tfloat64,Tint8): + case X(Tfloat64,Tuns8): e = el_una(OPd_s16, TYshort, e); + fty = Tint16; + goto Lagain; + case X(Tfloat64,Tint16): eop = OPd_s16; goto Leop; + case X(Tfloat64,Tuns16): eop = OPd_u16; goto Leop; + case X(Tfloat64,Tint32): eop = OPd_s32; goto Leop; + case X(Tfloat64,Tuns32): eop = OPd_u32; goto Leop; + case X(Tfloat64,Tint64): eop = OPd_s64; goto Leop; + case X(Tfloat64,Tuns64): eop = OPd_u64; goto Leop; + case X(Tfloat64,Tfloat32): eop = OPd_f; goto Leop; + case X(Tfloat64,Tfloat80): eop = OPd_ld; goto Leop; + case X(Tfloat64,Timaginary32): goto Lzero; + case X(Tfloat64,Timaginary64): goto Lzero; + case X(Tfloat64,Timaginary80): goto Lzero; + case X(Tfloat64,Tcomplex32): + case X(Tfloat64,Tcomplex64): + case X(Tfloat64,Tcomplex80): + e = el_bin(OPadd,TYcfloat,el_long(TYidouble,0),e); + fty = Tcomplex64; + goto Lagain; + + /* ============================= */ + + case X(Tfloat80,Tint8): + case X(Tfloat80,Tuns8): + case X(Tfloat80,Tint16): + case X(Tfloat80,Tuns16): + case X(Tfloat80,Tint32): + case X(Tfloat80,Tuns32): + case X(Tfloat80,Tint64): + case X(Tfloat80,Tfloat32): e = el_una(OPld_d, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tfloat80,Tuns64): + eop = OPld_u64; goto Leop; + case X(Tfloat80,Tfloat64): eop = OPld_d; goto Leop; + case X(Tfloat80,Timaginary32): goto Lzero; + case X(Tfloat80,Timaginary64): goto Lzero; + case X(Tfloat80,Timaginary80): goto Lzero; + case X(Tfloat80,Tcomplex32): + case X(Tfloat80,Tcomplex64): + case X(Tfloat80,Tcomplex80): + e = el_bin(OPadd,TYcldouble,e,el_long(TYildouble,0)); + fty = Tcomplex80; + goto Lagain; + + /* ============================= */ + + case X(Timaginary32,Tint8): + case X(Timaginary32,Tuns8): + case X(Timaginary32,Tint16): + case X(Timaginary32,Tuns16): + case X(Timaginary32,Tint32): + case X(Timaginary32,Tuns32): + case X(Timaginary32,Tint64): + case X(Timaginary32,Tuns64): + case X(Timaginary32,Tfloat32): + case X(Timaginary32,Tfloat64): + case X(Timaginary32,Tfloat80): goto Lzero; + case X(Timaginary32,Timaginary64): eop = OPf_d; goto Leop; + case X(Timaginary32,Timaginary80): + e = el_una(OPf_d, TYidouble, e); + fty = Timaginary64; + goto Lagain; + case X(Timaginary32,Tcomplex32): + case X(Timaginary32,Tcomplex64): + case X(Timaginary32,Tcomplex80): + e = el_bin(OPadd,TYcfloat,el_long(TYfloat,0),e); + fty = Tcomplex32; + goto Lagain; + + /* ============================= */ + + case X(Timaginary64,Tint8): + case X(Timaginary64,Tuns8): + case X(Timaginary64,Tint16): + case X(Timaginary64,Tuns16): + case X(Timaginary64,Tint32): + case X(Timaginary64,Tuns32): + case X(Timaginary64,Tint64): + case X(Timaginary64,Tuns64): + case X(Timaginary64,Tfloat32): + case X(Timaginary64,Tfloat64): + case X(Timaginary64,Tfloat80): goto Lzero; + case X(Timaginary64,Timaginary32): eop = OPd_f; goto Leop; + case X(Timaginary64,Timaginary80): eop = OPd_ld; goto Leop; + case X(Timaginary64,Tcomplex32): + case X(Timaginary64,Tcomplex64): + case X(Timaginary64,Tcomplex80): + e = el_bin(OPadd,TYcdouble,el_long(TYdouble,0),e); + fty = Tcomplex64; + goto Lagain; + + /* ============================= */ + + case X(Timaginary80,Tint8): + case X(Timaginary80,Tuns8): + case X(Timaginary80,Tint16): + case X(Timaginary80,Tuns16): + case X(Timaginary80,Tint32): + case X(Timaginary80,Tuns32): + case X(Timaginary80,Tint64): + case X(Timaginary80,Tuns64): + case X(Timaginary80,Tfloat32): + case X(Timaginary80,Tfloat64): + case X(Timaginary80,Tfloat80): goto Lzero; + case X(Timaginary80,Timaginary32): e = el_una(OPf_d, TYidouble, e); + fty = Timaginary64; + goto Lagain; + case X(Timaginary80,Timaginary64): eop = OPld_d; goto Leop; + case X(Timaginary80,Tcomplex32): + case X(Timaginary80,Tcomplex64): + case X(Timaginary80,Tcomplex80): + e = el_bin(OPadd,TYcldouble,el_long(TYldouble,0),e); + fty = Tcomplex80; + goto Lagain; + + /* ============================= */ + + case X(Tcomplex32,Tint8): + case X(Tcomplex32,Tuns8): + case X(Tcomplex32,Tint16): + case X(Tcomplex32,Tuns16): + case X(Tcomplex32,Tint32): + case X(Tcomplex32,Tuns32): + case X(Tcomplex32,Tint64): + case X(Tcomplex32,Tuns64): + case X(Tcomplex32,Tfloat32): + case X(Tcomplex32,Tfloat64): + case X(Tcomplex32,Tfloat80): + e = el_una(OPc_r, TYfloat, e); + fty = Tfloat32; + goto Lagain; + case X(Tcomplex32,Timaginary32): + case X(Tcomplex32,Timaginary64): + case X(Tcomplex32,Timaginary80): + e = el_una(OPc_i, TYifloat, e); + fty = Timaginary32; + goto Lagain; + case X(Tcomplex32,Tcomplex64): + case X(Tcomplex32,Tcomplex80): + e = el_una(OPf_d, TYcdouble, e); + fty = Tcomplex64; + goto Lagain; + + /* ============================= */ + + case X(Tcomplex64,Tint8): + case X(Tcomplex64,Tuns8): + case X(Tcomplex64,Tint16): + case X(Tcomplex64,Tuns16): + case X(Tcomplex64,Tint32): + case X(Tcomplex64,Tuns32): + case X(Tcomplex64,Tint64): + case X(Tcomplex64,Tuns64): + case X(Tcomplex64,Tfloat32): + case X(Tcomplex64,Tfloat64): + case X(Tcomplex64,Tfloat80): + e = el_una(OPc_r, TYdouble, e); + fty = Tfloat64; + goto Lagain; + case X(Tcomplex64,Timaginary32): + case X(Tcomplex64,Timaginary64): + case X(Tcomplex64,Timaginary80): + e = el_una(OPc_i, TYidouble, e); + fty = Timaginary64; + goto Lagain; + case X(Tcomplex64,Tcomplex32): eop = OPd_f; goto Leop; + case X(Tcomplex64,Tcomplex80): eop = OPd_ld; goto Leop; + + /* ============================= */ + + case X(Tcomplex80,Tint8): + case X(Tcomplex80,Tuns8): + case X(Tcomplex80,Tint16): + case X(Tcomplex80,Tuns16): + case X(Tcomplex80,Tint32): + case X(Tcomplex80,Tuns32): + case X(Tcomplex80,Tint64): + case X(Tcomplex80,Tuns64): + case X(Tcomplex80,Tfloat32): + case X(Tcomplex80,Tfloat64): + case X(Tcomplex80,Tfloat80): + e = el_una(OPc_r, TYldouble, e); + fty = Tfloat80; + goto Lagain; + case X(Tcomplex80,Timaginary32): + case X(Tcomplex80,Timaginary64): + case X(Tcomplex80,Timaginary80): + e = el_una(OPc_i, TYildouble, e); + fty = Timaginary80; + goto Lagain; + case X(Tcomplex80,Tcomplex32): + case X(Tcomplex80,Tcomplex64): + e = el_una(OPld_d, TYcdouble, e); + fty = Tcomplex64; + goto Lagain; + + /* ============================= */ + + default: + if (fty == tty) + goto Lpaint; + //dump(0); + //printf("fty = %d, tty = %d, %d\n", fty, tty, t->ty); + error("e2ir: cannot cast %s of type %s to type %s", e1->toChars(), e1->type->toChars(), t->toChars()); + goto Lzero; + + Lzero: + e = el_long(ttym, 0); + break; + + Lpaint: + e->Ety = ttym; + break; + + Leop: + e = el_una(eop, ttym, e); + break; + } +Lret: + // Adjust for any type paints + t = type->toBasetype(); + e->Ety = t->totym(); + + el_setLoc(e,loc); + return e; +} + +elem *ArrayLengthExp::toElem(IRState *irs) +{ + elem *e = e1->toElem(irs); + e = el_una(I64 ? OP128_64 : OP64_32, type->totym(), e); + el_setLoc(e,loc); + return e; +} + +elem *SliceExp::toElem(IRState *irs) +{ + //printf("SliceExp::toElem()\n"); + Type *t1 = e1->type->toBasetype(); + elem *e = e1->toElem(irs); + if (lwr) + { + elem *einit = resolveLengthVar(lengthVar, &e, t1); + + unsigned sz = t1->nextOf()->size(); + + elem *elwr = lwr->toElem(irs); + elem *eupr = upr->toElem(irs); + + elem *elwr2 = el_same(&elwr); + + // Create an array reference where: + // length is (upr - lwr) + // pointer is (ptr + lwr*sz) + // Combine as (length pair ptr) + + if (irs->arrayBoundsCheck()) + { + // Checks (unsigned compares): + // upr <= array.length + // lwr <= upr + + elem *c1; + elem *c2; + elem *ea; + elem *eb; + elem *eupr2; + elem *elength; + + if (t1->ty == Tpointer) + { + // Just do lwr <= upr check + + eupr2 = el_same(&eupr); + eupr2->Ety = TYsize_t; // make sure unsigned comparison + c1 = el_bin(OPle, TYint, elwr2, eupr2); + c1 = el_combine(eupr, c1); + goto L2; + } + else if (t1->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)t1; + dinteger_t length = tsa->dim->toInteger(); + + elength = el_long(TYsize_t, length); + goto L1; + } + else if (t1->ty == Tarray) + { + if (lengthVar && !(lengthVar->storage_class & STCconst)) + elength = el_var(lengthVar->toSymbol()); + else + { + elength = e; + e = el_same(&elength); + elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, elength); + } + L1: + eupr2 = el_same(&eupr); + c1 = el_bin(OPle, TYint, eupr, elength); + eupr2->Ety = TYsize_t; // make sure unsigned comparison + c2 = el_bin(OPle, TYint, elwr2, eupr2); + c1 = el_bin(OPandand, TYint, c1, c2); // (c1 && c2) + + L2: + // Construct: (c1 || ModuleArray(line)) + Symbol *sassert; + + sassert = irs->blx->module->toModuleArray(); + ea = el_bin(OPcall,TYvoid,el_var(sassert), el_long(TYint, loc.linnum)); + eb = el_bin(OPoror,TYvoid,c1,ea); + elwr = el_combine(elwr, eb); + + elwr2 = el_copytree(elwr2); + eupr = el_copytree(eupr2); + } + } + + elem *eptr = array_toPtr(e1->type, e); + + elem *elength = el_bin(OPmin, TYsize_t, eupr, elwr2); + eptr = el_bin(OPadd, TYnptr, eptr, el_bin(OPmul, TYsize_t, el_copytree(elwr2), el_long(TYsize_t, sz))); + + e = el_pair(TYdarray, elength, eptr); + e = el_combine(elwr, e); + e = el_combine(einit, e); + } + else if (t1->ty == Tsarray) + { + e = sarray_toDarray(loc, t1, NULL, e); + } + el_setLoc(e,loc); + return e; +} + +elem *IndexExp::toElem(IRState *irs) +{ elem *e; + elem *n1 = e1->toElem(irs); + elem *eb = NULL; + + //printf("IndexExp::toElem() %s\n", toChars()); + Type *t1 = e1->type->toBasetype(); + if (t1->ty == Taarray) + { + // set to: + // *aaGetX(aa, keyti, valuesize, &key); + + TypeAArray *taa = (TypeAArray *)t1; + unsigned vsize = taa->next->size(); + Symbol *s; + + // n2 becomes the index, also known as the key + elem *n2 = e2->toElem(irs); + + /* Turn n2 into a pointer to the index. If it's an lvalue, + * take the address of it. If not, copy it to a temp and + * take the address of that. + */ + n2 = addressElem(n2, taa->index); + + elem *valuesize = el_long(TYsize_t, vsize); + //printf("valuesize: "); elem_print(valuesize); + if (modifiable) + { + n1 = el_una(OPaddr, TYnptr, n1); + s = taa->aaGetSymbol("GetX", 1); + } + else + { + s = taa->aaGetSymbol("GetRvalueX", 1); + } + //printf("taa->index = %s\n", taa->index->toChars()); + elem* keyti = taa->index->getInternalTypeInfo(NULL)->toElem(irs); + //keyti = taa->index->getTypeInfo(NULL)->toElem(irs); + //printf("keyti:\n"); + //elem_print(keyti); + elem* ep = el_params(n2, valuesize, keyti, n1, NULL); + e = el_bin(OPcall, TYnptr, el_var(s), ep); + if (irs->arrayBoundsCheck()) + { + elem *ea; + + elem *n = el_same(&e); + + // Construct: ((e || ModuleAssert(line)),n) + Symbol *sassert = irs->blx->module->toModuleArray(); + ea = el_bin(OPcall,TYvoid,el_var(sassert), + el_long(TYint, loc.linnum)); + e = el_bin(OPoror,TYvoid,e,ea); + e = el_bin(OPcomma, TYnptr, e, n); + } + e = el_una(OPind, type->totym(), e); + if (tybasic(e->Ety) == TYstruct) + e->ET = type->toCtype(); + } + else + { + elem *einit = resolveLengthVar(lengthVar, &n1, t1); + elem *n2 = e2->toElem(irs); + + if (irs->arrayBoundsCheck()) + { + elem *elength; + elem *n2x; + elem *ea; + + if (t1->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)t1; + dinteger_t length = tsa->dim->toInteger(); + + elength = el_long(TYsize_t, length); + goto L1; + } + else if (t1->ty == Tarray) + { + elength = n1; + n1 = el_same(&elength); + elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, elength); + L1: + n2x = n2; + n2 = el_same(&n2x); + n2x = el_bin(OPlt, TYint, n2x, elength); + + // Construct: (n2x || ModuleAssert(line)) + Symbol *sassert; + + sassert = irs->blx->module->toModuleArray(); + ea = el_bin(OPcall,TYvoid,el_var(sassert), + el_long(TYint, loc.linnum)); + eb = el_bin(OPoror,TYvoid,n2x,ea); + } + } + + n1 = array_toPtr(t1, n1); + + { + elem *escale = el_long(TYsize_t, t1->nextOf()->size()); + n2 = el_bin(OPmul, TYsize_t, n2, escale); + e = el_bin(OPadd, TYnptr, n1, n2); + e = el_una(OPind, type->totym(), e); + if (tybasic(e->Ety) == TYstruct || tybasic(e->Ety) == TYarray) + { e->Ety = TYstruct; + e->ET = type->toCtype(); + } + } + + eb = el_combine(einit, eb); + e = el_combine(eb, e); + } + el_setLoc(e,loc); + return e; +} + + +elem *TupleExp::toElem(IRState *irs) +{ elem *e = NULL; + + //printf("TupleExp::toElem() %s\n", toChars()); + for (size_t i = 0; i < exps->dim; i++) + { Expression *el = exps->tdata()[i]; + elem *ep = el->toElem(irs); + + e = el_combine(e, ep); + } + return e; +} + +#if DMDV2 +elem *tree_insert(Elems *args, int low, int high) +{ + assert(low < high); + if (low + 1 == high) + return args->tdata()[low]; + int mid = (low + high) >> 1; + return el_param(tree_insert(args, low, mid), + tree_insert(args, mid, high)); +} +#endif + +elem *ArrayLiteralExp::toElem(IRState *irs) +{ elem *e; + size_t dim; + elem *earg = NULL; + + //printf("ArrayLiteralExp::toElem() %s, type = %s\n", toChars(), type->toChars()); + Type *tb = type->toBasetype(); + if (elements) + { + /* Instead of passing the initializers on the stack, allocate the + * array and assign the members inline. + * Avoids the whole variadic arg mess. + */ + dim = elements->dim; + Elems args; + args.setDim(dim); // +1 for number of args parameter + e = el_long(TYsize_t, dim); + e = el_param(e, type->getTypeInfo(NULL)->toElem(irs)); + // call _d_arrayliteralTX(ti, dim) + e = el_bin(OPcall,TYnptr,el_var(rtlsym[RTLSYM_ARRAYLITERALTX]),e); + Symbol *stmp = symbol_genauto(Type::tvoid->pointerTo()->toCtype()); + e = el_bin(OPeq,TYnptr,el_var(stmp),e); + + targ_size_t sz = tb->nextOf()->size(); // element size + ::type *te = tb->nextOf()->toCtype(); // element type + for (size_t i = 0; i < dim; i++) + { Expression *el = elements->tdata()[i]; + + /* Generate: *(stmp + i * sz) = element[i] + */ + elem *ep = el->toElem(irs); + elem *ev = el_var(stmp); + ev = el_bin(OPadd, TYnptr, ev, el_long(TYsize_t, i * sz)); + ev = el_una(OPind, te->Tty, ev); + elem *eeq = el_bin(OPeq,te->Tty,ev,ep); + + if (tybasic(te->Tty) == TYstruct) + { + eeq->Eoper = OPstreq; + eeq->ET = te; + } + else if (tybasic(te->Tty) == TYarray) + { + eeq->Eoper = OPstreq; + eeq->Ejty = eeq->Ety = TYstruct; + eeq->ET = te; + } + args.tdata()[i] = eeq; + } + e = el_combine(e, el_combines((void **)args.tdata(), dim)); + e = el_combine(e, el_var(stmp)); + } + else + { dim = 0; + e = el_long(TYsize_t, 0); + } + if (tb->ty == Tarray) + { + e = el_pair(TYdarray, el_long(TYsize_t, dim), e); + } + else if (tb->ty == Tpointer) + { + } + else + { + e = el_una(OPind,TYstruct,e); + e->ET = type->toCtype(); + } + + el_setLoc(e,loc); + e = el_combine(earg, e); + return e; +} + +/************************************************* + * Allocate a static array, and initialize its members with + * exps[]. + * Return the initialization expression, and the symbol for the static array in *psym. + */ +elem *ExpressionsToStaticArray(IRState *irs, Loc loc, Expressions *exps, Type *telem, symbol **psym) +{ + // Create a static array of type telem[dim] + size_t dim = exps->dim; + Type *tsarray = new TypeSArray(telem, new IntegerExp(loc, dim, Type::tsize_t)); + tsarray = tsarray->semantic(loc, NULL); + symbol *stmp = symbol_genauto(tsarray->toCtype()); + targ_size_t szelem = telem->size(); + + Elems elems; + elems.setDim(dim); + + ::type *te = telem->toCtype(); // stmp[] element type + + for (size_t i = 0; i < dim; i++) + { Expression *el = exps->tdata()[i]; + + /* Generate: *(&stmp + i * szelem) = element[i] + */ + elem *ep = el->toElem(irs); + elem *ev = el_ptr(stmp); + ev = el_bin(OPadd, TYnptr, ev, el_long(TYsize_t, i * szelem)); + ev = el_una(OPind, te->Tty, ev); + elem *eeq = el_bin(OPeq,te->Tty,ev,ep); + + if (tybasic(te->Tty) == TYstruct) + { + eeq->Eoper = OPstreq; + eeq->ET = te; + } + else if (tybasic(te->Tty) == TYarray) + { + eeq->Eoper = OPstreq; + eeq->Ejty = eeq->Ety = TYstruct; + eeq->ET = te; + } + elems.tdata()[i] = eeq; + } + + *psym = stmp; + return el_combines((void **)elems.tdata(), dim); +} + +elem *AssocArrayLiteralExp::toElem(IRState *irs) +{ + //printf("AssocArrayLiteralExp::toElem() %s\n", toChars()); + size_t dim = keys->dim; + elem *e; + + // call _d_assocarrayliteralTX(TypeInfo_AssociativeArray ti, void[] keys, void[] values) + // Prefer this to avoid the varargs fiasco in 64 bit code + Type *t = type->toBasetype()->mutableOf(); + assert(t->ty == Taarray); + TypeAArray *ta = (TypeAArray *)t; + + symbol *skeys; + elem *ekeys = ExpressionsToStaticArray(irs, loc, keys, ta->index, &skeys); + + symbol *svalues; + elem *evalues = ExpressionsToStaticArray(irs, loc, values, ta->nextOf(), &svalues); + + e = el_params(el_pair(TYdarray, el_long(TYsize_t, dim), el_ptr(svalues)), + el_pair(TYdarray, el_long(TYsize_t, dim), el_ptr(skeys )), + ta->getTypeInfo(NULL)->toElem(irs), + NULL); + + // call _d_assocarrayliteralTX(ti, keys, values) + e = el_bin(OPcall,TYnptr,el_var(rtlsym[RTLSYM_ASSOCARRAYLITERALTX]),e); + el_setLoc(e,loc); + + e = el_combine(evalues, e); + e = el_combine(ekeys, e); + + return e; +} + + +/******************************************* + * Generate elem to zero fill contents of Symbol stmp + * from *poffset..offset2. + * May store anywhere from 0..maxoff, as this function + * tries to use aligned int stores whereever possible. + * Update *poffset to end of initialized hole; *poffset will be >= offset2. + */ + +elem *fillHole(Symbol *stmp, size_t *poffset, size_t offset2, size_t maxoff) +{ elem *e = NULL; + int basealign = 1; + + while (*poffset < offset2) + { tym_t ty; + elem *e1; + + if (tybasic(stmp->Stype->Tty) == TYnptr) + e1 = el_var(stmp); + else + e1 = el_ptr(stmp); + if (basealign) + *poffset &= ~3; + basealign = 1; + size_t sz = maxoff - *poffset; + switch (sz) + { case 1: ty = TYchar; break; + case 2: ty = TYshort; break; + case 3: + ty = TYshort; + basealign = 0; + break; + default: + ty = TYlong; + break; + } + e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, *poffset)); + e1 = el_una(OPind, ty, e1); + e1 = el_bin(OPeq, ty, e1, el_long(ty, 0)); + e = el_combine(e, e1); + *poffset += tysize[ty]; + } + return e; +} + +elem *StructLiteralExp::toElem(IRState *irs) +{ elem *e; + size_t dim; + + //printf("StructLiteralExp::toElem() %s\n", toChars()); + + // struct symbol to initialize with the literal + Symbol *stmp = sym ? sym : symbol_genauto(sd->type->toCtype()); + + e = NULL; + + if (fillHoles) + { + /* Initialize all alignment 'holes' to zero. + * Do before initializing fields, as the hole filling process + * can spill over into the fields. + */ + size_t offset = 0; + for (size_t i = 0; i < sd->fields.dim; i++) + { + Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + + e = el_combine(e, fillHole(stmp, &offset, v->offset, sd->structsize)); + size_t vend = v->offset + v->type->size(); + if (offset < vend) + offset = vend; + } + e = el_combine(e, fillHole(stmp, &offset, sd->structsize, sd->structsize)); + } + + if (elements) + { + dim = elements->dim; + assert(dim <= sd->fields.dim); + for (size_t i = 0; i < dim; i++) + { Expression *el = elements->tdata()[i]; + if (!el) + continue; + + Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + assert(!v->isThisDeclaration()); + + elem *e1; + if (tybasic(stmp->Stype->Tty) == TYnptr) + { e1 = el_var(stmp); + e1->EV.sp.Voffset = soffset; + } + else + { e1 = el_ptr(stmp); + if (soffset) + e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, soffset)); + } + e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, v->offset)); + elem *ec = e1; // pointer to destination + + elem *ep = el->toElem(irs); + + Type *t1b = v->type->toBasetype(); + Type *t2b = el->type->toBasetype(); + if (t1b->ty == Tsarray) + { + if (t2b->implicitConvTo(t1b)) + { +#if DMDV2 + // Determine if postblit is needed + int postblit = 0; + if (needsPostblit(t1b)) + postblit = 1; + + if (postblit) + { + /* Generate: + * _d_arrayctor(ti, From: ep, To: e1) + */ + Expression *ti = t1b->nextOf()->toBasetype()->getTypeInfo(NULL); + elem *esize = el_long(TYsize_t, ((TypeSArray *)t1b)->dim->toInteger()); + e1 = el_pair(TYdarray, esize, e1); + ep = el_pair(TYdarray, el_copytree(esize), array_toPtr(el->type, ep)); + ep = el_params(e1, ep, ti->toElem(irs), NULL); + int rtl = RTLSYM_ARRAYCTOR; + e1 = el_bin(OPcall, type->totym(), el_var(rtlsym[rtl]), ep); + } + else +#endif + { + elem *esize = el_long(TYsize_t, t1b->size()); + ep = array_toPtr(el->type, ep); + e1 = el_bin(OPmemcpy, TYnptr, e1, el_param(ep, esize)); + } + } + else + { + elem *edim = el_long(TYsize_t, t1b->size() / t2b->size()); + e1 = setArray(e1, edim, t2b, ep, irs, TOKconstruct); + } + } + else + { + tym_t ty = v->type->totym(); + e1 = el_una(OPind, ty, e1); + if (tybasic(ty) == TYstruct) + e1->ET = v->type->toCtype(); + e1 = el_bin(OPeq, ty, e1, ep); + if (tybasic(ty) == TYstruct) + { e1->Eoper = OPstreq; + e1->ET = v->type->toCtype(); + } +#if DMDV2 + /* Call postblit() on e1 + */ + StructDeclaration *sd = needsPostblit(v->type); + if (sd) + { FuncDeclaration *fd = sd->postblit; + ec = el_copytree(ec); + ec = callfunc(loc, irs, 1, Type::tvoid, ec, sd->type->pointerTo(), fd, fd->type, NULL, NULL); + e1 = el_bin(OPcomma, ec->Ety, e1, ec); + } +#endif + } + e = el_combine(e, e1); + } + } + +#if DMDV2 + if (sd->isnested) + { // Initialize the hidden 'this' pointer + assert(sd->fields.dim); + Dsymbol *s = sd->fields.tdata()[sd->fields.dim - 1]; + ThisDeclaration *v = s->isThisDeclaration(); + assert(v); + + elem *e1; + if (tybasic(stmp->Stype->Tty) == TYnptr) + { e1 = el_var(stmp); + e1->EV.sp.Voffset = soffset; + } + else + { e1 = el_ptr(stmp); + if (soffset) + e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, soffset)); + } + e1 = setEthis(loc, irs, e1, sd); + + e = el_combine(e, e1); + } +#endif + + elem *ev = el_var(stmp); + ev->ET = sd->type->toCtype(); + e = el_combine(e, ev); + el_setLoc(e,loc); + return e; +} + +/******************************************** + * Add destructors + */ + +elem *appendDtors(IRState *irs, elem *er, size_t starti, size_t endi) +{ + //printf("appendDtors(%d .. %d)\n", starti, endi); + + /* Code gen can be improved by determining if no exceptions can be thrown + * between the OPdctor and OPddtor, and eliminating the OPdctor and OPddtor. + */ + + /* Build edtors, an expression that calls destructors on all the variables + * going out of the scope starti..endi + */ + elem *edtors = NULL; + for (size_t i = starti; i != endi; ++i) + { + VarDeclaration *vd = irs->varsInScope->tdata()[i]; + if (vd) + { + //printf("appending dtor\n"); + irs->varsInScope->tdata()[i] = NULL; + elem *ed = vd->edtor->toElem(irs); + ed = el_ddtor(ed, vd); + edtors = el_combine(ed, edtors); // execute in reverse order + } + } + + if (edtors) + { +#if TARGET_WINDOS + Blockx *blx = irs->blx; + nteh_declarvars(blx); +#endif + /* Append edtors to er, while preserving the value of er + */ + if (tybasic(er->Ety) == TYvoid) + { /* No value to preserve, so simply append + */ + er = el_combine(er, edtors); + } + else + { + elem **pe; + for (pe = &er; (*pe)->Eoper == OPcomma; pe = &(*pe)->E2) + ; + elem *erx = *pe; + + if (erx->Eoper == OPconst || erx->Eoper == OPrelconst) + { + *pe = el_combine(edtors, erx); + } + else if (tybasic(erx->Ety) == TYstruct || tybasic(erx->Ety) == TYarray) + { + /* Expensive to copy, to take a pointer to it instead + */ + elem *ep = el_una(OPaddr, TYnptr, erx); + elem *e = el_same(&ep); + ep = el_combine(ep, edtors); + ep = el_combine(ep, e); + e = el_una(OPind, erx->Ety, ep); + e->ET = erx->ET; + *pe = e; + } + else + { + elem *e = el_same(&erx); + erx = el_combine(erx, edtors); + *pe = el_combine(erx, e); + } + } + } + return er; +} + diff --git a/eh.c b/eh.c new file mode 100644 index 00000000..2896b745 --- /dev/null +++ b/eh.c @@ -0,0 +1,344 @@ +/* + * Copyright (c) 1994-1998 by Symantec + * Copyright (c) 2000-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * http://www.dsource.org/projects/dmd/browser/branches/dmd-1.x/src/eh.c + * http://www.dsource.org/projects/dmd/browser/trunk/src/eh.c + * Written by Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Support for D exception handling + +#include +#include +#include +#include + +#include "cc.h" +#include "el.h" +#include "code.h" +#include "oper.h" +#include "global.h" +#include "type.h" +#include "dt.h" +#include "exh.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/* If we do our own EH tables and stack walking scheme + * (Otherwise use NT Structured Exception Handling) + */ +#define OUREH (TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS) + + +/**************************** + * Generate and output scope table. + */ + +symbol *except_gentables() +{ + //printf("except_gentables()\n"); +#if OUREH + + // BUG: alloca() changes the stack size, which is not reflected + // in the fixed eh tables. + assert(!usedalloca); + + symbol *s = symbol_generate(SCstatic,tsint); + s->Sseg = UNKNOWN; + symbol_keep(s); + symbol_debug(s); + + except_fillInEHTable(s); + + outdata(s); // output the scope table + + obj_ehtables(funcsym_p,funcsym_p->Ssize,s); +#endif + return NULL; +} + +/********************************************** + * Initializes the symbol s with the contents of the exception handler table. + */ + +struct Guard +{ +#if OUREH + unsigned offset; // offset of start of guarded section (Linux) + unsigned endoffset; // ending offset of guarded section (Linux) +#endif + int last_index; // previous index (enclosing guarded section) + unsigned catchoffset; // offset to catch block from symbol + void *finally; // finally code to execute +}; + +void except_fillInEHTable(symbol *s) +{ + unsigned fsize = NPTRSIZE; // target size of function pointer + dt_t **pdt = &s->Sdt; + + /* + void* pointer to start of function + unsigned offset of ESP from EBP + unsigned offset from start of function to return code + unsigned nguards; // dimension of guard[] (Linux) + Guard guard[]; // sorted such that the enclosing guarded sections come first + catchoffset: + unsigned ncatches; // number of catch blocks + { void *type; // symbol representing type + unsigned bpoffset; // EBP offset of catch variable + void *handler; // catch handler code + } catch[]; + */ + +/* Be careful of this, as we need the sizeof Guard on the target, not + * in the compiler. + */ +#if OUREH +#define GUARD_SIZE (I64 ? 3*8 : 5*4) // sizeof(Guard) +#else +#define GUARD_SIZE (sizeof(Guard)) +#endif + + int sz = 0; + + // Address of start of function + symbol_debug(funcsym_p); + pdt = dtxoff(pdt,funcsym_p,0,TYnptr); + sz += fsize; + + //printf("ehtables: func = %s, offset = x%x, startblock->Boffset = x%x\n", funcsym_p->Sident, funcsym_p->Soffset, startblock->Boffset); + + // Get offset of ESP from EBP + long spoff = cod3_spoff(); + pdt = dtdword(pdt,spoff); + sz += 4; + + // Offset from start of function to return code + pdt = dtdword(pdt,retoffset); + sz += 4; + + // First, calculate starting catch offset + int guarddim = 0; // max dimension of guard[] + int ndctors = 0; // number of ESCdctor's + for (block *b = startblock; b; b = b->Bnext) + { + if (b->BC == BC_try && b->Bscope_index >= guarddim) + guarddim = b->Bscope_index + 1; +// printf("b->BC = %2d, Bscope_index = %2d, last_index = %2d, offset = x%x\n", +// b->BC, b->Bscope_index, b->Blast_index, b->Boffset); + if (usednteh & EHcleanup) + for (code *c = b->Bcode; c; c = code_next(c)) + { + if (c->Iop == (ESCAPE | ESCddtor)) + ndctors++; + } + } + //printf("guarddim = %d, ndctors = %d\n", guarddim, ndctors); + +#if OUREH + pdt = dtsize_t(pdt,guarddim + ndctors); + sz += NPTRSIZE; +#endif + + unsigned catchoffset = sz + (guarddim + ndctors) * GUARD_SIZE; + + // Generate guard[] + int i = 0; + for (block *b = startblock; b; b = b->Bnext) + { + //printf("b = %p, b->Btry = %p, b->offset = %x\n", b, b->Btry, b->Boffset); + if (b->BC == BC_try) + { + assert(b->Bscope_index >= i); + if (i < b->Bscope_index) + { int fillsize = (b->Bscope_index - i) * GUARD_SIZE; + pdt = dtnzeros(pdt, fillsize); + sz += fillsize; + } + i = b->Bscope_index + 1; + + int nsucc = list_nitems(b->Bsucc); + +#if OUREH + //printf("DHandlerInfo: offset = %x", (int)(b->Boffset - startblock->Boffset)); + pdt = dtdword(pdt,b->Boffset - startblock->Boffset); // offset to start of block + + // Compute ending offset + unsigned endoffset; + for (block *bn = b->Bnext; 1; bn = bn->Bnext) + { + //printf("\tbn = %p, bn->Btry = %p, bn->offset = %x\n", bn, bn->Btry, bn->Boffset); + assert(bn); + if (bn->Btry == b->Btry) + { endoffset = bn->Boffset - startblock->Boffset; + break; + } + } + //printf(" endoffset = %x, prev_index = %d\n", endoffset, b->Blast_index); + pdt = dtdword(pdt,endoffset); // offset past end of guarded block +#endif + + pdt = dtdword(pdt,b->Blast_index); // parent index + + if (b->jcatchvar) // if try-catch + { + pdt = dtdword(pdt,catchoffset); + pdt = dtsize_t(pdt,0); // no finally handler + + catchoffset += NPTRSIZE + (nsucc - 1) * (3 * NPTRSIZE); + } + else // else try-finally + { + assert(nsucc == 2); + pdt = dtdword(pdt,0); // no catch offset + block *bhandler = list_block(list_next(b->Bsucc)); + assert(bhandler->BC == BC_finally); + // To successor of BC_finally block + bhandler = list_block(bhandler->Bsucc); +#if OUREH + pdt = dtxoff(pdt,funcsym_p,bhandler->Boffset - startblock->Boffset, TYnptr); // finally handler address +#else + pdt = dtcoff(pdt,bhandler->Boffset); // finally handler address +#endif + } + sz += GUARD_SIZE; + } + } + + /* Append to guard[] the guard blocks for temporaries that are created and destroyed + * within a single expression. These are marked by the special instruction pairs + * (ESCAPE | ESCdctor) and (ESCAPE | ESCddtor). + */ + if (usednteh & EHcleanup) + { + int scopeindex = guarddim; + for (block *b = startblock; b; b = b->Bnext) + { + /* Set up stack of scope indices + */ + #define STACKINC 16 + int stackbuf[STACKINC]; + int *stack = stackbuf; + int stackmax = STACKINC; + stack[0] = b->Btry ? b->Btry->Bscope_index : -1; + int stacki = 1; + + unsigned boffset = b->Boffset; + for (code *c = b->Bcode; c; c = code_next(c)) + { + if (c->Iop == (ESCAPE | ESCdctor)) + { + code *c2 = code_next(c); + if (config.flags2 & CFG2seh) + c2->IEV2.Vsize_t = scopeindex; +#if OUREH + pdt = dtdword(pdt,boffset - startblock->Boffset); // guard offset +#endif + // Find corresponding ddtor instruction + int n = 0; + unsigned eoffset = boffset; + unsigned foffset; + for (; 1; c2 = code_next(c2)) + { + assert(c2); + if (c2->Iop == (ESCAPE | ESCddtor)) + { + if (n) + n--; + else + { + foffset = eoffset; + code *cf = code_next(c2); + if (config.flags2 & CFG2seh) + { cf->IEV2.Vsize_t = stack[stacki - 1]; + foffset += calccodsize(cf); + cf = code_next(cf); + } + foffset += calccodsize(cf); + while (cf->Iop != JMP && cf->Iop != JMPS) + { + cf = code_next(cf); + foffset += calccodsize(cf); + } + cf = code_next(cf); + foffset += calccodsize(cf); +#if OUREH + pdt = dtdword(pdt,eoffset - startblock->Boffset); // guard offset +#endif + break; + } + } + else if (c2->Iop == (ESCAPE | ESCdctor)) + { + n++; + } + else + eoffset += calccodsize(c2); + } + //printf("boffset = %x, eoffset = %x, foffset = %x\n", boffset, eoffset, foffset); + pdt = dtdword(pdt,stack[stacki - 1]); // parent index + pdt = dtdword(pdt,0); // no catch offset +#if OUREH + pdt = dtxoff(pdt,funcsym_p,foffset - startblock->Boffset, TYnptr); // finally handler offset +#else + pdt = dtcoff(pdt,foffset); // finally handler address +#endif + if (stacki == stackmax) + { // stack[] is out of space; enlarge it + int *pi = (int *)alloca((stackmax + STACKINC) * sizeof(int)); + assert(pi); + memcpy(pi, stack, stackmax * sizeof(int)); + stack = pi; + stackmax += STACKINC; + } + stack[stacki++] = scopeindex; + ++scopeindex; + sz += GUARD_SIZE; + } + else if (c->Iop == (ESCAPE | ESCddtor)) + { + stacki--; + assert(stacki != 0); + } + boffset += calccodsize(c); + } + } + } + + // Generate catch[] + for (block *b = startblock; b; b = b->Bnext) + { + if (b->BC == BC_try && b->jcatchvar) // if try-catch + { + int nsucc = list_nitems(b->Bsucc); + pdt = dtsize_t(pdt,nsucc - 1); // # of catch blocks + sz += NPTRSIZE; + + for (list_t bl = list_next(b->Bsucc); bl; bl = list_next(bl)) + { + block *bcatch = list_block(bl); + + pdt = dtxoff(pdt,bcatch->Bcatchtype,0,TYjhandle); + + pdt = dtsize_t(pdt,cod3_bpoffset(b->jcatchvar)); // EBP offset + +#if OUREH + pdt = dtxoff(pdt,funcsym_p,bcatch->Boffset - startblock->Boffset, TYnptr); // catch handler address +#else + pdt = dtcoff(pdt,bcatch->Boffset); // catch handler address +#endif + sz += 3 * NPTRSIZE; + } + } + } + assert(sz != 0); +} + diff --git a/entity.c b/entity.c new file mode 100644 index 00000000..98b81141 --- /dev/null +++ b/entity.c @@ -0,0 +1,2391 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include + +/********************************************* + * Convert from named entity to its encoding. + * For reference: + * http://www.htmlhelp.com/reference/html40/entities/ + * http://www.w3.org/2003/entities/2007/w3centities-f.ent + */ + +struct NameId +{ + const char *name; + unsigned value; +}; + +static NameId namesA[]={ + "Aacgr", 0x00386, // GREEK CAPITAL LETTER ALPHA WITH TONOS + "aacgr", 0x003AC, // GREEK SMALL LETTER ALPHA WITH TONOS + "Aacute", 0x000C1, // LATIN CAPITAL LETTER A WITH ACUTE + "aacute", 0x000E1, // LATIN SMALL LETTER A WITH ACUTE + "Abreve", 0x00102, // LATIN CAPITAL LETTER A WITH BREVE + "abreve", 0x00103, // LATIN SMALL LETTER A WITH BREVE + "ac", 0x0223E, // INVERTED LAZY S + "acd", 0x0223F, // SINE WAVE +// "acE", 0x0223E;0x00333, // INVERTED LAZY S with double underline + "Acirc", 0x000C2, // LATIN CAPITAL LETTER A WITH CIRCUMFLEX + "acirc", 0x000E2, // LATIN SMALL LETTER A WITH CIRCUMFLEX + "acute", 0x000B4, // ACUTE ACCENT + "Acy", 0x00410, // CYRILLIC CAPITAL LETTER A + "acy", 0x00430, // CYRILLIC SMALL LETTER A + "AElig", 0x000C6, // LATIN CAPITAL LETTER AE + "aelig", 0x000E6, // LATIN SMALL LETTER AE + "af", 0x02061, // FUNCTION APPLICATION + "Afr", 0x1D504, // MATHEMATICAL FRAKTUR CAPITAL A + "afr", 0x1D51E, // MATHEMATICAL FRAKTUR SMALL A + "Agr", 0x00391, // GREEK CAPITAL LETTER ALPHA + "agr", 0x003B1, // GREEK SMALL LETTER ALPHA + "Agrave", 0x000C0, // LATIN CAPITAL LETTER A WITH GRAVE + "agrave", 0x000E0, // LATIN SMALL LETTER A WITH GRAVE + "alefsym", 0x02135, // ALEF SYMBOL + "aleph", 0x02135, // ALEF SYMBOL + "Alpha", 0x00391, // GREEK CAPITAL LETTER ALPHA + "alpha", 0x003B1, // GREEK SMALL LETTER ALPHA + "Amacr", 0x00100, // LATIN CAPITAL LETTER A WITH MACRON + "amacr", 0x00101, // LATIN SMALL LETTER A WITH MACRON + "amalg", 0x02A3F, // AMALGAMATION OR COPRODUCT + "amp", 0x00026, // AMPERSAND + "AMP", 0x00026, // AMPERSAND + "and", 0x02227, // LOGICAL AND + "And", 0x02A53, // DOUBLE LOGICAL AND + "andand", 0x02A55, // TWO INTERSECTING LOGICAL AND + "andd", 0x02A5C, // LOGICAL AND WITH HORIZONTAL DASH + "andslope", 0x02A58, // SLOPING LARGE AND + "andv", 0x02A5A, // LOGICAL AND WITH MIDDLE STEM + "ang", 0x02220, // ANGLE + "ange", 0x029A4, // ANGLE WITH UNDERBAR + "angle", 0x02220, // ANGLE + "angmsd", 0x02221, // MEASURED ANGLE + "angmsdaa", 0x029A8, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT + "angmsdab", 0x029A9, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT + "angmsdac", 0x029AA, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT + "angmsdad", 0x029AB, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT + "angmsdae", 0x029AC, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP + "angmsdaf", 0x029AD, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP + "angmsdag", 0x029AE, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN + "angmsdah", 0x029AF, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN + "angrt", 0x0221F, // RIGHT ANGLE + "angrtvb", 0x022BE, // RIGHT ANGLE WITH ARC + "angrtvbd", 0x0299D, // MEASURED RIGHT ANGLE WITH DOT + "angsph", 0x02222, // SPHERICAL ANGLE + "angst", 0x000C5, // LATIN CAPITAL LETTER A WITH RING ABOVE + "angzarr", 0x0237C, // RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW + "Aogon", 0x00104, // LATIN CAPITAL LETTER A WITH OGONEK + "aogon", 0x00105, // LATIN SMALL LETTER A WITH OGONEK + "Aopf", 0x1D538, // MATHEMATICAL DOUBLE-STRUCK CAPITAL A + "aopf", 0x1D552, // MATHEMATICAL DOUBLE-STRUCK SMALL A + "ap", 0x02248, // ALMOST EQUAL TO + "apacir", 0x02A6F, // ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT + "ape", 0x0224A, // ALMOST EQUAL OR EQUAL TO + "apE", 0x02A70, // APPROXIMATELY EQUAL OR EQUAL TO + "apid", 0x0224B, // TRIPLE TILDE + "apos", 0x00027, // APOSTROPHE + "ApplyFunction", 0x02061, // FUNCTION APPLICATION + "approx", 0x02248, // ALMOST EQUAL TO + "approxeq", 0x0224A, // ALMOST EQUAL OR EQUAL TO + "Aring", 0x000C5, // LATIN CAPITAL LETTER A WITH RING ABOVE + "aring", 0x000E5, // LATIN SMALL LETTER A WITH RING ABOVE + "Ascr", 0x1D49C, // MATHEMATICAL SCRIPT CAPITAL A + "ascr", 0x1D4B6, // MATHEMATICAL SCRIPT SMALL A + "Assign", 0x02254, // COLON EQUALS + "ast", 0x0002A, // ASTERISK + "asymp", 0x02248, // ALMOST EQUAL TO + "asympeq", 0x0224D, // EQUIVALENT TO + "Atilde", 0x000C3, // LATIN CAPITAL LETTER A WITH TILDE + "atilde", 0x000E3, // LATIN SMALL LETTER A WITH TILDE + "Auml", 0x000C4, // LATIN CAPITAL LETTER A WITH DIAERESIS + "auml", 0x000E4, // LATIN SMALL LETTER A WITH DIAERESIS + "awconint", 0x02233, // ANTICLOCKWISE CONTOUR INTEGRAL + "awint", 0x02A11, // ANTICLOCKWISE INTEGRATION + NULL, 0 +}; + +static NameId namesB[]={ + "backcong", 0x0224C, // ALL EQUAL TO + "backepsilon", 0x003F6, // GREEK REVERSED LUNATE EPSILON SYMBOL + "backprime", 0x02035, // REVERSED PRIME + "backsim", 0x0223D, // REVERSED TILDE + "backsimeq", 0x022CD, // REVERSED TILDE EQUALS + "Backslash", 0x02216, // SET MINUS +// "b.alpha", 0x1D6C2, // MATHEMATICAL BOLD SMALL ALPHA + "Barv", 0x02AE7, // SHORT DOWN TACK WITH OVERBAR + "barvee", 0x022BD, // NOR + "barwed", 0x02305, // PROJECTIVE + "Barwed", 0x02306, // PERSPECTIVE + "barwedge", 0x02305, // PROJECTIVE +// "b.beta", 0x1D6C3, // MATHEMATICAL BOLD SMALL BETA + "bbrk", 0x023B5, // BOTTOM SQUARE BRACKET + "bbrktbrk", 0x023B6, // BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET +// "b.chi", 0x1D6D8, // MATHEMATICAL BOLD SMALL CHI + "bcong", 0x0224C, // ALL EQUAL TO + "Bcy", 0x00411, // CYRILLIC CAPITAL LETTER BE + "bcy", 0x00431, // CYRILLIC SMALL LETTER BE +// "b.Delta", 0x1D6AB, // MATHEMATICAL BOLD CAPITAL DELTA +// "b.delta", 0x1D6C5, // MATHEMATICAL BOLD SMALL DELTA + "bdquo", 0x0201E, // DOUBLE LOW-9 QUOTATION MARK + "becaus", 0x02235, // BECAUSE + "because", 0x02235, // BECAUSE + "Because", 0x02235, // BECAUSE + "bemptyv", 0x029B0, // REVERSED EMPTY SET + "bepsi", 0x003F6, // GREEK REVERSED LUNATE EPSILON SYMBOL +// "b.epsi", 0x1D6C6, // MATHEMATICAL BOLD SMALL EPSILON +// "b.epsiv", 0x1D6DC, // MATHEMATICAL BOLD EPSILON SYMBOL + "bernou", 0x0212C, // SCRIPT CAPITAL B + "Bernoullis", 0x0212C, // SCRIPT CAPITAL B + "Beta", 0x00392, // GREEK CAPITAL LETTER BETA + "beta", 0x003B2, // GREEK SMALL LETTER BETA +// "b.eta", 0x1D6C8, // MATHEMATICAL BOLD SMALL ETA + "beth", 0x02136, // BET SYMBOL + "between", 0x0226C, // BETWEEN + "Bfr", 0x1D505, // MATHEMATICAL FRAKTUR CAPITAL B + "bfr", 0x1D51F, // MATHEMATICAL FRAKTUR SMALL B +// "b.Gamma", 0x1D6AA, // MATHEMATICAL BOLD CAPITAL GAMMA +// "b.gamma", 0x1D6C4, // MATHEMATICAL BOLD SMALL GAMMA +// "b.Gammad", 0x1D7CA, // MATHEMATICAL BOLD CAPITAL DIGAMMA +// "b.gammad", 0x1D7CB, // MATHEMATICAL BOLD SMALL DIGAMMA + "Bgr", 0x00392, // GREEK CAPITAL LETTER BETA + "bgr", 0x003B2, // GREEK SMALL LETTER BETA + "bigcap", 0x022C2, // N-ARY INTERSECTION + "bigcirc", 0x025EF, // LARGE CIRCLE + "bigcup", 0x022C3, // N-ARY UNION + "bigodot", 0x02A00, // N-ARY CIRCLED DOT OPERATOR + "bigoplus", 0x02A01, // N-ARY CIRCLED PLUS OPERATOR + "bigotimes", 0x02A02, // N-ARY CIRCLED TIMES OPERATOR + "bigsqcup", 0x02A06, // N-ARY SQUARE UNION OPERATOR + "bigstar", 0x02605, // BLACK STAR + "bigtriangledown", 0x025BD, // WHITE DOWN-POINTING TRIANGLE + "bigtriangleup", 0x025B3, // WHITE UP-POINTING TRIANGLE + "biguplus", 0x02A04, // N-ARY UNION OPERATOR WITH PLUS + "bigvee", 0x022C1, // N-ARY LOGICAL OR + "bigwedge", 0x022C0, // N-ARY LOGICAL AND +// "b.iota", 0x1D6CA, // MATHEMATICAL BOLD SMALL IOTA +// "b.kappa", 0x1D6CB, // MATHEMATICAL BOLD SMALL KAPPA +// "b.kappav", 0x1D6DE, // MATHEMATICAL BOLD KAPPA SYMBOL + "bkarow", 0x0290D, // RIGHTWARDS DOUBLE DASH ARROW + "blacklozenge", 0x029EB, // BLACK LOZENGE + "blacksquare", 0x025AA, // BLACK SMALL SQUARE + "blacktriangle", 0x025B4, // BLACK UP-POINTING SMALL TRIANGLE + "blacktriangledown", 0x025BE, // BLACK DOWN-POINTING SMALL TRIANGLE + "blacktriangleleft", 0x025C2, // BLACK LEFT-POINTING SMALL TRIANGLE + "blacktriangleright", 0x025B8, // BLACK RIGHT-POINTING SMALL TRIANGLE +// "b.Lambda", 0x1D6B2, // MATHEMATICAL BOLD CAPITAL LAMDA +// "b.lambda", 0x1D6CC, // MATHEMATICAL BOLD SMALL LAMDA + "blank", 0x02423, // OPEN BOX + "blk12", 0x02592, // MEDIUM SHADE + "blk14", 0x02591, // LIGHT SHADE + "blk34", 0x02593, // DARK SHADE + "block", 0x02588, // FULL BLOCK +// "b.mu", 0x1D6CD, // MATHEMATICAL BOLD SMALL MU +// "bne", 0x0003D;0x020E5, // EQUALS SIGN with reverse slash +// "bnequiv", 0x02261;0x020E5, // IDENTICAL TO with reverse slash + "bnot", 0x02310, // REVERSED NOT SIGN + "bNot", 0x02AED, // REVERSED DOUBLE STROKE NOT SIGN +// "b.nu", 0x1D6CE, // MATHEMATICAL BOLD SMALL NU +// "b.Omega", 0x1D6C0, // MATHEMATICAL BOLD CAPITAL OMEGA +// "b.omega", 0x1D6DA, // MATHEMATICAL BOLD SMALL OMEGA + "Bopf", 0x1D539, // MATHEMATICAL DOUBLE-STRUCK CAPITAL B + "bopf", 0x1D553, // MATHEMATICAL DOUBLE-STRUCK SMALL B + "bot", 0x022A5, // UP TACK + "bottom", 0x022A5, // UP TACK + "bowtie", 0x022C8, // BOWTIE + "boxbox", 0x029C9, // TWO JOINED SQUARES + "boxdl", 0x02510, // BOX DRAWINGS LIGHT DOWN AND LEFT + "boxdL", 0x02555, // BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE + "boxDl", 0x02556, // BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE + "boxDL", 0x02557, // BOX DRAWINGS DOUBLE DOWN AND LEFT + "boxdr", 0x0250C, // BOX DRAWINGS LIGHT DOWN AND RIGHT + "boxdR", 0x02552, // BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE + "boxDr", 0x02553, // BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE + "boxDR", 0x02554, // BOX DRAWINGS DOUBLE DOWN AND RIGHT + "boxh", 0x02500, // BOX DRAWINGS LIGHT HORIZONTAL + "boxH", 0x02550, // BOX DRAWINGS DOUBLE HORIZONTAL + "boxhd", 0x0252C, // BOX DRAWINGS LIGHT DOWN AND HORIZONTAL + "boxHd", 0x02564, // BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE + "boxhD", 0x02565, // BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE + "boxHD", 0x02566, // BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL + "boxhu", 0x02534, // BOX DRAWINGS LIGHT UP AND HORIZONTAL + "boxHu", 0x02567, // BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE + "boxhU", 0x02568, // BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE + "boxHU", 0x02569, // BOX DRAWINGS DOUBLE UP AND HORIZONTAL + "boxminus", 0x0229F, // SQUARED MINUS + "boxplus", 0x0229E, // SQUARED PLUS + "boxtimes", 0x022A0, // SQUARED TIMES + "boxul", 0x02518, // BOX DRAWINGS LIGHT UP AND LEFT + "boxuL", 0x0255B, // BOX DRAWINGS UP SINGLE AND LEFT DOUBLE + "boxUl", 0x0255C, // BOX DRAWINGS UP DOUBLE AND LEFT SINGLE + "boxUL", 0x0255D, // BOX DRAWINGS DOUBLE UP AND LEFT + "boxur", 0x02514, // BOX DRAWINGS LIGHT UP AND RIGHT + "boxuR", 0x02558, // BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE + "boxUr", 0x02559, // BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE + "boxUR", 0x0255A, // BOX DRAWINGS DOUBLE UP AND RIGHT + "boxv", 0x02502, // BOX DRAWINGS LIGHT VERTICAL + "boxV", 0x02551, // BOX DRAWINGS DOUBLE VERTICAL + "boxvh", 0x0253C, // BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL + "boxvH", 0x0256A, // BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE + "boxVh", 0x0256B, // BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE + "boxVH", 0x0256C, // BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL + "boxvl", 0x02524, // BOX DRAWINGS LIGHT VERTICAL AND LEFT + "boxvL", 0x02561, // BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE + "boxVl", 0x02562, // BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE + "boxVL", 0x02563, // BOX DRAWINGS DOUBLE VERTICAL AND LEFT + "boxvr", 0x0251C, // BOX DRAWINGS LIGHT VERTICAL AND RIGHT + "boxvR", 0x0255E, // BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE + "boxVr", 0x0255F, // BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE + "boxVR", 0x02560, // BOX DRAWINGS DOUBLE VERTICAL AND RIGHT +// "b.Phi", 0x1D6BD, // MATHEMATICAL BOLD CAPITAL PHI +// "b.phi", 0x1D6D7, // MATHEMATICAL BOLD SMALL PHI +// "b.phiv", 0x1D6DF, // MATHEMATICAL BOLD PHI SYMBOL +// "b.Pi", 0x1D6B7, // MATHEMATICAL BOLD CAPITAL PI +// "b.pi", 0x1D6D1, // MATHEMATICAL BOLD SMALL PI +// "b.piv", 0x1D6E1, // MATHEMATICAL BOLD PI SYMBOL + "bprime", 0x02035, // REVERSED PRIME +// "b.Psi", 0x1D6BF, // MATHEMATICAL BOLD CAPITAL PSI +// "b.psi", 0x1D6D9, // MATHEMATICAL BOLD SMALL PSI + "breve", 0x002D8, // BREVE + "Breve", 0x002D8, // BREVE +// "b.rho", 0x1D6D2, // MATHEMATICAL BOLD SMALL RHO +// "b.rhov", 0x1D6E0, // MATHEMATICAL BOLD RHO SYMBOL + "brvbar", 0x000A6, // BROKEN BAR + "Bscr", 0x0212C, // SCRIPT CAPITAL B + "bscr", 0x1D4B7, // MATHEMATICAL SCRIPT SMALL B + "bsemi", 0x0204F, // REVERSED SEMICOLON +// "b.Sigma", 0x1D6BA, // MATHEMATICAL BOLD CAPITAL SIGMA +// "b.sigma", 0x1D6D4, // MATHEMATICAL BOLD SMALL SIGMA +// "b.sigmav", 0x1D6D3, // MATHEMATICAL BOLD SMALL FINAL SIGMA + "bsim", 0x0223D, // REVERSED TILDE + "bsime", 0x022CD, // REVERSED TILDE EQUALS + "bsol", 0x0005C, // REVERSE SOLIDUS + "bsolb", 0x029C5, // SQUARED FALLING DIAGONAL SLASH + "bsolhsub", 0x027C8, // REVERSE SOLIDUS PRECEDING SUBSET +// "b.tau", 0x1D6D5, // MATHEMATICAL BOLD SMALL TAU +// "b.Theta", 0x1D6AF, // MATHEMATICAL BOLD CAPITAL THETA +// "b.thetas", 0x1D6C9, // MATHEMATICAL BOLD SMALL THETA +// "b.thetav", 0x1D6DD, // MATHEMATICAL BOLD THETA SYMBOL + "bull", 0x02022, // BULLET + "bullet", 0x02022, // BULLET + "bump", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "bumpe", 0x0224F, // DIFFERENCE BETWEEN + "bumpE", 0x02AAE, // EQUALS SIGN WITH BUMPY ABOVE + "Bumpeq", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "bumpeq", 0x0224F, // DIFFERENCE BETWEEN +// "b.Upsi", 0x1D6BC, // MATHEMATICAL BOLD CAPITAL UPSILON +// "b.upsi", 0x1D6D6, // MATHEMATICAL BOLD SMALL UPSILON +// "b.Xi", 0x1D6B5, // MATHEMATICAL BOLD CAPITAL XI +// "b.xi", 0x1D6CF, // MATHEMATICAL BOLD SMALL XI +// "b.zeta", 0x1D6C7, // MATHEMATICAL BOLD SMALL ZETA + NULL, 0 +}; + +static NameId namesC[]={ + "Cacute", 0x00106, // LATIN CAPITAL LETTER C WITH ACUTE + "cacute", 0x00107, // LATIN SMALL LETTER C WITH ACUTE + "cap", 0x02229, // INTERSECTION + "Cap", 0x022D2, // DOUBLE INTERSECTION + "capand", 0x02A44, // INTERSECTION WITH LOGICAL AND + "capbrcup", 0x02A49, // INTERSECTION ABOVE BAR ABOVE UNION + "capcap", 0x02A4B, // INTERSECTION BESIDE AND JOINED WITH INTERSECTION + "capcup", 0x02A47, // INTERSECTION ABOVE UNION + "capdot", 0x02A40, // INTERSECTION WITH DOT + "CapitalDifferentialD", 0x02145, // DOUBLE-STRUCK ITALIC CAPITAL D +// "caps", 0x02229;0x0FE00, // INTERSECTION with serifs + "caret", 0x02041, // CARET INSERTION POINT + "caron", 0x002C7, // CARON + "Cayleys", 0x0212D, // BLACK-LETTER CAPITAL C + "ccaps", 0x02A4D, // CLOSED INTERSECTION WITH SERIFS + "Ccaron", 0x0010C, // LATIN CAPITAL LETTER C WITH CARON + "ccaron", 0x0010D, // LATIN SMALL LETTER C WITH CARON + "Ccedil", 0x000C7, // LATIN CAPITAL LETTER C WITH CEDILLA + "ccedil", 0x000E7, // LATIN SMALL LETTER C WITH CEDILLA + "Ccirc", 0x00108, // LATIN CAPITAL LETTER C WITH CIRCUMFLEX + "ccirc", 0x00109, // LATIN SMALL LETTER C WITH CIRCUMFLEX + "Cconint", 0x02230, // VOLUME INTEGRAL + "ccups", 0x02A4C, // CLOSED UNION WITH SERIFS + "ccupssm", 0x02A50, // CLOSED UNION WITH SERIFS AND SMASH PRODUCT + "Cdot", 0x0010A, // LATIN CAPITAL LETTER C WITH DOT ABOVE + "cdot", 0x0010B, // LATIN SMALL LETTER C WITH DOT ABOVE + "cedil", 0x000B8, // CEDILLA + "Cedilla", 0x000B8, // CEDILLA + "cemptyv", 0x029B2, // EMPTY SET WITH SMALL CIRCLE ABOVE + "cent", 0x000A2, // CENT SIGN + "centerdot", 0x000B7, // MIDDLE DOT + "CenterDot", 0x000B7, // MIDDLE DOT + "Cfr", 0x0212D, // BLACK-LETTER CAPITAL C + "cfr", 0x1D520, // MATHEMATICAL FRAKTUR SMALL C + "CHcy", 0x00427, // CYRILLIC CAPITAL LETTER CHE + "chcy", 0x00447, // CYRILLIC SMALL LETTER CHE + "check", 0x02713, // CHECK MARK + "checkmark", 0x02713, // CHECK MARK + "Chi", 0x003A7, // GREEK CAPITAL LETTER CHI + "chi", 0x003C7, // GREEK SMALL LETTER CHI + "cir", 0x025CB, // WHITE CIRCLE + "circ", 0x002C6, // MODIFIER LETTER CIRCUMFLEX ACCENT + "circeq", 0x02257, // RING EQUAL TO + "circlearrowleft", 0x021BA, // ANTICLOCKWISE OPEN CIRCLE ARROW + "circlearrowright", 0x021BB, // CLOCKWISE OPEN CIRCLE ARROW + "circledast", 0x0229B, // CIRCLED ASTERISK OPERATOR + "circledcirc", 0x0229A, // CIRCLED RING OPERATOR + "circleddash", 0x0229D, // CIRCLED DASH + "CircleDot", 0x02299, // CIRCLED DOT OPERATOR + "circledR", 0x000AE, // REGISTERED SIGN + "circledS", 0x024C8, // CIRCLED LATIN CAPITAL LETTER S + "CircleMinus", 0x02296, // CIRCLED MINUS + "CirclePlus", 0x02295, // CIRCLED PLUS + "CircleTimes", 0x02297, // CIRCLED TIMES + "cire", 0x02257, // RING EQUAL TO + "cirE", 0x029C3, // CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT + "cirfnint", 0x02A10, // CIRCULATION FUNCTION + "cirmid", 0x02AEF, // VERTICAL LINE WITH CIRCLE ABOVE + "cirscir", 0x029C2, // CIRCLE WITH SMALL CIRCLE TO THE RIGHT + "ClockwiseContourIntegral", 0x02232, // CLOCKWISE CONTOUR INTEGRAL + "CloseCurlyDoubleQuote", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "CloseCurlyQuote", 0x02019, // RIGHT SINGLE QUOTATION MARK + "clubs", 0x02663, // BLACK CLUB SUIT + "clubsuit", 0x02663, // BLACK CLUB SUIT + "colon", 0x0003A, // COLON + "Colon", 0x02237, // PROPORTION + "colone", 0x02254, // COLON EQUALS + "Colone", 0x02A74, // DOUBLE COLON EQUAL + "coloneq", 0x02254, // COLON EQUALS + "comma", 0x0002C, // COMMA + "commat", 0x00040, // COMMERCIAL AT + "comp", 0x02201, // COMPLEMENT + "compfn", 0x02218, // RING OPERATOR + "complement", 0x02201, // COMPLEMENT + "complexes", 0x02102, // DOUBLE-STRUCK CAPITAL C + "cong", 0x02245, // APPROXIMATELY EQUAL TO + "congdot", 0x02A6D, // CONGRUENT WITH DOT ABOVE + "Congruent", 0x02261, // IDENTICAL TO + "conint", 0x0222E, // CONTOUR INTEGRAL + "Conint", 0x0222F, // SURFACE INTEGRAL + "ContourIntegral", 0x0222E, // CONTOUR INTEGRAL + "Copf", 0x02102, // DOUBLE-STRUCK CAPITAL C + "copf", 0x1D554, // MATHEMATICAL DOUBLE-STRUCK SMALL C + "coprod", 0x02210, // N-ARY COPRODUCT + "Coproduct", 0x02210, // N-ARY COPRODUCT + "copy", 0x000A9, // COPYRIGHT SIGN + "COPY", 0x000A9, // COPYRIGHT SIGN + "copysr", 0x02117, // SOUND RECORDING COPYRIGHT + "CounterClockwiseContourIntegral", 0x02233, // ANTICLOCKWISE CONTOUR INTEGRAL + "crarr", 0x021B5, // DOWNWARDS ARROW WITH CORNER LEFTWARDS + "cross", 0x02717, // BALLOT X + "Cross", 0x02A2F, // VECTOR OR CROSS PRODUCT + "Cscr", 0x1D49E, // MATHEMATICAL SCRIPT CAPITAL C + "cscr", 0x1D4B8, // MATHEMATICAL SCRIPT SMALL C + "csub", 0x02ACF, // CLOSED SUBSET + "csube", 0x02AD1, // CLOSED SUBSET OR EQUAL TO + "csup", 0x02AD0, // CLOSED SUPERSET + "csupe", 0x02AD2, // CLOSED SUPERSET OR EQUAL TO + "ctdot", 0x022EF, // MIDLINE HORIZONTAL ELLIPSIS + "cudarrl", 0x02938, // RIGHT-SIDE ARC CLOCKWISE ARROW + "cudarrr", 0x02935, // ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS + "cuepr", 0x022DE, // EQUAL TO OR PRECEDES + "cuesc", 0x022DF, // EQUAL TO OR SUCCEEDS + "cularr", 0x021B6, // ANTICLOCKWISE TOP SEMICIRCLE ARROW + "cularrp", 0x0293D, // TOP ARC ANTICLOCKWISE ARROW WITH PLUS + "cup", 0x0222A, // UNION + "Cup", 0x022D3, // DOUBLE UNION + "cupbrcap", 0x02A48, // UNION ABOVE BAR ABOVE INTERSECTION + "CupCap", 0x0224D, // EQUIVALENT TO + "cupcap", 0x02A46, // UNION ABOVE INTERSECTION + "cupcup", 0x02A4A, // UNION BESIDE AND JOINED WITH UNION + "cupdot", 0x0228D, // MULTISET MULTIPLICATION + "cupor", 0x02A45, // UNION WITH LOGICAL OR +// "cups", 0x0222A;0x0FE00, // UNION with serifs + "curarr", 0x021B7, // CLOCKWISE TOP SEMICIRCLE ARROW + "curarrm", 0x0293C, // TOP ARC CLOCKWISE ARROW WITH MINUS + "curlyeqprec", 0x022DE, // EQUAL TO OR PRECEDES + "curlyeqsucc", 0x022DF, // EQUAL TO OR SUCCEEDS + "curlyvee", 0x022CE, // CURLY LOGICAL OR + "curlywedge", 0x022CF, // CURLY LOGICAL AND + "curren", 0x000A4, // CURRENCY SIGN + "curvearrowleft", 0x021B6, // ANTICLOCKWISE TOP SEMICIRCLE ARROW + "curvearrowright", 0x021B7, // CLOCKWISE TOP SEMICIRCLE ARROW + "cuvee", 0x022CE, // CURLY LOGICAL OR + "cuwed", 0x022CF, // CURLY LOGICAL AND + "cwconint", 0x02232, // CLOCKWISE CONTOUR INTEGRAL + "cwint", 0x02231, // CLOCKWISE INTEGRAL + "cylcty", 0x0232D, // CYLINDRICITY + NULL, 0 +}; + +static NameId namesD[]={ + "dagger", 0x02020, // DAGGER + "Dagger", 0x02021, // DOUBLE DAGGER + "daleth", 0x02138, // DALET SYMBOL + "darr", 0x02193, // DOWNWARDS ARROW + "Darr", 0x021A1, // DOWNWARDS TWO HEADED ARROW + "dArr", 0x021D3, // DOWNWARDS DOUBLE ARROW + "dash", 0x02010, // HYPHEN + "dashv", 0x022A3, // LEFT TACK + "Dashv", 0x02AE4, // VERTICAL BAR DOUBLE LEFT TURNSTILE + "dbkarow", 0x0290F, // RIGHTWARDS TRIPLE DASH ARROW + "dblac", 0x002DD, // DOUBLE ACUTE ACCENT + "Dcaron", 0x0010E, // LATIN CAPITAL LETTER D WITH CARON + "dcaron", 0x0010F, // LATIN SMALL LETTER D WITH CARON + "Dcy", 0x00414, // CYRILLIC CAPITAL LETTER DE + "dcy", 0x00434, // CYRILLIC SMALL LETTER DE + "DD", 0x02145, // DOUBLE-STRUCK ITALIC CAPITAL D + "dd", 0x02146, // DOUBLE-STRUCK ITALIC SMALL D + "ddagger", 0x02021, // DOUBLE DAGGER + "ddarr", 0x021CA, // DOWNWARDS PAIRED ARROWS + "DDotrahd", 0x02911, // RIGHTWARDS ARROW WITH DOTTED STEM + "ddotseq", 0x02A77, // EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW + "deg", 0x000B0, // DEGREE SIGN + "Del", 0x02207, // NABLA + "Delta", 0x00394, // GREEK CAPITAL LETTER DELTA + "delta", 0x003B4, // GREEK SMALL LETTER DELTA + "demptyv", 0x029B1, // EMPTY SET WITH OVERBAR + "dfisht", 0x0297F, // DOWN FISH TAIL + "Dfr", 0x1D507, // MATHEMATICAL FRAKTUR CAPITAL D + "dfr", 0x1D521, // MATHEMATICAL FRAKTUR SMALL D + "Dgr", 0x00394, // GREEK CAPITAL LETTER DELTA + "dgr", 0x003B4, // GREEK SMALL LETTER DELTA + "dHar", 0x02965, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "dharl", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "dharr", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "DiacriticalAcute", 0x000B4, // ACUTE ACCENT + "DiacriticalDot", 0x002D9, // DOT ABOVE + "DiacriticalDoubleAcute", 0x002DD, // DOUBLE ACUTE ACCENT + "DiacriticalGrave", 0x00060, // GRAVE ACCENT + "DiacriticalTilde", 0x002DC, // SMALL TILDE + "diam", 0x022C4, // DIAMOND OPERATOR + "diamond", 0x022C4, // DIAMOND OPERATOR + "Diamond", 0x022C4, // DIAMOND OPERATOR + "diamondsuit", 0x02666, // BLACK DIAMOND SUIT + "diams", 0x02666, // BLACK DIAMOND SUIT + "die", 0x000A8, // DIAERESIS + "DifferentialD", 0x02146, // DOUBLE-STRUCK ITALIC SMALL D + "digamma", 0x003DD, // GREEK SMALL LETTER DIGAMMA + "disin", 0x022F2, // ELEMENT OF WITH LONG HORIZONTAL STROKE + "div", 0x000F7, // DIVISION SIGN + "divide", 0x000F7, // DIVISION SIGN + "divideontimes", 0x022C7, // DIVISION TIMES + "divonx", 0x022C7, // DIVISION TIMES + "DJcy", 0x00402, // CYRILLIC CAPITAL LETTER DJE + "djcy", 0x00452, // CYRILLIC SMALL LETTER DJE + "dlcorn", 0x0231E, // BOTTOM LEFT CORNER + "dlcrop", 0x0230D, // BOTTOM LEFT CROP + "dollar", 0x00024, // DOLLAR SIGN + "Dopf", 0x1D53B, // MATHEMATICAL DOUBLE-STRUCK CAPITAL D + "dopf", 0x1D555, // MATHEMATICAL DOUBLE-STRUCK SMALL D + "Dot", 0x000A8, // DIAERESIS + "dot", 0x002D9, // DOT ABOVE + "DotDot", 0x020DC, // COMBINING FOUR DOTS ABOVE + "doteq", 0x02250, // APPROACHES THE LIMIT + "doteqdot", 0x02251, // GEOMETRICALLY EQUAL TO + "DotEqual", 0x02250, // APPROACHES THE LIMIT + "dotminus", 0x02238, // DOT MINUS + "dotplus", 0x02214, // DOT PLUS + "dotsquare", 0x022A1, // SQUARED DOT OPERATOR + "doublebarwedge", 0x02306, // PERSPECTIVE + "DoubleContourIntegral", 0x0222F, // SURFACE INTEGRAL + "DoubleDot", 0x000A8, // DIAERESIS + "DoubleDownArrow", 0x021D3, // DOWNWARDS DOUBLE ARROW + "DoubleLeftArrow", 0x021D0, // LEFTWARDS DOUBLE ARROW + "DoubleLeftRightArrow", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "DoubleLeftTee", 0x02AE4, // VERTICAL BAR DOUBLE LEFT TURNSTILE + "DoubleLongLeftArrow", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "DoubleLongLeftRightArrow", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "DoubleLongRightArrow", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "DoubleRightArrow", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "DoubleRightTee", 0x022A8, // TRUE + "DoubleUpArrow", 0x021D1, // UPWARDS DOUBLE ARROW + "DoubleUpDownArrow", 0x021D5, // UP DOWN DOUBLE ARROW + "DoubleVerticalBar", 0x02225, // PARALLEL TO + "downarrow", 0x02193, // DOWNWARDS ARROW + "DownArrow", 0x02193, // DOWNWARDS ARROW + "Downarrow", 0x021D3, // DOWNWARDS DOUBLE ARROW + "DownArrowBar", 0x02913, // DOWNWARDS ARROW TO BAR + "DownArrowUpArrow", 0x021F5, // DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW + "DownBreve", 0x00311, // COMBINING INVERTED BREVE + "downdownarrows", 0x021CA, // DOWNWARDS PAIRED ARROWS + "downharpoonleft", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "downharpoonright", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "DownLeftRightVector", 0x02950, // LEFT BARB DOWN RIGHT BARB DOWN HARPOON + "DownLeftTeeVector", 0x0295E, // LEFTWARDS HARPOON WITH BARB DOWN FROM BAR + "DownLeftVector", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "DownLeftVectorBar", 0x02956, // LEFTWARDS HARPOON WITH BARB DOWN TO BAR + "DownRightTeeVector", 0x0295F, // RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR + "DownRightVector", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "DownRightVectorBar", 0x02957, // RIGHTWARDS HARPOON WITH BARB DOWN TO BAR + "DownTee", 0x022A4, // DOWN TACK + "DownTeeArrow", 0x021A7, // DOWNWARDS ARROW FROM BAR + "drbkarow", 0x02910, // RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW + "drcorn", 0x0231F, // BOTTOM RIGHT CORNER + "drcrop", 0x0230C, // BOTTOM RIGHT CROP + "Dscr", 0x1D49F, // MATHEMATICAL SCRIPT CAPITAL D + "dscr", 0x1D4B9, // MATHEMATICAL SCRIPT SMALL D + "DScy", 0x00405, // CYRILLIC CAPITAL LETTER DZE + "dscy", 0x00455, // CYRILLIC SMALL LETTER DZE + "dsol", 0x029F6, // SOLIDUS WITH OVERBAR + "Dstrok", 0x00110, // LATIN CAPITAL LETTER D WITH STROKE + "dstrok", 0x00111, // LATIN SMALL LETTER D WITH STROKE + "dtdot", 0x022F1, // DOWN RIGHT DIAGONAL ELLIPSIS + "dtri", 0x025BF, // WHITE DOWN-POINTING SMALL TRIANGLE + "dtrif", 0x025BE, // BLACK DOWN-POINTING SMALL TRIANGLE + "duarr", 0x021F5, // DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW + "duhar", 0x0296F, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "dwangle", 0x029A6, // OBLIQUE ANGLE OPENING UP + "DZcy", 0x0040F, // CYRILLIC CAPITAL LETTER DZHE + "dzcy", 0x0045F, // CYRILLIC SMALL LETTER DZHE + "dzigrarr", 0x027FF, // LONG RIGHTWARDS SQUIGGLE ARROW + NULL, 0 +}; + +static NameId namesE[]={ + "Eacgr", 0x00388, // GREEK CAPITAL LETTER EPSILON WITH TONOS + "eacgr", 0x003AD, // GREEK SMALL LETTER EPSILON WITH TONOS + "Eacute", 0x000C9, // LATIN CAPITAL LETTER E WITH ACUTE + "eacute", 0x000E9, // LATIN SMALL LETTER E WITH ACUTE + "easter", 0x02A6E, // EQUALS WITH ASTERISK + "Ecaron", 0x0011A, // LATIN CAPITAL LETTER E WITH CARON + "ecaron", 0x0011B, // LATIN SMALL LETTER E WITH CARON + "ecir", 0x02256, // RING IN EQUAL TO + "Ecirc", 0x000CA, // LATIN CAPITAL LETTER E WITH CIRCUMFLEX + "ecirc", 0x000EA, // LATIN SMALL LETTER E WITH CIRCUMFLEX + "ecolon", 0x02255, // EQUALS COLON + "Ecy", 0x0042D, // CYRILLIC CAPITAL LETTER E + "ecy", 0x0044D, // CYRILLIC SMALL LETTER E + "eDDot", 0x02A77, // EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW + "Edot", 0x00116, // LATIN CAPITAL LETTER E WITH DOT ABOVE + "edot", 0x00117, // LATIN SMALL LETTER E WITH DOT ABOVE + "eDot", 0x02251, // GEOMETRICALLY EQUAL TO + "ee", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + "EEacgr", 0x00389, // GREEK CAPITAL LETTER ETA WITH TONOS + "eeacgr", 0x003AE, // GREEK SMALL LETTER ETA WITH TONOS + "EEgr", 0x00397, // GREEK CAPITAL LETTER ETA + "eegr", 0x003B7, // GREEK SMALL LETTER ETA + "efDot", 0x02252, // APPROXIMATELY EQUAL TO OR THE IMAGE OF + "Efr", 0x1D508, // MATHEMATICAL FRAKTUR CAPITAL E + "efr", 0x1D522, // MATHEMATICAL FRAKTUR SMALL E + "eg", 0x02A9A, // DOUBLE-LINE EQUAL TO OR GREATER-THAN + "Egr", 0x00395, // GREEK CAPITAL LETTER EPSILON + "egr", 0x003B5, // GREEK SMALL LETTER EPSILON + "Egrave", 0x000C8, // LATIN CAPITAL LETTER E WITH GRAVE + "egrave", 0x000E8, // LATIN SMALL LETTER E WITH GRAVE + "egs", 0x02A96, // SLANTED EQUAL TO OR GREATER-THAN + "egsdot", 0x02A98, // SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE + "el", 0x02A99, // DOUBLE-LINE EQUAL TO OR LESS-THAN + "Element", 0x02208, // ELEMENT OF + "elinters", 0x023E7, // ELECTRICAL INTERSECTION + "ell", 0x02113, // SCRIPT SMALL L + "els", 0x02A95, // SLANTED EQUAL TO OR LESS-THAN + "elsdot", 0x02A97, // SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE + "Emacr", 0x00112, // LATIN CAPITAL LETTER E WITH MACRON + "emacr", 0x00113, // LATIN SMALL LETTER E WITH MACRON + "empty", 0x02205, // EMPTY SET + "emptyset", 0x02205, // EMPTY SET + "EmptySmallSquare", 0x025FB, // WHITE MEDIUM SQUARE + "emptyv", 0x02205, // EMPTY SET + "EmptyVerySmallSquare", 0x025AB, // WHITE SMALL SQUARE + "emsp", 0x02003, // EM SPACE + "emsp13", 0x02004, // THREE-PER-EM SPACE + "emsp14", 0x02005, // FOUR-PER-EM SPACE + "ENG", 0x0014A, // LATIN CAPITAL LETTER ENG + "eng", 0x0014B, // LATIN SMALL LETTER ENG + "ensp", 0x02002, // EN SPACE + "Eogon", 0x00118, // LATIN CAPITAL LETTER E WITH OGONEK + "eogon", 0x00119, // LATIN SMALL LETTER E WITH OGONEK + "Eopf", 0x1D53C, // MATHEMATICAL DOUBLE-STRUCK CAPITAL E + "eopf", 0x1D556, // MATHEMATICAL DOUBLE-STRUCK SMALL E + "epar", 0x022D5, // EQUAL AND PARALLEL TO + "eparsl", 0x029E3, // EQUALS SIGN AND SLANTED PARALLEL + "eplus", 0x02A71, // EQUALS SIGN ABOVE PLUS SIGN + "epsi", 0x003B5, // GREEK SMALL LETTER EPSILON + "Epsilon", 0x00395, // GREEK CAPITAL LETTER EPSILON + "epsilon", 0x003B5, // GREEK SMALL LETTER EPSILON + "epsiv", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "eqcirc", 0x02256, // RING IN EQUAL TO + "eqcolon", 0x02255, // EQUALS COLON + "eqsim", 0x02242, // MINUS TILDE + "eqslantgtr", 0x02A96, // SLANTED EQUAL TO OR GREATER-THAN + "eqslantless", 0x02A95, // SLANTED EQUAL TO OR LESS-THAN + "Equal", 0x02A75, // TWO CONSECUTIVE EQUALS SIGNS + "equals", 0x0003D, // EQUALS SIGN + "EqualTilde", 0x02242, // MINUS TILDE + "equest", 0x0225F, // QUESTIONED EQUAL TO + "Equilibrium", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "equiv", 0x02261, // IDENTICAL TO + "equivDD", 0x02A78, // EQUIVALENT WITH FOUR DOTS ABOVE + "eqvparsl", 0x029E5, // IDENTICAL TO AND SLANTED PARALLEL + "erarr", 0x02971, // EQUALS SIGN ABOVE RIGHTWARDS ARROW + "erDot", 0x02253, // IMAGE OF OR APPROXIMATELY EQUAL TO + "escr", 0x0212F, // SCRIPT SMALL E + "Escr", 0x02130, // SCRIPT CAPITAL E + "esdot", 0x02250, // APPROACHES THE LIMIT + "esim", 0x02242, // MINUS TILDE + "Esim", 0x02A73, // EQUALS SIGN ABOVE TILDE OPERATOR + "Eta", 0x00397, // GREEK CAPITAL LETTER ETA + "eta", 0x003B7, // GREEK SMALL LETTER ETA + "ETH", 0x000D0, // LATIN CAPITAL LETTER ETH + "eth", 0x000F0, // LATIN SMALL LETTER ETH + "Euml", 0x000CB, // LATIN CAPITAL LETTER E WITH DIAERESIS + "euml", 0x000EB, // LATIN SMALL LETTER E WITH DIAERESIS + "euro", 0x020AC, // EURO SIGN + "excl", 0x00021, // EXCLAMATION MARK + "exist", 0x02203, // THERE EXISTS + "Exists", 0x02203, // THERE EXISTS + "expectation", 0x02130, // SCRIPT CAPITAL E + "exponentiale", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + "ExponentialE", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + NULL, 0 +}; + +static NameId namesF[]={ + "fallingdotseq", 0x02252, // APPROXIMATELY EQUAL TO OR THE IMAGE OF + "Fcy", 0x00424, // CYRILLIC CAPITAL LETTER EF + "fcy", 0x00444, // CYRILLIC SMALL LETTER EF + "female", 0x02640, // FEMALE SIGN + "ffilig", 0x0FB03, // LATIN SMALL LIGATURE FFI + "fflig", 0x0FB00, // LATIN SMALL LIGATURE FF + "ffllig", 0x0FB04, // LATIN SMALL LIGATURE FFL + "Ffr", 0x1D509, // MATHEMATICAL FRAKTUR CAPITAL F + "ffr", 0x1D523, // MATHEMATICAL FRAKTUR SMALL F + "filig", 0x0FB01, // LATIN SMALL LIGATURE FI + "FilledSmallSquare", 0x025FC, // BLACK MEDIUM SQUARE + "FilledVerySmallSquare", 0x025AA, // BLACK SMALL SQUARE +// "fjlig", 0x00066;0x0006A, // fj ligature + "flat", 0x0266D, // MUSIC FLAT SIGN + "fllig", 0x0FB02, // LATIN SMALL LIGATURE FL + "fltns", 0x025B1, // WHITE PARALLELOGRAM + "fnof", 0x00192, // LATIN SMALL LETTER F WITH HOOK + "Fopf", 0x1D53D, // MATHEMATICAL DOUBLE-STRUCK CAPITAL F + "fopf", 0x1D557, // MATHEMATICAL DOUBLE-STRUCK SMALL F + "forall", 0x02200, // FOR ALL + "ForAll", 0x02200, // FOR ALL + "fork", 0x022D4, // PITCHFORK + "forkv", 0x02AD9, // ELEMENT OF OPENING DOWNWARDS + "Fouriertrf", 0x02131, // SCRIPT CAPITAL F + "fpartint", 0x02A0D, // FINITE PART INTEGRAL + "frac12", 0x000BD, // VULGAR FRACTION ONE HALF + "frac13", 0x02153, // VULGAR FRACTION ONE THIRD + "frac14", 0x000BC, // VULGAR FRACTION ONE QUARTER + "frac15", 0x02155, // VULGAR FRACTION ONE FIFTH + "frac16", 0x02159, // VULGAR FRACTION ONE SIXTH + "frac18", 0x0215B, // VULGAR FRACTION ONE EIGHTH + "frac23", 0x02154, // VULGAR FRACTION TWO THIRDS + "frac25", 0x02156, // VULGAR FRACTION TWO FIFTHS + "frac34", 0x000BE, // VULGAR FRACTION THREE QUARTERS + "frac35", 0x02157, // VULGAR FRACTION THREE FIFTHS + "frac38", 0x0215C, // VULGAR FRACTION THREE EIGHTHS + "frac45", 0x02158, // VULGAR FRACTION FOUR FIFTHS + "frac56", 0x0215A, // VULGAR FRACTION FIVE SIXTHS + "frac58", 0x0215D, // VULGAR FRACTION FIVE EIGHTHS + "frac78", 0x0215E, // VULGAR FRACTION SEVEN EIGHTHS + "frasl", 0x02044, // FRACTION SLASH + "frown", 0x02322, // FROWN + "Fscr", 0x02131, // SCRIPT CAPITAL F + "fscr", 0x1D4BB, // MATHEMATICAL SCRIPT SMALL F + NULL, 0 +}; + +static NameId namesG[]={ + "gacute", 0x001F5, // LATIN SMALL LETTER G WITH ACUTE + "Gamma", 0x00393, // GREEK CAPITAL LETTER GAMMA + "gamma", 0x003B3, // GREEK SMALL LETTER GAMMA + "Gammad", 0x003DC, // GREEK LETTER DIGAMMA + "gammad", 0x003DD, // GREEK SMALL LETTER DIGAMMA + "gap", 0x02A86, // GREATER-THAN OR APPROXIMATE + "Gbreve", 0x0011E, // LATIN CAPITAL LETTER G WITH BREVE + "gbreve", 0x0011F, // LATIN SMALL LETTER G WITH BREVE + "Gcedil", 0x00122, // LATIN CAPITAL LETTER G WITH CEDILLA + "Gcirc", 0x0011C, // LATIN CAPITAL LETTER G WITH CIRCUMFLEX + "gcirc", 0x0011D, // LATIN SMALL LETTER G WITH CIRCUMFLEX + "Gcy", 0x00413, // CYRILLIC CAPITAL LETTER GHE + "gcy", 0x00433, // CYRILLIC SMALL LETTER GHE + "Gdot", 0x00120, // LATIN CAPITAL LETTER G WITH DOT ABOVE + "gdot", 0x00121, // LATIN SMALL LETTER G WITH DOT ABOVE + "ge", 0x02265, // GREATER-THAN OR EQUAL TO + "gE", 0x02267, // GREATER-THAN OVER EQUAL TO + "gel", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "gEl", 0x02A8C, // GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN + "geq", 0x02265, // GREATER-THAN OR EQUAL TO + "geqq", 0x02267, // GREATER-THAN OVER EQUAL TO + "geqslant", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "ges", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "gescc", 0x02AA9, // GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL + "gesdot", 0x02A80, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE + "gesdoto", 0x02A82, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE + "gesdotol", 0x02A84, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT +// "gesl", 0x022DB;0x0FE00, // GREATER-THAN slanted EQUAL TO OR LESS-THAN + "gesles", 0x02A94, // GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL + "Gfr", 0x1D50A, // MATHEMATICAL FRAKTUR CAPITAL G + "gfr", 0x1D524, // MATHEMATICAL FRAKTUR SMALL G + "gg", 0x0226B, // MUCH GREATER-THAN + "Gg", 0x022D9, // VERY MUCH GREATER-THAN + "ggg", 0x022D9, // VERY MUCH GREATER-THAN + "Ggr", 0x00393, // GREEK CAPITAL LETTER GAMMA + "ggr", 0x003B3, // GREEK SMALL LETTER GAMMA + "gimel", 0x02137, // GIMEL SYMBOL + "GJcy", 0x00403, // CYRILLIC CAPITAL LETTER GJE + "gjcy", 0x00453, // CYRILLIC SMALL LETTER GJE + "gl", 0x02277, // GREATER-THAN OR LESS-THAN + "gla", 0x02AA5, // GREATER-THAN BESIDE LESS-THAN + "glE", 0x02A92, // GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL + "glj", 0x02AA4, // GREATER-THAN OVERLAPPING LESS-THAN + "gnap", 0x02A8A, // GREATER-THAN AND NOT APPROXIMATE + "gnapprox", 0x02A8A, // GREATER-THAN AND NOT APPROXIMATE + "gnE", 0x02269, // GREATER-THAN BUT NOT EQUAL TO + "gne", 0x02A88, // GREATER-THAN AND SINGLE-LINE NOT EQUAL TO + "gneq", 0x02A88, // GREATER-THAN AND SINGLE-LINE NOT EQUAL TO + "gneqq", 0x02269, // GREATER-THAN BUT NOT EQUAL TO + "gnsim", 0x022E7, // GREATER-THAN BUT NOT EQUIVALENT TO + "Gopf", 0x1D53E, // MATHEMATICAL DOUBLE-STRUCK CAPITAL G + "gopf", 0x1D558, // MATHEMATICAL DOUBLE-STRUCK SMALL G + "grave", 0x00060, // GRAVE ACCENT + "GreaterEqual", 0x02265, // GREATER-THAN OR EQUAL TO + "GreaterEqualLess", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "GreaterFullEqual", 0x02267, // GREATER-THAN OVER EQUAL TO + "GreaterGreater", 0x02AA2, // DOUBLE NESTED GREATER-THAN + "GreaterLess", 0x02277, // GREATER-THAN OR LESS-THAN + "GreaterSlantEqual", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "GreaterTilde", 0x02273, // GREATER-THAN OR EQUIVALENT TO + "gscr", 0x0210A, // SCRIPT SMALL G + "Gscr", 0x1D4A2, // MATHEMATICAL SCRIPT CAPITAL G + "gsim", 0x02273, // GREATER-THAN OR EQUIVALENT TO + "gsime", 0x02A8E, // GREATER-THAN ABOVE SIMILAR OR EQUAL + "gsiml", 0x02A90, // GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN + "gt", 0x0003E, // GREATER-THAN SIGN + "GT", 0x0003E, // GREATER-THAN SIGN + "Gt", 0x0226B, // MUCH GREATER-THAN + "gtcc", 0x02AA7, // GREATER-THAN CLOSED BY CURVE + "gtcir", 0x02A7A, // GREATER-THAN WITH CIRCLE INSIDE + "gtdot", 0x022D7, // GREATER-THAN WITH DOT + "gtlPar", 0x02995, // DOUBLE LEFT ARC GREATER-THAN BRACKET + "gtquest", 0x02A7C, // GREATER-THAN WITH QUESTION MARK ABOVE + "gtrapprox", 0x02A86, // GREATER-THAN OR APPROXIMATE + "gtrarr", 0x02978, // GREATER-THAN ABOVE RIGHTWARDS ARROW + "gtrdot", 0x022D7, // GREATER-THAN WITH DOT + "gtreqless", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "gtreqqless", 0x02A8C, // GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN + "gtrless", 0x02277, // GREATER-THAN OR LESS-THAN + "gtrsim", 0x02273, // GREATER-THAN OR EQUIVALENT TO +// "gvertneqq", 0x02269;0x0FE00, // GREATER-THAN BUT NOT EQUAL TO - with vertical stroke +// "gvnE", 0x02269;0x0FE00, // GREATER-THAN BUT NOT EQUAL TO - with vertical stroke + NULL, 0 +}; + +static NameId namesH[]={ + "Hacek", 0x002C7, // CARON + "hairsp", 0x0200A, // HAIR SPACE + "half", 0x000BD, // VULGAR FRACTION ONE HALF + "hamilt", 0x0210B, // SCRIPT CAPITAL H + "HARDcy", 0x0042A, // CYRILLIC CAPITAL LETTER HARD SIGN + "hardcy", 0x0044A, // CYRILLIC SMALL LETTER HARD SIGN + "harr", 0x02194, // LEFT RIGHT ARROW + "hArr", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "harrcir", 0x02948, // LEFT RIGHT ARROW THROUGH SMALL CIRCLE + "harrw", 0x021AD, // LEFT RIGHT WAVE ARROW + "Hat", 0x0005E, // CIRCUMFLEX ACCENT + "hbar", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "Hcirc", 0x00124, // LATIN CAPITAL LETTER H WITH CIRCUMFLEX + "hcirc", 0x00125, // LATIN SMALL LETTER H WITH CIRCUMFLEX + "hearts", 0x02665, // BLACK HEART SUIT + "heartsuit", 0x02665, // BLACK HEART SUIT + "hellip", 0x02026, // HORIZONTAL ELLIPSIS + "hercon", 0x022B9, // HERMITIAN CONJUGATE MATRIX + "Hfr", 0x0210C, // BLACK-LETTER CAPITAL H + "hfr", 0x1D525, // MATHEMATICAL FRAKTUR SMALL H + "HilbertSpace", 0x0210B, // SCRIPT CAPITAL H + "hksearow", 0x02925, // SOUTH EAST ARROW WITH HOOK + "hkswarow", 0x02926, // SOUTH WEST ARROW WITH HOOK + "hoarr", 0x021FF, // LEFT RIGHT OPEN-HEADED ARROW + "homtht", 0x0223B, // HOMOTHETIC + "hookleftarrow", 0x021A9, // LEFTWARDS ARROW WITH HOOK + "hookrightarrow", 0x021AA, // RIGHTWARDS ARROW WITH HOOK + "Hopf", 0x0210D, // DOUBLE-STRUCK CAPITAL H + "hopf", 0x1D559, // MATHEMATICAL DOUBLE-STRUCK SMALL H + "horbar", 0x02015, // HORIZONTAL BAR + "HorizontalLine", 0x02500, // BOX DRAWINGS LIGHT HORIZONTAL + "Hscr", 0x0210B, // SCRIPT CAPITAL H + "hscr", 0x1D4BD, // MATHEMATICAL SCRIPT SMALL H + "hslash", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "Hstrok", 0x00126, // LATIN CAPITAL LETTER H WITH STROKE + "hstrok", 0x00127, // LATIN SMALL LETTER H WITH STROKE + "HumpDownHump", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "HumpEqual", 0x0224F, // DIFFERENCE BETWEEN + "hybull", 0x02043, // HYPHEN BULLET + "hyphen", 0x02010, // HYPHEN + NULL, 0 +}; + +static NameId namesI[]={ + "Iacgr", 0x0038A, // GREEK CAPITAL LETTER IOTA WITH TONOS + "iacgr", 0x003AF, // GREEK SMALL LETTER IOTA WITH TONOS + "Iacute", 0x000CD, // LATIN CAPITAL LETTER I WITH ACUTE + "iacute", 0x000ED, // LATIN SMALL LETTER I WITH ACUTE + "ic", 0x02063, // INVISIBLE SEPARATOR + "Icirc", 0x000CE, // LATIN CAPITAL LETTER I WITH CIRCUMFLEX + "icirc", 0x000EE, // LATIN SMALL LETTER I WITH CIRCUMFLEX + "Icy", 0x00418, // CYRILLIC CAPITAL LETTER I + "icy", 0x00438, // CYRILLIC SMALL LETTER I + "idiagr", 0x00390, // GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + "Idigr", 0x003AA, // GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + "idigr", 0x003CA, // GREEK SMALL LETTER IOTA WITH DIALYTIKA + "Idot", 0x00130, // LATIN CAPITAL LETTER I WITH DOT ABOVE + "IEcy", 0x00415, // CYRILLIC CAPITAL LETTER IE + "iecy", 0x00435, // CYRILLIC SMALL LETTER IE + "iexcl", 0x000A1, // INVERTED EXCLAMATION MARK + "iff", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "Ifr", 0x02111, // BLACK-LETTER CAPITAL I + "ifr", 0x1D526, // MATHEMATICAL FRAKTUR SMALL I + "Igr", 0x00399, // GREEK CAPITAL LETTER IOTA + "igr", 0x003B9, // GREEK SMALL LETTER IOTA + "Igrave", 0x000CC, // LATIN CAPITAL LETTER I WITH GRAVE + "igrave", 0x000EC, // LATIN SMALL LETTER I WITH GRAVE + "ii", 0x02148, // DOUBLE-STRUCK ITALIC SMALL I + "iiiint", 0x02A0C, // QUADRUPLE INTEGRAL OPERATOR + "iiint", 0x0222D, // TRIPLE INTEGRAL + "iinfin", 0x029DC, // INCOMPLETE INFINITY + "iiota", 0x02129, // TURNED GREEK SMALL LETTER IOTA + "IJlig", 0x00132, // LATIN CAPITAL LIGATURE IJ + "ijlig", 0x00133, // LATIN SMALL LIGATURE IJ + "Im", 0x02111, // BLACK-LETTER CAPITAL I + "Imacr", 0x0012A, // LATIN CAPITAL LETTER I WITH MACRON + "imacr", 0x0012B, // LATIN SMALL LETTER I WITH MACRON + "image", 0x02111, // BLACK-LETTER CAPITAL I + "ImaginaryI", 0x02148, // DOUBLE-STRUCK ITALIC SMALL I + "imagline", 0x02110, // SCRIPT CAPITAL I + "imagpart", 0x02111, // BLACK-LETTER CAPITAL I + "imath", 0x00131, // LATIN SMALL LETTER DOTLESS I + "imof", 0x022B7, // IMAGE OF + "imped", 0x001B5, // LATIN CAPITAL LETTER Z WITH STROKE + "Implies", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "in", 0x02208, // ELEMENT OF + "incare", 0x02105, // CARE OF + "infin", 0x0221E, // INFINITY + "infintie", 0x029DD, // TIE OVER INFINITY + "inodot", 0x00131, // LATIN SMALL LETTER DOTLESS I + "int", 0x0222B, // INTEGRAL + "Int", 0x0222C, // DOUBLE INTEGRAL + "intcal", 0x022BA, // INTERCALATE + "integers", 0x02124, // DOUBLE-STRUCK CAPITAL Z + "Integral", 0x0222B, // INTEGRAL + "intercal", 0x022BA, // INTERCALATE + "Intersection", 0x022C2, // N-ARY INTERSECTION + "intlarhk", 0x02A17, // INTEGRAL WITH LEFTWARDS ARROW WITH HOOK + "intprod", 0x02A3C, // INTERIOR PRODUCT + "InvisibleComma", 0x02063, // INVISIBLE SEPARATOR + "InvisibleTimes", 0x02062, // INVISIBLE TIMES + "IOcy", 0x00401, // CYRILLIC CAPITAL LETTER IO + "iocy", 0x00451, // CYRILLIC SMALL LETTER IO + "Iogon", 0x0012E, // LATIN CAPITAL LETTER I WITH OGONEK + "iogon", 0x0012F, // LATIN SMALL LETTER I WITH OGONEK + "Iopf", 0x1D540, // MATHEMATICAL DOUBLE-STRUCK CAPITAL I + "iopf", 0x1D55A, // MATHEMATICAL DOUBLE-STRUCK SMALL I + "Iota", 0x00399, // GREEK CAPITAL LETTER IOTA + "iota", 0x003B9, // GREEK SMALL LETTER IOTA + "iprod", 0x02A3C, // INTERIOR PRODUCT + "iquest", 0x000BF, // INVERTED QUESTION MARK + "Iscr", 0x02110, // SCRIPT CAPITAL I + "iscr", 0x1D4BE, // MATHEMATICAL SCRIPT SMALL I + "isin", 0x02208, // ELEMENT OF + "isindot", 0x022F5, // ELEMENT OF WITH DOT ABOVE + "isinE", 0x022F9, // ELEMENT OF WITH TWO HORIZONTAL STROKES + "isins", 0x022F4, // SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "isinsv", 0x022F3, // ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "isinv", 0x02208, // ELEMENT OF + "it", 0x02062, // INVISIBLE TIMES + "Itilde", 0x00128, // LATIN CAPITAL LETTER I WITH TILDE + "itilde", 0x00129, // LATIN SMALL LETTER I WITH TILDE + "Iukcy", 0x00406, // CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I + "iukcy", 0x00456, // CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I + "Iuml", 0x000CF, // LATIN CAPITAL LETTER I WITH DIAERESIS + "iuml", 0x000EF, // LATIN SMALL LETTER I WITH DIAERESIS + NULL, 0 +}; + +static NameId namesJ[]={ + "Jcirc", 0x00134, // LATIN CAPITAL LETTER J WITH CIRCUMFLEX + "jcirc", 0x00135, // LATIN SMALL LETTER J WITH CIRCUMFLEX + "Jcy", 0x00419, // CYRILLIC CAPITAL LETTER SHORT I + "jcy", 0x00439, // CYRILLIC SMALL LETTER SHORT I + "Jfr", 0x1D50D, // MATHEMATICAL FRAKTUR CAPITAL J + "jfr", 0x1D527, // MATHEMATICAL FRAKTUR SMALL J + "jmath", 0x00237, // LATIN SMALL LETTER DOTLESS J + "Jopf", 0x1D541, // MATHEMATICAL DOUBLE-STRUCK CAPITAL J + "jopf", 0x1D55B, // MATHEMATICAL DOUBLE-STRUCK SMALL J + "Jscr", 0x1D4A5, // MATHEMATICAL SCRIPT CAPITAL J + "jscr", 0x1D4BF, // MATHEMATICAL SCRIPT SMALL J + "Jsercy", 0x00408, // CYRILLIC CAPITAL LETTER JE + "jsercy", 0x00458, // CYRILLIC SMALL LETTER JE + "Jukcy", 0x00404, // CYRILLIC CAPITAL LETTER UKRAINIAN IE + "jukcy", 0x00454, // CYRILLIC SMALL LETTER UKRAINIAN IE + NULL, 0 +}; + +static NameId namesK[]={ + "Kappa", 0x0039A, // GREEK CAPITAL LETTER KAPPA + "kappa", 0x003BA, // GREEK SMALL LETTER KAPPA + "kappav", 0x003F0, // GREEK KAPPA SYMBOL + "Kcedil", 0x00136, // LATIN CAPITAL LETTER K WITH CEDILLA + "kcedil", 0x00137, // LATIN SMALL LETTER K WITH CEDILLA + "Kcy", 0x0041A, // CYRILLIC CAPITAL LETTER KA + "kcy", 0x0043A, // CYRILLIC SMALL LETTER KA + "Kfr", 0x1D50E, // MATHEMATICAL FRAKTUR CAPITAL K + "kfr", 0x1D528, // MATHEMATICAL FRAKTUR SMALL K + "Kgr", 0x0039A, // GREEK CAPITAL LETTER KAPPA + "kgr", 0x003BA, // GREEK SMALL LETTER KAPPA + "kgreen", 0x00138, // LATIN SMALL LETTER KRA + "KHcy", 0x00425, // CYRILLIC CAPITAL LETTER HA + "khcy", 0x00445, // CYRILLIC SMALL LETTER HA + "KHgr", 0x003A7, // GREEK CAPITAL LETTER CHI + "khgr", 0x003C7, // GREEK SMALL LETTER CHI + "KJcy", 0x0040C, // CYRILLIC CAPITAL LETTER KJE + "kjcy", 0x0045C, // CYRILLIC SMALL LETTER KJE + "Kopf", 0x1D542, // MATHEMATICAL DOUBLE-STRUCK CAPITAL K + "kopf", 0x1D55C, // MATHEMATICAL DOUBLE-STRUCK SMALL K + "Kscr", 0x1D4A6, // MATHEMATICAL SCRIPT CAPITAL K + "kscr", 0x1D4C0, // MATHEMATICAL SCRIPT SMALL K + NULL, 0 +}; + +static NameId namesL[]={ + "lAarr", 0x021DA, // LEFTWARDS TRIPLE ARROW + "Lacute", 0x00139, // LATIN CAPITAL LETTER L WITH ACUTE + "lacute", 0x0013A, // LATIN SMALL LETTER L WITH ACUTE + "laemptyv", 0x029B4, // EMPTY SET WITH LEFT ARROW ABOVE + "lagran", 0x02112, // SCRIPT CAPITAL L + "Lambda", 0x0039B, // GREEK CAPITAL LETTER LAMDA + "lambda", 0x003BB, // GREEK SMALL LETTER LAMDA + "lang", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "Lang", 0x027EA, // MATHEMATICAL LEFT DOUBLE ANGLE BRACKET + "langd", 0x02991, // LEFT ANGLE BRACKET WITH DOT + "langle", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "lap", 0x02A85, // LESS-THAN OR APPROXIMATE + "Laplacetrf", 0x02112, // SCRIPT CAPITAL L + "laquo", 0x000AB, // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + "larr", 0x02190, // LEFTWARDS ARROW + "Larr", 0x0219E, // LEFTWARDS TWO HEADED ARROW + "lArr", 0x021D0, // LEFTWARDS DOUBLE ARROW + "larrb", 0x021E4, // LEFTWARDS ARROW TO BAR + "larrbfs", 0x0291F, // LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND + "larrfs", 0x0291D, // LEFTWARDS ARROW TO BLACK DIAMOND + "larrhk", 0x021A9, // LEFTWARDS ARROW WITH HOOK + "larrlp", 0x021AB, // LEFTWARDS ARROW WITH LOOP + "larrpl", 0x02939, // LEFT-SIDE ARC ANTICLOCKWISE ARROW + "larrsim", 0x02973, // LEFTWARDS ARROW ABOVE TILDE OPERATOR + "larrtl", 0x021A2, // LEFTWARDS ARROW WITH TAIL + "lat", 0x02AAB, // LARGER THAN + "latail", 0x02919, // LEFTWARDS ARROW-TAIL + "lAtail", 0x0291B, // LEFTWARDS DOUBLE ARROW-TAIL + "late", 0x02AAD, // LARGER THAN OR EQUAL TO +// "lates", 0x02AAD;0x0FE00, // LARGER THAN OR slanted EQUAL + "lbarr", 0x0290C, // LEFTWARDS DOUBLE DASH ARROW + "lBarr", 0x0290E, // LEFTWARDS TRIPLE DASH ARROW + "lbbrk", 0x02772, // LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT + "lbrace", 0x0007B, // LEFT CURLY BRACKET + "lbrack", 0x0005B, // LEFT SQUARE BRACKET + "lbrke", 0x0298B, // LEFT SQUARE BRACKET WITH UNDERBAR + "lbrksld", 0x0298F, // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER + "lbrkslu", 0x0298D, // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER + "Lcaron", 0x0013D, // LATIN CAPITAL LETTER L WITH CARON + "lcaron", 0x0013E, // LATIN SMALL LETTER L WITH CARON + "Lcedil", 0x0013B, // LATIN CAPITAL LETTER L WITH CEDILLA + "lcedil", 0x0013C, // LATIN SMALL LETTER L WITH CEDILLA + "lceil", 0x02308, // LEFT CEILING + "lcub", 0x0007B, // LEFT CURLY BRACKET + "Lcy", 0x0041B, // CYRILLIC CAPITAL LETTER EL + "lcy", 0x0043B, // CYRILLIC SMALL LETTER EL + "ldca", 0x02936, // ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS + "ldquo", 0x0201C, // LEFT DOUBLE QUOTATION MARK + "ldquor", 0x0201E, // DOUBLE LOW-9 QUOTATION MARK + "ldrdhar", 0x02967, // LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN + "ldrushar", 0x0294B, // LEFT BARB DOWN RIGHT BARB UP HARPOON + "ldsh", 0x021B2, // DOWNWARDS ARROW WITH TIP LEFTWARDS + "le", 0x02264, // LESS-THAN OR EQUAL TO + "lE", 0x02266, // LESS-THAN OVER EQUAL TO + "LeftAngleBracket", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "leftarrow", 0x02190, // LEFTWARDS ARROW + "LeftArrow", 0x02190, // LEFTWARDS ARROW + "Leftarrow", 0x021D0, // LEFTWARDS DOUBLE ARROW + "LeftArrowBar", 0x021E4, // LEFTWARDS ARROW TO BAR + "LeftArrowRightArrow", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "leftarrowtail", 0x021A2, // LEFTWARDS ARROW WITH TAIL + "LeftCeiling", 0x02308, // LEFT CEILING + "LeftDoubleBracket", 0x027E6, // MATHEMATICAL LEFT WHITE SQUARE BRACKET + "LeftDownTeeVector", 0x02961, // DOWNWARDS HARPOON WITH BARB LEFT FROM BAR + "LeftDownVector", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "LeftDownVectorBar", 0x02959, // DOWNWARDS HARPOON WITH BARB LEFT TO BAR + "LeftFloor", 0x0230A, // LEFT FLOOR + "leftharpoondown", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "leftharpoonup", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "leftleftarrows", 0x021C7, // LEFTWARDS PAIRED ARROWS + "leftrightarrow", 0x02194, // LEFT RIGHT ARROW + "LeftRightArrow", 0x02194, // LEFT RIGHT ARROW + "Leftrightarrow", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "leftrightarrows", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "leftrightharpoons", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "leftrightsquigarrow", 0x021AD, // LEFT RIGHT WAVE ARROW + "LeftRightVector", 0x0294E, // LEFT BARB UP RIGHT BARB UP HARPOON + "LeftTee", 0x022A3, // LEFT TACK + "LeftTeeArrow", 0x021A4, // LEFTWARDS ARROW FROM BAR + "LeftTeeVector", 0x0295A, // LEFTWARDS HARPOON WITH BARB UP FROM BAR + "leftthreetimes", 0x022CB, // LEFT SEMIDIRECT PRODUCT + "LeftTriangle", 0x022B2, // NORMAL SUBGROUP OF + "LeftTriangleBar", 0x029CF, // LEFT TRIANGLE BESIDE VERTICAL BAR + "LeftTriangleEqual", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "LeftUpDownVector", 0x02951, // UP BARB LEFT DOWN BARB LEFT HARPOON + "LeftUpTeeVector", 0x02960, // UPWARDS HARPOON WITH BARB LEFT FROM BAR + "LeftUpVector", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "LeftUpVectorBar", 0x02958, // UPWARDS HARPOON WITH BARB LEFT TO BAR + "LeftVector", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "LeftVectorBar", 0x02952, // LEFTWARDS HARPOON WITH BARB UP TO BAR + "leg", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "lEg", 0x02A8B, // LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN + "leq", 0x02264, // LESS-THAN OR EQUAL TO + "leqq", 0x02266, // LESS-THAN OVER EQUAL TO + "leqslant", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "les", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "lescc", 0x02AA8, // LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL + "lesdot", 0x02A7F, // LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE + "lesdoto", 0x02A81, // LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE + "lesdotor", 0x02A83, // LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT +// "lesg", 0x022DA;0x0FE00, // LESS-THAN slanted EQUAL TO OR GREATER-THAN + "lesges", 0x02A93, // LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL + "lessapprox", 0x02A85, // LESS-THAN OR APPROXIMATE + "lessdot", 0x022D6, // LESS-THAN WITH DOT + "lesseqgtr", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "lesseqqgtr", 0x02A8B, // LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN + "LessEqualGreater", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "LessFullEqual", 0x02266, // LESS-THAN OVER EQUAL TO + "LessGreater", 0x02276, // LESS-THAN OR GREATER-THAN + "lessgtr", 0x02276, // LESS-THAN OR GREATER-THAN + "LessLess", 0x02AA1, // DOUBLE NESTED LESS-THAN + "lesssim", 0x02272, // LESS-THAN OR EQUIVALENT TO + "LessSlantEqual", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "LessTilde", 0x02272, // LESS-THAN OR EQUIVALENT TO + "lfisht", 0x0297C, // LEFT FISH TAIL + "lfloor", 0x0230A, // LEFT FLOOR + "Lfr", 0x1D50F, // MATHEMATICAL FRAKTUR CAPITAL L + "lfr", 0x1D529, // MATHEMATICAL FRAKTUR SMALL L + "lg", 0x02276, // LESS-THAN OR GREATER-THAN + "lgE", 0x02A91, // LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL + "Lgr", 0x0039B, // GREEK CAPITAL LETTER LAMDA + "lgr", 0x003BB, // GREEK SMALL LETTER LAMDA + "lHar", 0x02962, // LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN + "lhard", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "lharu", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "lharul", 0x0296A, // LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH + "lhblk", 0x02584, // LOWER HALF BLOCK + "LJcy", 0x00409, // CYRILLIC CAPITAL LETTER LJE + "ljcy", 0x00459, // CYRILLIC SMALL LETTER LJE + "ll", 0x0226A, // MUCH LESS-THAN + "Ll", 0x022D8, // VERY MUCH LESS-THAN + "llarr", 0x021C7, // LEFTWARDS PAIRED ARROWS + "llcorner", 0x0231E, // BOTTOM LEFT CORNER + "Lleftarrow", 0x021DA, // LEFTWARDS TRIPLE ARROW + "llhard", 0x0296B, // LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH + "lltri", 0x025FA, // LOWER LEFT TRIANGLE + "Lmidot", 0x0013F, // LATIN CAPITAL LETTER L WITH MIDDLE DOT + "lmidot", 0x00140, // LATIN SMALL LETTER L WITH MIDDLE DOT + "lmoust", 0x023B0, // UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION + "lmoustache", 0x023B0, // UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION + "lnap", 0x02A89, // LESS-THAN AND NOT APPROXIMATE + "lnapprox", 0x02A89, // LESS-THAN AND NOT APPROXIMATE + "lnE", 0x02268, // LESS-THAN BUT NOT EQUAL TO + "lne", 0x02A87, // LESS-THAN AND SINGLE-LINE NOT EQUAL TO + "lneq", 0x02A87, // LESS-THAN AND SINGLE-LINE NOT EQUAL TO + "lneqq", 0x02268, // LESS-THAN BUT NOT EQUAL TO + "lnsim", 0x022E6, // LESS-THAN BUT NOT EQUIVALENT TO + "loang", 0x027EC, // MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET + "loarr", 0x021FD, // LEFTWARDS OPEN-HEADED ARROW + "lobrk", 0x027E6, // MATHEMATICAL LEFT WHITE SQUARE BRACKET + "longleftarrow", 0x027F5, // LONG LEFTWARDS ARROW + "LongLeftArrow", 0x027F5, // LONG LEFTWARDS ARROW + "Longleftarrow", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "longleftrightarrow", 0x027F7, // LONG LEFT RIGHT ARROW + "LongLeftRightArrow", 0x027F7, // LONG LEFT RIGHT ARROW + "Longleftrightarrow", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "longmapsto", 0x027FC, // LONG RIGHTWARDS ARROW FROM BAR + "longrightarrow", 0x027F6, // LONG RIGHTWARDS ARROW + "LongRightArrow", 0x027F6, // LONG RIGHTWARDS ARROW + "Longrightarrow", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "looparrowleft", 0x021AB, // LEFTWARDS ARROW WITH LOOP + "looparrowright", 0x021AC, // RIGHTWARDS ARROW WITH LOOP + "lopar", 0x02985, // LEFT WHITE PARENTHESIS + "Lopf", 0x1D543, // MATHEMATICAL DOUBLE-STRUCK CAPITAL L + "lopf", 0x1D55D, // MATHEMATICAL DOUBLE-STRUCK SMALL L + "loplus", 0x02A2D, // PLUS SIGN IN LEFT HALF CIRCLE + "lotimes", 0x02A34, // MULTIPLICATION SIGN IN LEFT HALF CIRCLE + "lowast", 0x02217, // ASTERISK OPERATOR + "lowbar", 0x0005F, // LOW LINE + "LowerLeftArrow", 0x02199, // SOUTH WEST ARROW + "LowerRightArrow", 0x02198, // SOUTH EAST ARROW + "loz", 0x025CA, // LOZENGE + "lozenge", 0x025CA, // LOZENGE + "lozf", 0x029EB, // BLACK LOZENGE + "lpar", 0x00028, // LEFT PARENTHESIS + "lparlt", 0x02993, // LEFT ARC LESS-THAN BRACKET + "lrarr", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "lrcorner", 0x0231F, // BOTTOM RIGHT CORNER + "lrhar", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "lrhard", 0x0296D, // RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH + "lrm", 0x0200E, // LEFT-TO-RIGHT MARK + "lrtri", 0x022BF, // RIGHT TRIANGLE + "lsaquo", 0x02039, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK + "Lscr", 0x02112, // SCRIPT CAPITAL L + "lscr", 0x1D4C1, // MATHEMATICAL SCRIPT SMALL L + "lsh", 0x021B0, // UPWARDS ARROW WITH TIP LEFTWARDS + "Lsh", 0x021B0, // UPWARDS ARROW WITH TIP LEFTWARDS + "lsim", 0x02272, // LESS-THAN OR EQUIVALENT TO + "lsime", 0x02A8D, // LESS-THAN ABOVE SIMILAR OR EQUAL + "lsimg", 0x02A8F, // LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN + "lsqb", 0x0005B, // LEFT SQUARE BRACKET + "lsquo", 0x02018, // LEFT SINGLE QUOTATION MARK + "lsquor", 0x0201A, // SINGLE LOW-9 QUOTATION MARK + "Lstrok", 0x00141, // LATIN CAPITAL LETTER L WITH STROKE + "lstrok", 0x00142, // LATIN SMALL LETTER L WITH STROKE + "lt", 0x0003C, // LESS-THAN SIGN + "LT", 0x0003C, // LESS-THAN SIGN + "Lt", 0x0226A, // MUCH LESS-THAN + "ltcc", 0x02AA6, // LESS-THAN CLOSED BY CURVE + "ltcir", 0x02A79, // LESS-THAN WITH CIRCLE INSIDE + "ltdot", 0x022D6, // LESS-THAN WITH DOT + "lthree", 0x022CB, // LEFT SEMIDIRECT PRODUCT + "ltimes", 0x022C9, // LEFT NORMAL FACTOR SEMIDIRECT PRODUCT + "ltlarr", 0x02976, // LESS-THAN ABOVE LEFTWARDS ARROW + "ltquest", 0x02A7B, // LESS-THAN WITH QUESTION MARK ABOVE + "ltri", 0x025C3, // WHITE LEFT-POINTING SMALL TRIANGLE + "ltrie", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "ltrif", 0x025C2, // BLACK LEFT-POINTING SMALL TRIANGLE + "ltrPar", 0x02996, // DOUBLE RIGHT ARC LESS-THAN BRACKET + "lurdshar", 0x0294A, // LEFT BARB UP RIGHT BARB DOWN HARPOON + "luruhar", 0x02966, // LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP +// "lvertneqq", 0x02268;0x0FE00, // LESS-THAN BUT NOT EQUAL TO - with vertical stroke +// "lvnE", 0x02268;0x0FE00, // LESS-THAN BUT NOT EQUAL TO - with vertical stroke + NULL, 0 +}; + +static NameId namesM[]={ + "macr", 0x000AF, // MACRON + "male", 0x02642, // MALE SIGN + "malt", 0x02720, // MALTESE CROSS + "maltese", 0x02720, // MALTESE CROSS + "map", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "Map", 0x02905, // RIGHTWARDS TWO-HEADED ARROW FROM BAR + "mapsto", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "mapstodown", 0x021A7, // DOWNWARDS ARROW FROM BAR + "mapstoleft", 0x021A4, // LEFTWARDS ARROW FROM BAR + "mapstoup", 0x021A5, // UPWARDS ARROW FROM BAR + "marker", 0x025AE, // BLACK VERTICAL RECTANGLE + "mcomma", 0x02A29, // MINUS SIGN WITH COMMA ABOVE + "Mcy", 0x0041C, // CYRILLIC CAPITAL LETTER EM + "mcy", 0x0043C, // CYRILLIC SMALL LETTER EM + "mdash", 0x02014, // EM DASH + "mDDot", 0x0223A, // GEOMETRIC PROPORTION + "measuredangle", 0x02221, // MEASURED ANGLE + "MediumSpace", 0x0205F, // MEDIUM MATHEMATICAL SPACE + "Mellintrf", 0x02133, // SCRIPT CAPITAL M + "Mfr", 0x1D510, // MATHEMATICAL FRAKTUR CAPITAL M + "mfr", 0x1D52A, // MATHEMATICAL FRAKTUR SMALL M + "Mgr", 0x0039C, // GREEK CAPITAL LETTER MU + "mgr", 0x003BC, // GREEK SMALL LETTER MU + "mho", 0x02127, // INVERTED OHM SIGN + "micro", 0x000B5, // MICRO SIGN + "mid", 0x02223, // DIVIDES + "midast", 0x0002A, // ASTERISK + "midcir", 0x02AF0, // VERTICAL LINE WITH CIRCLE BELOW + "middot", 0x000B7, // MIDDLE DOT + "minus", 0x02212, // MINUS SIGN + "minusb", 0x0229F, // SQUARED MINUS + "minusd", 0x02238, // DOT MINUS + "minusdu", 0x02A2A, // MINUS SIGN WITH DOT BELOW + "MinusPlus", 0x02213, // MINUS-OR-PLUS SIGN + "mlcp", 0x02ADB, // TRANSVERSAL INTERSECTION + "mldr", 0x02026, // HORIZONTAL ELLIPSIS + "mnplus", 0x02213, // MINUS-OR-PLUS SIGN + "models", 0x022A7, // MODELS + "Mopf", 0x1D544, // MATHEMATICAL DOUBLE-STRUCK CAPITAL M + "mopf", 0x1D55E, // MATHEMATICAL DOUBLE-STRUCK SMALL M + "mp", 0x02213, // MINUS-OR-PLUS SIGN + "Mscr", 0x02133, // SCRIPT CAPITAL M + "mscr", 0x1D4C2, // MATHEMATICAL SCRIPT SMALL M + "mstpos", 0x0223E, // INVERTED LAZY S + "Mu", 0x0039C, // GREEK CAPITAL LETTER MU + "mu", 0x003BC, // GREEK SMALL LETTER MU + "multimap", 0x022B8, // MULTIMAP + "mumap", 0x022B8, // MULTIMAP + NULL, 0 +}; + +static NameId namesN[]={ + "nabla", 0x02207, // NABLA + "Nacute", 0x00143, // LATIN CAPITAL LETTER N WITH ACUTE + "nacute", 0x00144, // LATIN SMALL LETTER N WITH ACUTE +// "nang", 0x02220;0x020D2, // ANGLE with vertical line + "nap", 0x02249, // NOT ALMOST EQUAL TO +// "napE", 0x02A70;0x00338, // APPROXIMATELY EQUAL OR EQUAL TO with slash +// "napid", 0x0224B;0x00338, // TRIPLE TILDE with slash + "napos", 0x00149, // LATIN SMALL LETTER N PRECEDED BY APOSTROPHE + "napprox", 0x02249, // NOT ALMOST EQUAL TO + "natur", 0x0266E, // MUSIC NATURAL SIGN + "natural", 0x0266E, // MUSIC NATURAL SIGN + "naturals", 0x02115, // DOUBLE-STRUCK CAPITAL N + "nbsp", 0x000A0, // NO-BREAK SPACE +// "nbump", 0x0224E;0x00338, // GEOMETRICALLY EQUIVALENT TO with slash +// "nbumpe", 0x0224F;0x00338, // DIFFERENCE BETWEEN with slash + "ncap", 0x02A43, // INTERSECTION WITH OVERBAR + "Ncaron", 0x00147, // LATIN CAPITAL LETTER N WITH CARON + "ncaron", 0x00148, // LATIN SMALL LETTER N WITH CARON + "Ncedil", 0x00145, // LATIN CAPITAL LETTER N WITH CEDILLA + "ncedil", 0x00146, // LATIN SMALL LETTER N WITH CEDILLA + "ncong", 0x02247, // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO +// "ncongdot", 0x02A6D;0x00338, // CONGRUENT WITH DOT ABOVE with slash + "ncup", 0x02A42, // UNION WITH OVERBAR + "Ncy", 0x0041D, // CYRILLIC CAPITAL LETTER EN + "ncy", 0x0043D, // CYRILLIC SMALL LETTER EN + "ndash", 0x02013, // EN DASH + "ne", 0x02260, // NOT EQUAL TO + "nearhk", 0x02924, // NORTH EAST ARROW WITH HOOK + "nearr", 0x02197, // NORTH EAST ARROW + "neArr", 0x021D7, // NORTH EAST DOUBLE ARROW + "nearrow", 0x02197, // NORTH EAST ARROW +// "nedot", 0x02250;0x00338, // APPROACHES THE LIMIT with slash + "NegativeMediumSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeThickSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeThinSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeVeryThinSpace", 0x0200B, // ZERO WIDTH SPACE + "nequiv", 0x02262, // NOT IDENTICAL TO + "nesear", 0x02928, // NORTH EAST ARROW AND SOUTH EAST ARROW +// "nesim", 0x02242;0x00338, // MINUS TILDE with slash + "NestedGreaterGreater", 0x0226B, // MUCH GREATER-THAN + "NestedLessLess", 0x0226A, // MUCH LESS-THAN + "NewLine", 0x0000A, // LINE FEED (LF) + "nexist", 0x02204, // THERE DOES NOT EXIST + "nexists", 0x02204, // THERE DOES NOT EXIST + "Nfr", 0x1D511, // MATHEMATICAL FRAKTUR CAPITAL N + "nfr", 0x1D52B, // MATHEMATICAL FRAKTUR SMALL N +// "ngE", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash + "nge", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO + "ngeq", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO +// "ngeqq", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash +// "ngeqslant", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash +// "nges", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash +// "nGg", 0x022D9;0x00338, // VERY MUCH GREATER-THAN with slash + "Ngr", 0x0039D, // GREEK CAPITAL LETTER NU + "ngr", 0x003BD, // GREEK SMALL LETTER NU + "ngsim", 0x02275, // NEITHER GREATER-THAN NOR EQUIVALENT TO +// "nGt", 0x0226B;0x020D2, // MUCH GREATER THAN with vertical line + "ngt", 0x0226F, // NOT GREATER-THAN + "ngtr", 0x0226F, // NOT GREATER-THAN +// "nGtv", 0x0226B;0x00338, // MUCH GREATER THAN with slash + "nharr", 0x021AE, // LEFT RIGHT ARROW WITH STROKE + "nhArr", 0x021CE, // LEFT RIGHT DOUBLE ARROW WITH STROKE + "nhpar", 0x02AF2, // PARALLEL WITH HORIZONTAL STROKE + "ni", 0x0220B, // CONTAINS AS MEMBER + "nis", 0x022FC, // SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "nisd", 0x022FA, // CONTAINS WITH LONG HORIZONTAL STROKE + "niv", 0x0220B, // CONTAINS AS MEMBER + "NJcy", 0x0040A, // CYRILLIC CAPITAL LETTER NJE + "njcy", 0x0045A, // CYRILLIC SMALL LETTER NJE + "nlarr", 0x0219A, // LEFTWARDS ARROW WITH STROKE + "nlArr", 0x021CD, // LEFTWARDS DOUBLE ARROW WITH STROKE + "nldr", 0x02025, // TWO DOT LEADER +// "nlE", 0x02266;0x00338, // LESS-THAN OVER EQUAL TO with slash + "nle", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO + "nleftarrow", 0x0219A, // LEFTWARDS ARROW WITH STROKE + "nLeftarrow", 0x021CD, // LEFTWARDS DOUBLE ARROW WITH STROKE + "nleftrightarrow", 0x021AE, // LEFT RIGHT ARROW WITH STROKE + "nLeftrightarrow", 0x021CE, // LEFT RIGHT DOUBLE ARROW WITH STROKE + "nleq", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO +// "nleqq", 0x02266;0x00338, // LESS-THAN OVER EQUAL TO with slash +// "nleqslant", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash +// "nles", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash + "nless", 0x0226E, // NOT LESS-THAN +// "nLl", 0x022D8;0x00338, // VERY MUCH LESS-THAN with slash + "nlsim", 0x02274, // NEITHER LESS-THAN NOR EQUIVALENT TO +// "nLt", 0x0226A;0x020D2, // MUCH LESS THAN with vertical line + "nlt", 0x0226E, // NOT LESS-THAN + "nltri", 0x022EA, // NOT NORMAL SUBGROUP OF + "nltrie", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO +// "nLtv", 0x0226A;0x00338, // MUCH LESS THAN with slash + "nmid", 0x02224, // DOES NOT DIVIDE + "NoBreak", 0x02060, // WORD JOINER + "NonBreakingSpace", 0x000A0, // NO-BREAK SPACE + "Nopf", 0x02115, // DOUBLE-STRUCK CAPITAL N + "nopf", 0x1D55F, // MATHEMATICAL DOUBLE-STRUCK SMALL N + "not", 0x000AC, // NOT SIGN + "Not", 0x02AEC, // DOUBLE STROKE NOT SIGN + "NotCongruent", 0x02262, // NOT IDENTICAL TO + "NotCupCap", 0x0226D, // NOT EQUIVALENT TO + "NotDoubleVerticalBar", 0x02226, // NOT PARALLEL TO + "NotElement", 0x02209, // NOT AN ELEMENT OF + "NotEqual", 0x02260, // NOT EQUAL TO +// "NotEqualTilde", 0x02242;0x00338, // MINUS TILDE with slash + "NotExists", 0x02204, // THERE DOES NOT EXIST + "NotGreater", 0x0226F, // NOT GREATER-THAN + "NotGreaterEqual", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO +// "NotGreaterFullEqual", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash +// "NotGreaterGreater", 0x0226B;0x00338, // MUCH GREATER THAN with slash + "NotGreaterLess", 0x02279, // NEITHER GREATER-THAN NOR LESS-THAN +// "NotGreaterSlantEqual", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash + "NotGreaterTilde", 0x02275, // NEITHER GREATER-THAN NOR EQUIVALENT TO +// "NotHumpDownHump", 0x0224E;0x00338, // GEOMETRICALLY EQUIVALENT TO with slash +// "NotHumpEqual", 0x0224F;0x00338, // DIFFERENCE BETWEEN with slash + "notin", 0x02209, // NOT AN ELEMENT OF +// "notindot", 0x022F5;0x00338, // ELEMENT OF WITH DOT ABOVE with slash +// "notinE", 0x022F9;0x00338, // ELEMENT OF WITH TWO HORIZONTAL STROKES with slash + "notinva", 0x02209, // NOT AN ELEMENT OF + "notinvb", 0x022F7, // SMALL ELEMENT OF WITH OVERBAR + "notinvc", 0x022F6, // ELEMENT OF WITH OVERBAR + "NotLeftTriangle", 0x022EA, // NOT NORMAL SUBGROUP OF +// "NotLeftTriangleBar", 0x029CF;0x00338, // LEFT TRIANGLE BESIDE VERTICAL BAR with slash + "NotLeftTriangleEqual", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO + "NotLess", 0x0226E, // NOT LESS-THAN + "NotLessEqual", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO + "NotLessGreater", 0x02278, // NEITHER LESS-THAN NOR GREATER-THAN +// "NotLessLess", 0x0226A;0x00338, // MUCH LESS THAN with slash +// "NotLessSlantEqual", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash + "NotLessTilde", 0x02274, // NEITHER LESS-THAN NOR EQUIVALENT TO +// "NotNestedGreaterGreater", 0x02AA2;0x00338, // DOUBLE NESTED GREATER-THAN with slash +// "NotNestedLessLess", 0x02AA1;0x00338, // DOUBLE NESTED LESS-THAN with slash + "notni", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "notniva", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "notnivb", 0x022FE, // SMALL CONTAINS WITH OVERBAR + "notnivc", 0x022FD, // CONTAINS WITH OVERBAR + "NotPrecedes", 0x02280, // DOES NOT PRECEDE +// "NotPrecedesEqual", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "NotPrecedesSlantEqual", 0x022E0, // DOES NOT PRECEDE OR EQUAL + "NotReverseElement", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "NotRightTriangle", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP +// "NotRightTriangleBar", 0x029D0;0x00338, // VERTICAL BAR BESIDE RIGHT TRIANGLE with slash + "NotRightTriangleEqual", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL +// "NotSquareSubset", 0x0228F;0x00338, // SQUARE IMAGE OF with slash + "NotSquareSubsetEqual", 0x022E2, // NOT SQUARE IMAGE OF OR EQUAL TO +// "NotSquareSuperset", 0x02290;0x00338, // SQUARE ORIGINAL OF with slash + "NotSquareSupersetEqual", 0x022E3, // NOT SQUARE ORIGINAL OF OR EQUAL TO +// "NotSubset", 0x02282;0x020D2, // SUBSET OF with vertical line + "NotSubsetEqual", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO + "NotSucceeds", 0x02281, // DOES NOT SUCCEED +// "NotSucceedsEqual", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "NotSucceedsSlantEqual", 0x022E1, // DOES NOT SUCCEED OR EQUAL +// "NotSucceedsTilde", 0x0227F;0x00338, // SUCCEEDS OR EQUIVALENT TO with slash +// "NotSuperset", 0x02283;0x020D2, // SUPERSET OF with vertical line + "NotSupersetEqual", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO + "NotTilde", 0x02241, // NOT TILDE + "NotTildeEqual", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "NotTildeFullEqual", 0x02247, // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO + "NotTildeTilde", 0x02249, // NOT ALMOST EQUAL TO + "NotVerticalBar", 0x02224, // DOES NOT DIVIDE + "npar", 0x02226, // NOT PARALLEL TO + "nparallel", 0x02226, // NOT PARALLEL TO +// "nparsl", 0x02AFD;0x020E5, // DOUBLE SOLIDUS OPERATOR with reverse slash +// "npart", 0x02202;0x00338, // PARTIAL DIFFERENTIAL with slash + "npolint", 0x02A14, // LINE INTEGRATION NOT INCLUDING THE POLE + "npr", 0x02280, // DOES NOT PRECEDE + "nprcue", 0x022E0, // DOES NOT PRECEDE OR EQUAL +// "npre", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "nprec", 0x02280, // DOES NOT PRECEDE +// "npreceq", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "nrarr", 0x0219B, // RIGHTWARDS ARROW WITH STROKE + "nrArr", 0x021CF, // RIGHTWARDS DOUBLE ARROW WITH STROKE +// "nrarrc", 0x02933;0x00338, // WAVE ARROW POINTING DIRECTLY RIGHT with slash +// "nrarrw", 0x0219D;0x00338, // RIGHTWARDS WAVE ARROW with slash + "nrightarrow", 0x0219B, // RIGHTWARDS ARROW WITH STROKE + "nRightarrow", 0x021CF, // RIGHTWARDS DOUBLE ARROW WITH STROKE + "nrtri", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP + "nrtrie", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL + "nsc", 0x02281, // DOES NOT SUCCEED + "nsccue", 0x022E1, // DOES NOT SUCCEED OR EQUAL +// "nsce", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "Nscr", 0x1D4A9, // MATHEMATICAL SCRIPT CAPITAL N + "nscr", 0x1D4C3, // MATHEMATICAL SCRIPT SMALL N + "nshortmid", 0x02224, // DOES NOT DIVIDE + "nshortparallel", 0x02226, // NOT PARALLEL TO + "nsim", 0x02241, // NOT TILDE + "nsime", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "nsimeq", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "nsmid", 0x02224, // DOES NOT DIVIDE + "nspar", 0x02226, // NOT PARALLEL TO + "nsqsube", 0x022E2, // NOT SQUARE IMAGE OF OR EQUAL TO + "nsqsupe", 0x022E3, // NOT SQUARE ORIGINAL OF OR EQUAL TO + "nsub", 0x02284, // NOT A SUBSET OF + "nsube", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO +// "nsubE", 0x02AC5;0x00338, // SUBSET OF ABOVE EQUALS SIGN with slash +// "nsubset", 0x02282;0x020D2, // SUBSET OF with vertical line + "nsubseteq", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO +// "nsubseteqq", 0x02AC5;0x00338, // SUBSET OF ABOVE EQUALS SIGN with slash + "nsucc", 0x02281, // DOES NOT SUCCEED +// "nsucceq", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "nsup", 0x02285, // NOT A SUPERSET OF + "nsupe", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO +// "nsupE", 0x02AC6;0x00338, // SUPERSET OF ABOVE EQUALS SIGN with slash +// "nsupset", 0x02283;0x020D2, // SUPERSET OF with vertical line + "nsupseteq", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO +// "nsupseteqq", 0x02AC6;0x00338, // SUPERSET OF ABOVE EQUALS SIGN with slash + "ntgl", 0x02279, // NEITHER GREATER-THAN NOR LESS-THAN + "Ntilde", 0x000D1, // LATIN CAPITAL LETTER N WITH TILDE + "ntilde", 0x000F1, // LATIN SMALL LETTER N WITH TILDE + "ntlg", 0x02278, // NEITHER LESS-THAN NOR GREATER-THAN + "ntriangleleft", 0x022EA, // NOT NORMAL SUBGROUP OF + "ntrianglelefteq", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO + "ntriangleright", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP + "ntrianglerighteq", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL + "Nu", 0x0039D, // GREEK CAPITAL LETTER NU + "nu", 0x003BD, // GREEK SMALL LETTER NU + "num", 0x00023, // NUMBER SIGN + "numero", 0x02116, // NUMERO SIGN + "numsp", 0x02007, // FIGURE SPACE +// "nvap", 0x0224D;0x020D2, // EQUIVALENT TO with vertical line + "nvdash", 0x022AC, // DOES NOT PROVE + "nvDash", 0x022AD, // NOT TRUE + "nVdash", 0x022AE, // DOES NOT FORCE + "nVDash", 0x022AF, // NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE +// "nvge", 0x02265;0x020D2, // GREATER-THAN OR EQUAL TO with vertical line +// "nvgt", 0x0003E;0x020D2, // GREATER-THAN SIGN with vertical line + "nvHarr", 0x02904, // LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE + "nvinfin", 0x029DE, // INFINITY NEGATED WITH VERTICAL BAR + "nvlArr", 0x02902, // LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE +// "nvle", 0x02264;0x020D2, // LESS-THAN OR EQUAL TO with vertical line +// "nvlt", 0x0003C;0x020D2, // LESS-THAN SIGN with vertical line +// "nvltrie", 0x022B4;0x020D2, // NORMAL SUBGROUP OF OR EQUAL TO with vertical line + "nvrArr", 0x02903, // RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE +// "nvrtrie", 0x022B5;0x020D2, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO with vertical line +// "nvsim", 0x0223C;0x020D2, // TILDE OPERATOR with vertical line + "nwarhk", 0x02923, // NORTH WEST ARROW WITH HOOK + "nwarr", 0x02196, // NORTH WEST ARROW + "nwArr", 0x021D6, // NORTH WEST DOUBLE ARROW + "nwarrow", 0x02196, // NORTH WEST ARROW + "nwnear", 0x02927, // NORTH WEST ARROW AND NORTH EAST ARROW + NULL, 0 +}; + +static NameId namesO[]={ + "Oacgr", 0x0038C, // GREEK CAPITAL LETTER OMICRON WITH TONOS + "oacgr", 0x003CC, // GREEK SMALL LETTER OMICRON WITH TONOS + "Oacute", 0x000D3, // LATIN CAPITAL LETTER O WITH ACUTE + "oacute", 0x000F3, // LATIN SMALL LETTER O WITH ACUTE + "oast", 0x0229B, // CIRCLED ASTERISK OPERATOR + "ocir", 0x0229A, // CIRCLED RING OPERATOR + "Ocirc", 0x000D4, // LATIN CAPITAL LETTER O WITH CIRCUMFLEX + "ocirc", 0x000F4, // LATIN SMALL LETTER O WITH CIRCUMFLEX + "Ocy", 0x0041E, // CYRILLIC CAPITAL LETTER O + "ocy", 0x0043E, // CYRILLIC SMALL LETTER O + "odash", 0x0229D, // CIRCLED DASH + "Odblac", 0x00150, // LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + "odblac", 0x00151, // LATIN SMALL LETTER O WITH DOUBLE ACUTE + "odiv", 0x02A38, // CIRCLED DIVISION SIGN + "odot", 0x02299, // CIRCLED DOT OPERATOR + "odsold", 0x029BC, // CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN + "OElig", 0x00152, // LATIN CAPITAL LIGATURE OE + "oelig", 0x00153, // LATIN SMALL LIGATURE OE + "ofcir", 0x029BF, // CIRCLED BULLET + "Ofr", 0x1D512, // MATHEMATICAL FRAKTUR CAPITAL O + "ofr", 0x1D52C, // MATHEMATICAL FRAKTUR SMALL O + "ogon", 0x002DB, // OGONEK + "Ogr", 0x0039F, // GREEK CAPITAL LETTER OMICRON + "ogr", 0x003BF, // GREEK SMALL LETTER OMICRON + "Ograve", 0x000D2, // LATIN CAPITAL LETTER O WITH GRAVE + "ograve", 0x000F2, // LATIN SMALL LETTER O WITH GRAVE + "ogt", 0x029C1, // CIRCLED GREATER-THAN + "OHacgr", 0x0038F, // GREEK CAPITAL LETTER OMEGA WITH TONOS + "ohacgr", 0x003CE, // GREEK SMALL LETTER OMEGA WITH TONOS + "ohbar", 0x029B5, // CIRCLE WITH HORIZONTAL BAR + "OHgr", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "ohgr", 0x003C9, // GREEK SMALL LETTER OMEGA + "ohm", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "oint", 0x0222E, // CONTOUR INTEGRAL + "olarr", 0x021BA, // ANTICLOCKWISE OPEN CIRCLE ARROW + "olcir", 0x029BE, // CIRCLED WHITE BULLET + "olcross", 0x029BB, // CIRCLE WITH SUPERIMPOSED X + "oline", 0x0203E, // OVERLINE + "olt", 0x029C0, // CIRCLED LESS-THAN + "Omacr", 0x0014C, // LATIN CAPITAL LETTER O WITH MACRON + "omacr", 0x0014D, // LATIN SMALL LETTER O WITH MACRON + "Omega", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "omega", 0x003C9, // GREEK SMALL LETTER OMEGA + "Omicron", 0x0039F, // GREEK CAPITAL LETTER OMICRON + "omicron", 0x003BF, // GREEK SMALL LETTER OMICRON + "omid", 0x029B6, // CIRCLED VERTICAL BAR + "ominus", 0x02296, // CIRCLED MINUS + "Oopf", 0x1D546, // MATHEMATICAL DOUBLE-STRUCK CAPITAL O + "oopf", 0x1D560, // MATHEMATICAL DOUBLE-STRUCK SMALL O + "opar", 0x029B7, // CIRCLED PARALLEL + "OpenCurlyDoubleQuote", 0x0201C, // LEFT DOUBLE QUOTATION MARK + "OpenCurlyQuote", 0x02018, // LEFT SINGLE QUOTATION MARK + "operp", 0x029B9, // CIRCLED PERPENDICULAR + "oplus", 0x02295, // CIRCLED PLUS + "or", 0x02228, // LOGICAL OR + "Or", 0x02A54, // DOUBLE LOGICAL OR + "orarr", 0x021BB, // CLOCKWISE OPEN CIRCLE ARROW + "ord", 0x02A5D, // LOGICAL OR WITH HORIZONTAL DASH + "order", 0x02134, // SCRIPT SMALL O + "orderof", 0x02134, // SCRIPT SMALL O + "ordf", 0x000AA, // FEMININE ORDINAL INDICATOR + "ordm", 0x000BA, // MASCULINE ORDINAL INDICATOR + "origof", 0x022B6, // ORIGINAL OF + "oror", 0x02A56, // TWO INTERSECTING LOGICAL OR + "orslope", 0x02A57, // SLOPING LARGE OR + "orv", 0x02A5B, // LOGICAL OR WITH MIDDLE STEM + "oS", 0x024C8, // CIRCLED LATIN CAPITAL LETTER S + "oscr", 0x02134, // SCRIPT SMALL O + "Oscr", 0x1D4AA, // MATHEMATICAL SCRIPT CAPITAL O + "Oslash", 0x000D8, // LATIN CAPITAL LETTER O WITH STROKE + "oslash", 0x000F8, // LATIN SMALL LETTER O WITH STROKE + "osol", 0x02298, // CIRCLED DIVISION SLASH + "Otilde", 0x000D5, // LATIN CAPITAL LETTER O WITH TILDE + "otilde", 0x000F5, // LATIN SMALL LETTER O WITH TILDE + "otimes", 0x02297, // CIRCLED TIMES + "Otimes", 0x02A37, // MULTIPLICATION SIGN IN DOUBLE CIRCLE + "otimesas", 0x02A36, // CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT + "Ouml", 0x000D6, // LATIN CAPITAL LETTER O WITH DIAERESIS + "ouml", 0x000F6, // LATIN SMALL LETTER O WITH DIAERESIS + "ovbar", 0x0233D, // APL FUNCTIONAL SYMBOL CIRCLE STILE + "OverBar", 0x0203E, // OVERLINE + "OverBrace", 0x023DE, // TOP CURLY BRACKET + "OverBracket", 0x023B4, // TOP SQUARE BRACKET + "OverParenthesis", 0x023DC, // TOP PARENTHESIS + NULL, 0 +}; + +static NameId namesP[]={ + "par", 0x02225, // PARALLEL TO + "para", 0x000B6, // PILCROW SIGN + "parallel", 0x02225, // PARALLEL TO + "parsim", 0x02AF3, // PARALLEL WITH TILDE OPERATOR + "parsl", 0x02AFD, // DOUBLE SOLIDUS OPERATOR + "part", 0x02202, // PARTIAL DIFFERENTIAL + "PartialD", 0x02202, // PARTIAL DIFFERENTIAL + "Pcy", 0x0041F, // CYRILLIC CAPITAL LETTER PE + "pcy", 0x0043F, // CYRILLIC SMALL LETTER PE + "percnt", 0x00025, // PERCENT SIGN + "period", 0x0002E, // FULL STOP + "permil", 0x02030, // PER MILLE SIGN + "perp", 0x022A5, // UP TACK + "pertenk", 0x02031, // PER TEN THOUSAND SIGN + "Pfr", 0x1D513, // MATHEMATICAL FRAKTUR CAPITAL P + "pfr", 0x1D52D, // MATHEMATICAL FRAKTUR SMALL P + "Pgr", 0x003A0, // GREEK CAPITAL LETTER PI + "pgr", 0x003C0, // GREEK SMALL LETTER PI + "PHgr", 0x003A6, // GREEK CAPITAL LETTER PHI + "phgr", 0x003C6, // GREEK SMALL LETTER PHI + "Phi", 0x003A6, // GREEK CAPITAL LETTER PHI + "phi", 0x003C6, // GREEK SMALL LETTER PHI + "phiv", 0x003D5, // GREEK PHI SYMBOL + "phmmat", 0x02133, // SCRIPT CAPITAL M + "phone", 0x0260E, // BLACK TELEPHONE + "Pi", 0x003A0, // GREEK CAPITAL LETTER PI + "pi", 0x003C0, // GREEK SMALL LETTER PI + "pitchfork", 0x022D4, // PITCHFORK + "piv", 0x003D6, // GREEK PI SYMBOL + "planck", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "planckh", 0x0210E, // PLANCK CONSTANT + "plankv", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "plus", 0x0002B, // PLUS SIGN + "plusacir", 0x02A23, // PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE + "plusb", 0x0229E, // SQUARED PLUS + "pluscir", 0x02A22, // PLUS SIGN WITH SMALL CIRCLE ABOVE + "plusdo", 0x02214, // DOT PLUS + "plusdu", 0x02A25, // PLUS SIGN WITH DOT BELOW + "pluse", 0x02A72, // PLUS SIGN ABOVE EQUALS SIGN + "PlusMinus", 0x000B1, // PLUS-MINUS SIGN + "plusmn", 0x000B1, // PLUS-MINUS SIGN + "plussim", 0x02A26, // PLUS SIGN WITH TILDE BELOW + "plustwo", 0x02A27, // PLUS SIGN WITH SUBSCRIPT TWO + "pm", 0x000B1, // PLUS-MINUS SIGN + "Poincareplane", 0x0210C, // BLACK-LETTER CAPITAL H + "pointint", 0x02A15, // INTEGRAL AROUND A POINT OPERATOR + "Popf", 0x02119, // DOUBLE-STRUCK CAPITAL P + "popf", 0x1D561, // MATHEMATICAL DOUBLE-STRUCK SMALL P + "pound", 0x000A3, // POUND SIGN + "pr", 0x0227A, // PRECEDES + "Pr", 0x02ABB, // DOUBLE PRECEDES + "prap", 0x02AB7, // PRECEDES ABOVE ALMOST EQUAL TO + "prcue", 0x0227C, // PRECEDES OR EQUAL TO + "pre", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "prE", 0x02AB3, // PRECEDES ABOVE EQUALS SIGN + "prec", 0x0227A, // PRECEDES + "precapprox", 0x02AB7, // PRECEDES ABOVE ALMOST EQUAL TO + "preccurlyeq", 0x0227C, // PRECEDES OR EQUAL TO + "Precedes", 0x0227A, // PRECEDES + "PrecedesEqual", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "PrecedesSlantEqual", 0x0227C, // PRECEDES OR EQUAL TO + "PrecedesTilde", 0x0227E, // PRECEDES OR EQUIVALENT TO + "preceq", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "precnapprox", 0x02AB9, // PRECEDES ABOVE NOT ALMOST EQUAL TO + "precneqq", 0x02AB5, // PRECEDES ABOVE NOT EQUAL TO + "precnsim", 0x022E8, // PRECEDES BUT NOT EQUIVALENT TO + "precsim", 0x0227E, // PRECEDES OR EQUIVALENT TO + "prime", 0x02032, // PRIME + "Prime", 0x02033, // DOUBLE PRIME + "primes", 0x02119, // DOUBLE-STRUCK CAPITAL P + "prnap", 0x02AB9, // PRECEDES ABOVE NOT ALMOST EQUAL TO + "prnE", 0x02AB5, // PRECEDES ABOVE NOT EQUAL TO + "prnsim", 0x022E8, // PRECEDES BUT NOT EQUIVALENT TO + "prod", 0x0220F, // N-ARY PRODUCT + "Product", 0x0220F, // N-ARY PRODUCT + "profalar", 0x0232E, // ALL AROUND-PROFILE + "profline", 0x02312, // ARC + "profsurf", 0x02313, // SEGMENT + "prop", 0x0221D, // PROPORTIONAL TO + "Proportion", 0x02237, // PROPORTION + "Proportional", 0x0221D, // PROPORTIONAL TO + "propto", 0x0221D, // PROPORTIONAL TO + "prsim", 0x0227E, // PRECEDES OR EQUIVALENT TO + "prurel", 0x022B0, // PRECEDES UNDER RELATION + "Pscr", 0x1D4AB, // MATHEMATICAL SCRIPT CAPITAL P + "pscr", 0x1D4C5, // MATHEMATICAL SCRIPT SMALL P + "PSgr", 0x003A8, // GREEK CAPITAL LETTER PSI + "psgr", 0x003C8, // GREEK SMALL LETTER PSI + "Psi", 0x003A8, // GREEK CAPITAL LETTER PSI + "psi", 0x003C8, // GREEK SMALL LETTER PSI + "puncsp", 0x02008, // PUNCTUATION SPACE + NULL, 0 +}; + +static NameId namesQ[]={ + "Qfr", 0x1D514, // MATHEMATICAL FRAKTUR CAPITAL Q + "qfr", 0x1D52E, // MATHEMATICAL FRAKTUR SMALL Q + "qint", 0x02A0C, // QUADRUPLE INTEGRAL OPERATOR + "Qopf", 0x0211A, // DOUBLE-STRUCK CAPITAL Q + "qopf", 0x1D562, // MATHEMATICAL DOUBLE-STRUCK SMALL Q + "qprime", 0x02057, // QUADRUPLE PRIME + "Qscr", 0x1D4AC, // MATHEMATICAL SCRIPT CAPITAL Q + "qscr", 0x1D4C6, // MATHEMATICAL SCRIPT SMALL Q + "quaternions", 0x0210D, // DOUBLE-STRUCK CAPITAL H + "quatint", 0x02A16, // QUATERNION INTEGRAL OPERATOR + "quest", 0x0003F, // QUESTION MARK + "questeq", 0x0225F, // QUESTIONED EQUAL TO + "quot", 0x00022, // QUOTATION MARK + "QUOT", 0x00022, // QUOTATION MARK + NULL, 0 +}; + +static NameId namesR[]={ + "rAarr", 0x021DB, // RIGHTWARDS TRIPLE ARROW +// "race", 0x0223D;0x00331, // REVERSED TILDE with underline + "Racute", 0x00154, // LATIN CAPITAL LETTER R WITH ACUTE + "racute", 0x00155, // LATIN SMALL LETTER R WITH ACUTE + "radic", 0x0221A, // SQUARE ROOT + "raemptyv", 0x029B3, // EMPTY SET WITH RIGHT ARROW ABOVE + "rang", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "Rang", 0x027EB, // MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET + "rangd", 0x02992, // RIGHT ANGLE BRACKET WITH DOT + "range", 0x029A5, // REVERSED ANGLE WITH UNDERBAR + "rangle", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "raquo", 0x000BB, // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK + "rarr", 0x02192, // RIGHTWARDS ARROW + "Rarr", 0x021A0, // RIGHTWARDS TWO HEADED ARROW + "rArr", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "rarrap", 0x02975, // RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO + "rarrb", 0x021E5, // RIGHTWARDS ARROW TO BAR + "rarrbfs", 0x02920, // RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND + "rarrc", 0x02933, // WAVE ARROW POINTING DIRECTLY RIGHT + "rarrfs", 0x0291E, // RIGHTWARDS ARROW TO BLACK DIAMOND + "rarrhk", 0x021AA, // RIGHTWARDS ARROW WITH HOOK + "rarrlp", 0x021AC, // RIGHTWARDS ARROW WITH LOOP + "rarrpl", 0x02945, // RIGHTWARDS ARROW WITH PLUS BELOW + "rarrsim", 0x02974, // RIGHTWARDS ARROW ABOVE TILDE OPERATOR + "rarrtl", 0x021A3, // RIGHTWARDS ARROW WITH TAIL + "Rarrtl", 0x02916, // RIGHTWARDS TWO-HEADED ARROW WITH TAIL + "rarrw", 0x0219D, // RIGHTWARDS WAVE ARROW + "ratail", 0x0291A, // RIGHTWARDS ARROW-TAIL + "rAtail", 0x0291C, // RIGHTWARDS DOUBLE ARROW-TAIL + "ratio", 0x02236, // RATIO + "rationals", 0x0211A, // DOUBLE-STRUCK CAPITAL Q + "rbarr", 0x0290D, // RIGHTWARDS DOUBLE DASH ARROW + "rBarr", 0x0290F, // RIGHTWARDS TRIPLE DASH ARROW + "RBarr", 0x02910, // RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW + "rbbrk", 0x02773, // LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT + "rbrace", 0x0007D, // RIGHT CURLY BRACKET + "rbrack", 0x0005D, // RIGHT SQUARE BRACKET + "rbrke", 0x0298C, // RIGHT SQUARE BRACKET WITH UNDERBAR + "rbrksld", 0x0298E, // RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER + "rbrkslu", 0x02990, // RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER + "Rcaron", 0x00158, // LATIN CAPITAL LETTER R WITH CARON + "rcaron", 0x00159, // LATIN SMALL LETTER R WITH CARON + "Rcedil", 0x00156, // LATIN CAPITAL LETTER R WITH CEDILLA + "rcedil", 0x00157, // LATIN SMALL LETTER R WITH CEDILLA + "rceil", 0x02309, // RIGHT CEILING + "rcub", 0x0007D, // RIGHT CURLY BRACKET + "Rcy", 0x00420, // CYRILLIC CAPITAL LETTER ER + "rcy", 0x00440, // CYRILLIC SMALL LETTER ER + "rdca", 0x02937, // ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS + "rdldhar", 0x02969, // RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN + "rdquo", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "rdquor", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "rdsh", 0x021B3, // DOWNWARDS ARROW WITH TIP RIGHTWARDS + "Re", 0x0211C, // BLACK-LETTER CAPITAL R + "real", 0x0211C, // BLACK-LETTER CAPITAL R + "realine", 0x0211B, // SCRIPT CAPITAL R + "realpart", 0x0211C, // BLACK-LETTER CAPITAL R + "reals", 0x0211D, // DOUBLE-STRUCK CAPITAL R + "rect", 0x025AD, // WHITE RECTANGLE + "reg", 0x000AE, // REGISTERED SIGN + "REG", 0x000AE, // REGISTERED SIGN + "ReverseElement", 0x0220B, // CONTAINS AS MEMBER + "ReverseEquilibrium", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "ReverseUpEquilibrium", 0x0296F, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "rfisht", 0x0297D, // RIGHT FISH TAIL + "rfloor", 0x0230B, // RIGHT FLOOR + "Rfr", 0x0211C, // BLACK-LETTER CAPITAL R + "rfr", 0x1D52F, // MATHEMATICAL FRAKTUR SMALL R + "Rgr", 0x003A1, // GREEK CAPITAL LETTER RHO + "rgr", 0x003C1, // GREEK SMALL LETTER RHO + "rHar", 0x02964, // RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN + "rhard", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "rharu", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "rharul", 0x0296C, // RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH + "Rho", 0x003A1, // GREEK CAPITAL LETTER RHO + "rho", 0x003C1, // GREEK SMALL LETTER RHO + "rhov", 0x003F1, // GREEK RHO SYMBOL + "RightAngleBracket", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "rightarrow", 0x02192, // RIGHTWARDS ARROW + "RightArrow", 0x02192, // RIGHTWARDS ARROW + "Rightarrow", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "RightArrowBar", 0x021E5, // RIGHTWARDS ARROW TO BAR + "RightArrowLeftArrow", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rightarrowtail", 0x021A3, // RIGHTWARDS ARROW WITH TAIL + "RightCeiling", 0x02309, // RIGHT CEILING + "RightDoubleBracket", 0x027E7, // MATHEMATICAL RIGHT WHITE SQUARE BRACKET + "RightDownTeeVector", 0x0295D, // DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR + "RightDownVector", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "RightDownVectorBar", 0x02955, // DOWNWARDS HARPOON WITH BARB RIGHT TO BAR + "RightFloor", 0x0230B, // RIGHT FLOOR + "rightharpoondown", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "rightharpoonup", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "rightleftarrows", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rightleftharpoons", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "rightrightarrows", 0x021C9, // RIGHTWARDS PAIRED ARROWS + "rightsquigarrow", 0x0219D, // RIGHTWARDS WAVE ARROW + "RightTee", 0x022A2, // RIGHT TACK + "RightTeeArrow", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "RightTeeVector", 0x0295B, // RIGHTWARDS HARPOON WITH BARB UP FROM BAR + "rightthreetimes", 0x022CC, // RIGHT SEMIDIRECT PRODUCT + "RightTriangle", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "RightTriangleBar", 0x029D0, // VERTICAL BAR BESIDE RIGHT TRIANGLE + "RightTriangleEqual", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "RightUpDownVector", 0x0294F, // UP BARB RIGHT DOWN BARB RIGHT HARPOON + "RightUpTeeVector", 0x0295C, // UPWARDS HARPOON WITH BARB RIGHT FROM BAR + "RightUpVector", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "RightUpVectorBar", 0x02954, // UPWARDS HARPOON WITH BARB RIGHT TO BAR + "RightVector", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "RightVectorBar", 0x02953, // RIGHTWARDS HARPOON WITH BARB UP TO BAR + "ring", 0x002DA, // RING ABOVE + "risingdotseq", 0x02253, // IMAGE OF OR APPROXIMATELY EQUAL TO + "rlarr", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rlhar", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "rlm", 0x0200F, // RIGHT-TO-LEFT MARK + "rmoust", 0x023B1, // UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION + "rmoustache", 0x023B1, // UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION + "rnmid", 0x02AEE, // DOES NOT DIVIDE WITH REVERSED NEGATION SLASH + "roang", 0x027ED, // MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET + "roarr", 0x021FE, // RIGHTWARDS OPEN-HEADED ARROW + "robrk", 0x027E7, // MATHEMATICAL RIGHT WHITE SQUARE BRACKET + "ropar", 0x02986, // RIGHT WHITE PARENTHESIS + "Ropf", 0x0211D, // DOUBLE-STRUCK CAPITAL R + "ropf", 0x1D563, // MATHEMATICAL DOUBLE-STRUCK SMALL R + "roplus", 0x02A2E, // PLUS SIGN IN RIGHT HALF CIRCLE + "rotimes", 0x02A35, // MULTIPLICATION SIGN IN RIGHT HALF CIRCLE + "RoundImplies", 0x02970, // RIGHT DOUBLE ARROW WITH ROUNDED HEAD + "rpar", 0x00029, // RIGHT PARENTHESIS + "rpargt", 0x02994, // RIGHT ARC GREATER-THAN BRACKET + "rppolint", 0x02A12, // LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE + "rrarr", 0x021C9, // RIGHTWARDS PAIRED ARROWS + "Rrightarrow", 0x021DB, // RIGHTWARDS TRIPLE ARROW + "rsaquo", 0x0203A, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK + "Rscr", 0x0211B, // SCRIPT CAPITAL R + "rscr", 0x1D4C7, // MATHEMATICAL SCRIPT SMALL R + "rsh", 0x021B1, // UPWARDS ARROW WITH TIP RIGHTWARDS + "Rsh", 0x021B1, // UPWARDS ARROW WITH TIP RIGHTWARDS + "rsqb", 0x0005D, // RIGHT SQUARE BRACKET + "rsquo", 0x02019, // RIGHT SINGLE QUOTATION MARK + "rsquor", 0x02019, // RIGHT SINGLE QUOTATION MARK + "rthree", 0x022CC, // RIGHT SEMIDIRECT PRODUCT + "rtimes", 0x022CA, // RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT + "rtri", 0x025B9, // WHITE RIGHT-POINTING SMALL TRIANGLE + "rtrie", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "rtrif", 0x025B8, // BLACK RIGHT-POINTING SMALL TRIANGLE + "rtriltri", 0x029CE, // RIGHT TRIANGLE ABOVE LEFT TRIANGLE + "RuleDelayed", 0x029F4, // RULE-DELAYED + "ruluhar", 0x02968, // RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP + "rx", 0x0211E, // PRESCRIPTION TAKE + NULL, 0 +}; + +static NameId namesS[]={ + "Sacute", 0x0015A, // LATIN CAPITAL LETTER S WITH ACUTE + "sacute", 0x0015B, // LATIN SMALL LETTER S WITH ACUTE + "sbquo", 0x0201A, // SINGLE LOW-9 QUOTATION MARK + "sc", 0x0227B, // SUCCEEDS + "Sc", 0x02ABC, // DOUBLE SUCCEEDS + "scap", 0x02AB8, // SUCCEEDS ABOVE ALMOST EQUAL TO + "Scaron", 0x00160, // LATIN CAPITAL LETTER S WITH CARON + "scaron", 0x00161, // LATIN SMALL LETTER S WITH CARON + "sccue", 0x0227D, // SUCCEEDS OR EQUAL TO + "sce", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "scE", 0x02AB4, // SUCCEEDS ABOVE EQUALS SIGN + "Scedil", 0x0015E, // LATIN CAPITAL LETTER S WITH CEDILLA + "scedil", 0x0015F, // LATIN SMALL LETTER S WITH CEDILLA + "Scirc", 0x0015C, // LATIN CAPITAL LETTER S WITH CIRCUMFLEX + "scirc", 0x0015D, // LATIN SMALL LETTER S WITH CIRCUMFLEX + "scnap", 0x02ABA, // SUCCEEDS ABOVE NOT ALMOST EQUAL TO + "scnE", 0x02AB6, // SUCCEEDS ABOVE NOT EQUAL TO + "scnsim", 0x022E9, // SUCCEEDS BUT NOT EQUIVALENT TO + "scpolint", 0x02A13, // LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE + "scsim", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "Scy", 0x00421, // CYRILLIC CAPITAL LETTER ES + "scy", 0x00441, // CYRILLIC SMALL LETTER ES + "sdot", 0x022C5, // DOT OPERATOR + "sdotb", 0x022A1, // SQUARED DOT OPERATOR + "sdote", 0x02A66, // EQUALS SIGN WITH DOT BELOW + "searhk", 0x02925, // SOUTH EAST ARROW WITH HOOK + "searr", 0x02198, // SOUTH EAST ARROW + "seArr", 0x021D8, // SOUTH EAST DOUBLE ARROW + "searrow", 0x02198, // SOUTH EAST ARROW + "sect", 0x000A7, // SECTION SIGN + "semi", 0x0003B, // SEMICOLON + "seswar", 0x02929, // SOUTH EAST ARROW AND SOUTH WEST ARROW + "setminus", 0x02216, // SET MINUS + "setmn", 0x02216, // SET MINUS + "sext", 0x02736, // SIX POINTED BLACK STAR + "sfgr", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "Sfr", 0x1D516, // MATHEMATICAL FRAKTUR CAPITAL S + "sfr", 0x1D530, // MATHEMATICAL FRAKTUR SMALL S + "sfrown", 0x02322, // FROWN + "Sgr", 0x003A3, // GREEK CAPITAL LETTER SIGMA + "sgr", 0x003C3, // GREEK SMALL LETTER SIGMA + "sharp", 0x0266F, // MUSIC SHARP SIGN + "SHCHcy", 0x00429, // CYRILLIC CAPITAL LETTER SHCHA + "shchcy", 0x00449, // CYRILLIC SMALL LETTER SHCHA + "SHcy", 0x00428, // CYRILLIC CAPITAL LETTER SHA + "shcy", 0x00448, // CYRILLIC SMALL LETTER SHA + "ShortDownArrow", 0x02193, // DOWNWARDS ARROW + "ShortLeftArrow", 0x02190, // LEFTWARDS ARROW + "shortmid", 0x02223, // DIVIDES + "shortparallel", 0x02225, // PARALLEL TO + "ShortRightArrow", 0x02192, // RIGHTWARDS ARROW + "ShortUpArrow", 0x02191, // UPWARDS ARROW + "shy", 0x000AD, // SOFT HYPHEN + "Sigma", 0x003A3, // GREEK CAPITAL LETTER SIGMA + "sigma", 0x003C3, // GREEK SMALL LETTER SIGMA + "sigmaf", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "sigmav", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "sim", 0x0223C, // TILDE OPERATOR + "simdot", 0x02A6A, // TILDE OPERATOR WITH DOT ABOVE + "sime", 0x02243, // ASYMPTOTICALLY EQUAL TO + "simeq", 0x02243, // ASYMPTOTICALLY EQUAL TO + "simg", 0x02A9E, // SIMILAR OR GREATER-THAN + "simgE", 0x02AA0, // SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN + "siml", 0x02A9D, // SIMILAR OR LESS-THAN + "simlE", 0x02A9F, // SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN + "simne", 0x02246, // APPROXIMATELY BUT NOT ACTUALLY EQUAL TO + "simplus", 0x02A24, // PLUS SIGN WITH TILDE ABOVE + "simrarr", 0x02972, // TILDE OPERATOR ABOVE RIGHTWARDS ARROW + "slarr", 0x02190, // LEFTWARDS ARROW + "SmallCircle", 0x02218, // RING OPERATOR + "smallsetminus", 0x02216, // SET MINUS + "smashp", 0x02A33, // SMASH PRODUCT + "smeparsl", 0x029E4, // EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE + "smid", 0x02223, // DIVIDES + "smile", 0x02323, // SMILE + "smt", 0x02AAA, // SMALLER THAN + "smte", 0x02AAC, // SMALLER THAN OR EQUAL TO +// "smtes", 0x02AAC;0x0FE00, // SMALLER THAN OR slanted EQUAL + "SOFTcy", 0x0042C, // CYRILLIC CAPITAL LETTER SOFT SIGN + "softcy", 0x0044C, // CYRILLIC SMALL LETTER SOFT SIGN + "sol", 0x0002F, // SOLIDUS + "solb", 0x029C4, // SQUARED RISING DIAGONAL SLASH + "solbar", 0x0233F, // APL FUNCTIONAL SYMBOL SLASH BAR + "Sopf", 0x1D54A, // MATHEMATICAL DOUBLE-STRUCK CAPITAL S + "sopf", 0x1D564, // MATHEMATICAL DOUBLE-STRUCK SMALL S + "spades", 0x02660, // BLACK SPADE SUIT + "spadesuit", 0x02660, // BLACK SPADE SUIT + "spar", 0x02225, // PARALLEL TO + "sqcap", 0x02293, // SQUARE CAP +// "sqcaps", 0x02293;0x0FE00, // SQUARE CAP with serifs + "sqcup", 0x02294, // SQUARE CUP +// "sqcups", 0x02294;0x0FE00, // SQUARE CUP with serifs + "Sqrt", 0x0221A, // SQUARE ROOT + "sqsub", 0x0228F, // SQUARE IMAGE OF + "sqsube", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "sqsubset", 0x0228F, // SQUARE IMAGE OF + "sqsubseteq", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "sqsup", 0x02290, // SQUARE ORIGINAL OF + "sqsupe", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "sqsupset", 0x02290, // SQUARE ORIGINAL OF + "sqsupseteq", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "squ", 0x025A1, // WHITE SQUARE + "square", 0x025A1, // WHITE SQUARE + "Square", 0x025A1, // WHITE SQUARE + "SquareIntersection", 0x02293, // SQUARE CAP + "SquareSubset", 0x0228F, // SQUARE IMAGE OF + "SquareSubsetEqual", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "SquareSuperset", 0x02290, // SQUARE ORIGINAL OF + "SquareSupersetEqual", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "SquareUnion", 0x02294, // SQUARE CUP + "squarf", 0x025AA, // BLACK SMALL SQUARE + "squf", 0x025AA, // BLACK SMALL SQUARE + "srarr", 0x02192, // RIGHTWARDS ARROW + "Sscr", 0x1D4AE, // MATHEMATICAL SCRIPT CAPITAL S + "sscr", 0x1D4C8, // MATHEMATICAL SCRIPT SMALL S + "ssetmn", 0x02216, // SET MINUS + "ssmile", 0x02323, // SMILE + "sstarf", 0x022C6, // STAR OPERATOR + "Star", 0x022C6, // STAR OPERATOR + "star", 0x02606, // WHITE STAR + "starf", 0x02605, // BLACK STAR + "straightepsilon", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "straightphi", 0x003D5, // GREEK PHI SYMBOL + "strns", 0x000AF, // MACRON + "sub", 0x02282, // SUBSET OF + "Sub", 0x022D0, // DOUBLE SUBSET + "subdot", 0x02ABD, // SUBSET WITH DOT + "sube", 0x02286, // SUBSET OF OR EQUAL TO + "subE", 0x02AC5, // SUBSET OF ABOVE EQUALS SIGN + "subedot", 0x02AC3, // SUBSET OF OR EQUAL TO WITH DOT ABOVE + "submult", 0x02AC1, // SUBSET WITH MULTIPLICATION SIGN BELOW + "subne", 0x0228A, // SUBSET OF WITH NOT EQUAL TO + "subnE", 0x02ACB, // SUBSET OF ABOVE NOT EQUAL TO + "subplus", 0x02ABF, // SUBSET WITH PLUS SIGN BELOW + "subrarr", 0x02979, // SUBSET ABOVE RIGHTWARDS ARROW + "subset", 0x02282, // SUBSET OF + "Subset", 0x022D0, // DOUBLE SUBSET + "subseteq", 0x02286, // SUBSET OF OR EQUAL TO + "subseteqq", 0x02AC5, // SUBSET OF ABOVE EQUALS SIGN + "SubsetEqual", 0x02286, // SUBSET OF OR EQUAL TO + "subsetneq", 0x0228A, // SUBSET OF WITH NOT EQUAL TO + "subsetneqq", 0x02ACB, // SUBSET OF ABOVE NOT EQUAL TO + "subsim", 0x02AC7, // SUBSET OF ABOVE TILDE OPERATOR + "subsub", 0x02AD5, // SUBSET ABOVE SUBSET + "subsup", 0x02AD3, // SUBSET ABOVE SUPERSET + "succ", 0x0227B, // SUCCEEDS + "succapprox", 0x02AB8, // SUCCEEDS ABOVE ALMOST EQUAL TO + "succcurlyeq", 0x0227D, // SUCCEEDS OR EQUAL TO + "Succeeds", 0x0227B, // SUCCEEDS + "SucceedsEqual", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "SucceedsSlantEqual", 0x0227D, // SUCCEEDS OR EQUAL TO + "SucceedsTilde", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "succeq", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "succnapprox", 0x02ABA, // SUCCEEDS ABOVE NOT ALMOST EQUAL TO + "succneqq", 0x02AB6, // SUCCEEDS ABOVE NOT EQUAL TO + "succnsim", 0x022E9, // SUCCEEDS BUT NOT EQUIVALENT TO + "succsim", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "SuchThat", 0x0220B, // CONTAINS AS MEMBER + "sum", 0x02211, // N-ARY SUMMATION + "Sum", 0x02211, // N-ARY SUMMATION + "sung", 0x0266A, // EIGHTH NOTE + "sup", 0x02283, // SUPERSET OF + "Sup", 0x022D1, // DOUBLE SUPERSET + "sup1", 0x000B9, // SUPERSCRIPT ONE + "sup2", 0x000B2, // SUPERSCRIPT TWO + "sup3", 0x000B3, // SUPERSCRIPT THREE + "supdot", 0x02ABE, // SUPERSET WITH DOT + "supdsub", 0x02AD8, // SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET + "supe", 0x02287, // SUPERSET OF OR EQUAL TO + "supE", 0x02AC6, // SUPERSET OF ABOVE EQUALS SIGN + "supedot", 0x02AC4, // SUPERSET OF OR EQUAL TO WITH DOT ABOVE + "Superset", 0x02283, // SUPERSET OF + "SupersetEqual", 0x02287, // SUPERSET OF OR EQUAL TO + "suphsol", 0x027C9, // SUPERSET PRECEDING SOLIDUS + "suphsub", 0x02AD7, // SUPERSET BESIDE SUBSET + "suplarr", 0x0297B, // SUPERSET ABOVE LEFTWARDS ARROW + "supmult", 0x02AC2, // SUPERSET WITH MULTIPLICATION SIGN BELOW + "supne", 0x0228B, // SUPERSET OF WITH NOT EQUAL TO + "supnE", 0x02ACC, // SUPERSET OF ABOVE NOT EQUAL TO + "supplus", 0x02AC0, // SUPERSET WITH PLUS SIGN BELOW + "supset", 0x02283, // SUPERSET OF + "Supset", 0x022D1, // DOUBLE SUPERSET + "supseteq", 0x02287, // SUPERSET OF OR EQUAL TO + "supseteqq", 0x02AC6, // SUPERSET OF ABOVE EQUALS SIGN + "supsetneq", 0x0228B, // SUPERSET OF WITH NOT EQUAL TO + "supsetneqq", 0x02ACC, // SUPERSET OF ABOVE NOT EQUAL TO + "supsim", 0x02AC8, // SUPERSET OF ABOVE TILDE OPERATOR + "supsub", 0x02AD4, // SUPERSET ABOVE SUBSET + "supsup", 0x02AD6, // SUPERSET ABOVE SUPERSET + "swarhk", 0x02926, // SOUTH WEST ARROW WITH HOOK + "swarr", 0x02199, // SOUTH WEST ARROW + "swArr", 0x021D9, // SOUTH WEST DOUBLE ARROW + "swarrow", 0x02199, // SOUTH WEST ARROW + "swnwar", 0x0292A, // SOUTH WEST ARROW AND NORTH WEST ARROW + "szlig", 0x000DF, // LATIN SMALL LETTER SHARP S + NULL, 0 +}; + +static NameId namesT[]={ + "Tab", 0x00009, // CHARACTER TABULATION + "target", 0x02316, // POSITION INDICATOR + "Tau", 0x003A4, // GREEK CAPITAL LETTER TAU + "tau", 0x003C4, // GREEK SMALL LETTER TAU + "tbrk", 0x023B4, // TOP SQUARE BRACKET + "Tcaron", 0x00164, // LATIN CAPITAL LETTER T WITH CARON + "tcaron", 0x00165, // LATIN SMALL LETTER T WITH CARON + "Tcedil", 0x00162, // LATIN CAPITAL LETTER T WITH CEDILLA + "tcedil", 0x00163, // LATIN SMALL LETTER T WITH CEDILLA + "Tcy", 0x00422, // CYRILLIC CAPITAL LETTER TE + "tcy", 0x00442, // CYRILLIC SMALL LETTER TE + "tdot", 0x020DB, // COMBINING THREE DOTS ABOVE + "telrec", 0x02315, // TELEPHONE RECORDER + "Tfr", 0x1D517, // MATHEMATICAL FRAKTUR CAPITAL T + "tfr", 0x1D531, // MATHEMATICAL FRAKTUR SMALL T + "Tgr", 0x003A4, // GREEK CAPITAL LETTER TAU + "tgr", 0x003C4, // GREEK SMALL LETTER TAU + "there4", 0x02234, // THEREFORE + "therefore", 0x02234, // THEREFORE + "Therefore", 0x02234, // THEREFORE + "Theta", 0x00398, // GREEK CAPITAL LETTER THETA + "theta", 0x003B8, // GREEK SMALL LETTER THETA + "thetasym", 0x003D1, // GREEK THETA SYMBOL + "thetav", 0x003D1, // GREEK THETA SYMBOL + "THgr", 0x00398, // GREEK CAPITAL LETTER THETA + "thgr", 0x003B8, // GREEK SMALL LETTER THETA + "thickapprox", 0x02248, // ALMOST EQUAL TO + "thicksim", 0x0223C, // TILDE OPERATOR +// "ThickSpace", 0x0205F;0x0200A, // space of width 5/18 em + "thinsp", 0x02009, // THIN SPACE + "ThinSpace", 0x02009, // THIN SPACE + "thkap", 0x02248, // ALMOST EQUAL TO + "thksim", 0x0223C, // TILDE OPERATOR + "THORN", 0x000DE, // LATIN CAPITAL LETTER THORN + "thorn", 0x000FE, // LATIN SMALL LETTER THORN + "tilde", 0x002DC, // SMALL TILDE + "Tilde", 0x0223C, // TILDE OPERATOR + "TildeEqual", 0x02243, // ASYMPTOTICALLY EQUAL TO + "TildeFullEqual", 0x02245, // APPROXIMATELY EQUAL TO + "TildeTilde", 0x02248, // ALMOST EQUAL TO + "times", 0x000D7, // MULTIPLICATION SIGN + "timesb", 0x022A0, // SQUARED TIMES + "timesbar", 0x02A31, // MULTIPLICATION SIGN WITH UNDERBAR + "timesd", 0x02A30, // MULTIPLICATION SIGN WITH DOT ABOVE + "tint", 0x0222D, // TRIPLE INTEGRAL + "toea", 0x02928, // NORTH EAST ARROW AND SOUTH EAST ARROW + "top", 0x022A4, // DOWN TACK + "topbot", 0x02336, // APL FUNCTIONAL SYMBOL I-BEAM + "topcir", 0x02AF1, // DOWN TACK WITH CIRCLE BELOW + "Topf", 0x1D54B, // MATHEMATICAL DOUBLE-STRUCK CAPITAL T + "topf", 0x1D565, // MATHEMATICAL DOUBLE-STRUCK SMALL T + "topfork", 0x02ADA, // PITCHFORK WITH TEE TOP + "tosa", 0x02929, // SOUTH EAST ARROW AND SOUTH WEST ARROW + "tprime", 0x02034, // TRIPLE PRIME + "trade", 0x02122, // TRADE MARK SIGN + "TRADE", 0x02122, // TRADE MARK SIGN + "triangle", 0x025B5, // WHITE UP-POINTING SMALL TRIANGLE + "triangledown", 0x025BF, // WHITE DOWN-POINTING SMALL TRIANGLE + "triangleleft", 0x025C3, // WHITE LEFT-POINTING SMALL TRIANGLE + "trianglelefteq", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "triangleq", 0x0225C, // DELTA EQUAL TO + "triangleright", 0x025B9, // WHITE RIGHT-POINTING SMALL TRIANGLE + "trianglerighteq", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "tridot", 0x025EC, // WHITE UP-POINTING TRIANGLE WITH DOT + "trie", 0x0225C, // DELTA EQUAL TO + "triminus", 0x02A3A, // MINUS SIGN IN TRIANGLE + "TripleDot", 0x020DB, // COMBINING THREE DOTS ABOVE + "triplus", 0x02A39, // PLUS SIGN IN TRIANGLE + "trisb", 0x029CD, // TRIANGLE WITH SERIFS AT BOTTOM + "tritime", 0x02A3B, // MULTIPLICATION SIGN IN TRIANGLE + "trpezium", 0x023E2, // WHITE TRAPEZIUM + "Tscr", 0x1D4AF, // MATHEMATICAL SCRIPT CAPITAL T + "tscr", 0x1D4C9, // MATHEMATICAL SCRIPT SMALL T + "TScy", 0x00426, // CYRILLIC CAPITAL LETTER TSE + "tscy", 0x00446, // CYRILLIC SMALL LETTER TSE + "TSHcy", 0x0040B, // CYRILLIC CAPITAL LETTER TSHE + "tshcy", 0x0045B, // CYRILLIC SMALL LETTER TSHE + "Tstrok", 0x00166, // LATIN CAPITAL LETTER T WITH STROKE + "tstrok", 0x00167, // LATIN SMALL LETTER T WITH STROKE + "twixt", 0x0226C, // BETWEEN + "twoheadleftarrow", 0x0219E, // LEFTWARDS TWO HEADED ARROW + "twoheadrightarrow", 0x021A0, // RIGHTWARDS TWO HEADED ARROW + NULL, 0 +}; + +static NameId namesU[]={ + "Uacgr", 0x0038E, // GREEK CAPITAL LETTER UPSILON WITH TONOS + "uacgr", 0x003CD, // GREEK SMALL LETTER UPSILON WITH TONOS + "Uacute", 0x000DA, // LATIN CAPITAL LETTER U WITH ACUTE + "uacute", 0x000FA, // LATIN SMALL LETTER U WITH ACUTE + "uarr", 0x02191, // UPWARDS ARROW + "Uarr", 0x0219F, // UPWARDS TWO HEADED ARROW + "uArr", 0x021D1, // UPWARDS DOUBLE ARROW + "Uarrocir", 0x02949, // UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE + "Ubrcy", 0x0040E, // CYRILLIC CAPITAL LETTER SHORT U + "ubrcy", 0x0045E, // CYRILLIC SMALL LETTER SHORT U + "Ubreve", 0x0016C, // LATIN CAPITAL LETTER U WITH BREVE + "ubreve", 0x0016D, // LATIN SMALL LETTER U WITH BREVE + "Ucirc", 0x000DB, // LATIN CAPITAL LETTER U WITH CIRCUMFLEX + "ucirc", 0x000FB, // LATIN SMALL LETTER U WITH CIRCUMFLEX + "Ucy", 0x00423, // CYRILLIC CAPITAL LETTER U + "ucy", 0x00443, // CYRILLIC SMALL LETTER U + "udarr", 0x021C5, // UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW + "Udblac", 0x00170, // LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + "udblac", 0x00171, // LATIN SMALL LETTER U WITH DOUBLE ACUTE + "udhar", 0x0296E, // UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "udiagr", 0x003B0, // GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + "Udigr", 0x003AB, // GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + "udigr", 0x003CB, // GREEK SMALL LETTER UPSILON WITH DIALYTIKA + "ufisht", 0x0297E, // UP FISH TAIL + "Ufr", 0x1D518, // MATHEMATICAL FRAKTUR CAPITAL U + "ufr", 0x1D532, // MATHEMATICAL FRAKTUR SMALL U + "Ugr", 0x003A5, // GREEK CAPITAL LETTER UPSILON + "ugr", 0x003C5, // GREEK SMALL LETTER UPSILON + "Ugrave", 0x000D9, // LATIN CAPITAL LETTER U WITH GRAVE + "ugrave", 0x000F9, // LATIN SMALL LETTER U WITH GRAVE + "uHar", 0x02963, // UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "uharl", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "uharr", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "uhblk", 0x02580, // UPPER HALF BLOCK + "ulcorn", 0x0231C, // TOP LEFT CORNER + "ulcorner", 0x0231C, // TOP LEFT CORNER + "ulcrop", 0x0230F, // TOP LEFT CROP + "ultri", 0x025F8, // UPPER LEFT TRIANGLE + "Umacr", 0x0016A, // LATIN CAPITAL LETTER U WITH MACRON + "umacr", 0x0016B, // LATIN SMALL LETTER U WITH MACRON + "uml", 0x000A8, // DIAERESIS + "UnderBar", 0x0005F, // LOW LINE + "UnderBrace", 0x023DF, // BOTTOM CURLY BRACKET + "UnderBracket", 0x023B5, // BOTTOM SQUARE BRACKET + "UnderParenthesis", 0x023DD, // BOTTOM PARENTHESIS + "Union", 0x022C3, // N-ARY UNION + "UnionPlus", 0x0228E, // MULTISET UNION + "Uogon", 0x00172, // LATIN CAPITAL LETTER U WITH OGONEK + "uogon", 0x00173, // LATIN SMALL LETTER U WITH OGONEK + "Uopf", 0x1D54C, // MATHEMATICAL DOUBLE-STRUCK CAPITAL U + "uopf", 0x1D566, // MATHEMATICAL DOUBLE-STRUCK SMALL U + "uparrow", 0x02191, // UPWARDS ARROW + "UpArrow", 0x02191, // UPWARDS ARROW + "Uparrow", 0x021D1, // UPWARDS DOUBLE ARROW + "UpArrowBar", 0x02912, // UPWARDS ARROW TO BAR + "UpArrowDownArrow", 0x021C5, // UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW + "updownarrow", 0x02195, // UP DOWN ARROW + "UpDownArrow", 0x02195, // UP DOWN ARROW + "Updownarrow", 0x021D5, // UP DOWN DOUBLE ARROW + "UpEquilibrium", 0x0296E, // UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "upharpoonleft", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "upharpoonright", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "uplus", 0x0228E, // MULTISET UNION + "UpperLeftArrow", 0x02196, // NORTH WEST ARROW + "UpperRightArrow", 0x02197, // NORTH EAST ARROW + "upsi", 0x003C5, // GREEK SMALL LETTER UPSILON + "Upsi", 0x003D2, // GREEK UPSILON WITH HOOK SYMBOL + "upsih", 0x003D2, // GREEK UPSILON WITH HOOK SYMBOL + "Upsilon", 0x003A5, // GREEK CAPITAL LETTER UPSILON + "upsilon", 0x003C5, // GREEK SMALL LETTER UPSILON + "UpTee", 0x022A5, // UP TACK + "UpTeeArrow", 0x021A5, // UPWARDS ARROW FROM BAR + "upuparrows", 0x021C8, // UPWARDS PAIRED ARROWS + "urcorn", 0x0231D, // TOP RIGHT CORNER + "urcorner", 0x0231D, // TOP RIGHT CORNER + "urcrop", 0x0230E, // TOP RIGHT CROP + "Uring", 0x0016E, // LATIN CAPITAL LETTER U WITH RING ABOVE + "uring", 0x0016F, // LATIN SMALL LETTER U WITH RING ABOVE + "urtri", 0x025F9, // UPPER RIGHT TRIANGLE + "Uscr", 0x1D4B0, // MATHEMATICAL SCRIPT CAPITAL U + "uscr", 0x1D4CA, // MATHEMATICAL SCRIPT SMALL U + "utdot", 0x022F0, // UP RIGHT DIAGONAL ELLIPSIS + "Utilde", 0x00168, // LATIN CAPITAL LETTER U WITH TILDE + "utilde", 0x00169, // LATIN SMALL LETTER U WITH TILDE + "utri", 0x025B5, // WHITE UP-POINTING SMALL TRIANGLE + "utrif", 0x025B4, // BLACK UP-POINTING SMALL TRIANGLE + "uuarr", 0x021C8, // UPWARDS PAIRED ARROWS + "Uuml", 0x000DC, // LATIN CAPITAL LETTER U WITH DIAERESIS + "uuml", 0x000FC, // LATIN SMALL LETTER U WITH DIAERESIS + "uwangle", 0x029A7, // OBLIQUE ANGLE OPENING DOWN + NULL, 0 +}; + +static NameId namesV[]={ + "vangrt", 0x0299C, // RIGHT ANGLE VARIANT WITH SQUARE + "varepsilon", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "varkappa", 0x003F0, // GREEK KAPPA SYMBOL + "varnothing", 0x02205, // EMPTY SET + "varphi", 0x003D5, // GREEK PHI SYMBOL + "varpi", 0x003D6, // GREEK PI SYMBOL + "varpropto", 0x0221D, // PROPORTIONAL TO + "varr", 0x02195, // UP DOWN ARROW + "vArr", 0x021D5, // UP DOWN DOUBLE ARROW + "varrho", 0x003F1, // GREEK RHO SYMBOL + "varsigma", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA +// "varsubsetneq", 0x0228A;0x0FE00, // SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "varsubsetneqq", 0x02ACB;0x0FE00, // SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members +// "varsupsetneq", 0x0228B;0x0FE00, // SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "varsupsetneqq", 0x02ACC;0x0FE00, // SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members + "vartheta", 0x003D1, // GREEK THETA SYMBOL + "vartriangleleft", 0x022B2, // NORMAL SUBGROUP OF + "vartriangleright", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "vBar", 0x02AE8, // SHORT UP TACK WITH UNDERBAR + "Vbar", 0x02AEB, // DOUBLE UP TACK + "vBarv", 0x02AE9, // SHORT UP TACK ABOVE SHORT DOWN TACK + "Vcy", 0x00412, // CYRILLIC CAPITAL LETTER VE + "vcy", 0x00432, // CYRILLIC SMALL LETTER VE + "vdash", 0x022A2, // RIGHT TACK + "vDash", 0x022A8, // TRUE + "Vdash", 0x022A9, // FORCES + "VDash", 0x022AB, // DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE + "Vdashl", 0x02AE6, // LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL + "vee", 0x02228, // LOGICAL OR + "Vee", 0x022C1, // N-ARY LOGICAL OR + "veebar", 0x022BB, // XOR + "veeeq", 0x0225A, // EQUIANGULAR TO + "vellip", 0x022EE, // VERTICAL ELLIPSIS + "verbar", 0x0007C, // VERTICAL LINE + "Verbar", 0x02016, // DOUBLE VERTICAL LINE + "vert", 0x0007C, // VERTICAL LINE + "Vert", 0x02016, // DOUBLE VERTICAL LINE + "VerticalBar", 0x02223, // DIVIDES + "VerticalLine", 0x0007C, // VERTICAL LINE + "VerticalSeparator", 0x02758, // LIGHT VERTICAL BAR + "VerticalTilde", 0x02240, // WREATH PRODUCT + "VeryThinSpace", 0x0200A, // HAIR SPACE + "Vfr", 0x1D519, // MATHEMATICAL FRAKTUR CAPITAL V + "vfr", 0x1D533, // MATHEMATICAL FRAKTUR SMALL V + "vltri", 0x022B2, // NORMAL SUBGROUP OF +// "vnsub", 0x02282;0x020D2, // SUBSET OF with vertical line +// "vnsup", 0x02283;0x020D2, // SUPERSET OF with vertical line + "Vopf", 0x1D54D, // MATHEMATICAL DOUBLE-STRUCK CAPITAL V + "vopf", 0x1D567, // MATHEMATICAL DOUBLE-STRUCK SMALL V + "vprop", 0x0221D, // PROPORTIONAL TO + "vrtri", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "Vscr", 0x1D4B1, // MATHEMATICAL SCRIPT CAPITAL V + "vscr", 0x1D4CB, // MATHEMATICAL SCRIPT SMALL V +// "vsubne", 0x0228A;0x0FE00, // SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "vsubnE", 0x02ACB;0x0FE00, // SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members +// "vsupne", 0x0228B;0x0FE00, // SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "vsupnE", 0x02ACC;0x0FE00, // SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members + "Vvdash", 0x022AA, // TRIPLE VERTICAL BAR RIGHT TURNSTILE + "vzigzag", 0x0299A, // VERTICAL ZIGZAG LINE + NULL, 0 +}; + +static NameId namesW[]={ + "Wcirc", 0x00174, // LATIN CAPITAL LETTER W WITH CIRCUMFLEX + "wcirc", 0x00175, // LATIN SMALL LETTER W WITH CIRCUMFLEX + "wedbar", 0x02A5F, // LOGICAL AND WITH UNDERBAR + "wedge", 0x02227, // LOGICAL AND + "Wedge", 0x022C0, // N-ARY LOGICAL AND + "wedgeq", 0x02259, // ESTIMATES + "weierp", 0x02118, // SCRIPT CAPITAL P + "Wfr", 0x1D51A, // MATHEMATICAL FRAKTUR CAPITAL W + "wfr", 0x1D534, // MATHEMATICAL FRAKTUR SMALL W + "Wopf", 0x1D54E, // MATHEMATICAL DOUBLE-STRUCK CAPITAL W + "wopf", 0x1D568, // MATHEMATICAL DOUBLE-STRUCK SMALL W + "wp", 0x02118, // SCRIPT CAPITAL P + "wr", 0x02240, // WREATH PRODUCT + "wreath", 0x02240, // WREATH PRODUCT + "Wscr", 0x1D4B2, // MATHEMATICAL SCRIPT CAPITAL W + "wscr", 0x1D4CC, // MATHEMATICAL SCRIPT SMALL W + NULL, 0 +}; + +static NameId namesX[]={ + "xcap", 0x022C2, // N-ARY INTERSECTION + "xcirc", 0x025EF, // LARGE CIRCLE + "xcup", 0x022C3, // N-ARY UNION + "xdtri", 0x025BD, // WHITE DOWN-POINTING TRIANGLE + "Xfr", 0x1D51B, // MATHEMATICAL FRAKTUR CAPITAL X + "xfr", 0x1D535, // MATHEMATICAL FRAKTUR SMALL X + "Xgr", 0x0039E, // GREEK CAPITAL LETTER XI + "xgr", 0x003BE, // GREEK SMALL LETTER XI + "xharr", 0x027F7, // LONG LEFT RIGHT ARROW + "xhArr", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "Xi", 0x0039E, // GREEK CAPITAL LETTER XI + "xi", 0x003BE, // GREEK SMALL LETTER XI + "xlarr", 0x027F5, // LONG LEFTWARDS ARROW + "xlArr", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "xmap", 0x027FC, // LONG RIGHTWARDS ARROW FROM BAR + "xnis", 0x022FB, // CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "xodot", 0x02A00, // N-ARY CIRCLED DOT OPERATOR + "Xopf", 0x1D54F, // MATHEMATICAL DOUBLE-STRUCK CAPITAL X + "xopf", 0x1D569, // MATHEMATICAL DOUBLE-STRUCK SMALL X + "xoplus", 0x02A01, // N-ARY CIRCLED PLUS OPERATOR + "xotime", 0x02A02, // N-ARY CIRCLED TIMES OPERATOR + "xrarr", 0x027F6, // LONG RIGHTWARDS ARROW + "xrArr", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "Xscr", 0x1D4B3, // MATHEMATICAL SCRIPT CAPITAL X + "xscr", 0x1D4CD, // MATHEMATICAL SCRIPT SMALL X + "xsqcup", 0x02A06, // N-ARY SQUARE UNION OPERATOR + "xuplus", 0x02A04, // N-ARY UNION OPERATOR WITH PLUS + "xutri", 0x025B3, // WHITE UP-POINTING TRIANGLE + "xvee", 0x022C1, // N-ARY LOGICAL OR + "xwedge", 0x022C0, // N-ARY LOGICAL AND + NULL, 0 +}; + +static NameId namesY[]={ + "Yacute", 0x000DD, // LATIN CAPITAL LETTER Y WITH ACUTE + "yacute", 0x000FD, // LATIN SMALL LETTER Y WITH ACUTE + "YAcy", 0x0042F, // CYRILLIC CAPITAL LETTER YA + "yacy", 0x0044F, // CYRILLIC SMALL LETTER YA + "Ycirc", 0x00176, // LATIN CAPITAL LETTER Y WITH CIRCUMFLEX + "ycirc", 0x00177, // LATIN SMALL LETTER Y WITH CIRCUMFLEX + "Ycy", 0x0042B, // CYRILLIC CAPITAL LETTER YERU + "ycy", 0x0044B, // CYRILLIC SMALL LETTER YERU + "yen", 0x000A5, // YEN SIGN + "Yfr", 0x1D51C, // MATHEMATICAL FRAKTUR CAPITAL Y + "yfr", 0x1D536, // MATHEMATICAL FRAKTUR SMALL Y + "YIcy", 0x00407, // CYRILLIC CAPITAL LETTER YI + "yicy", 0x00457, // CYRILLIC SMALL LETTER YI + "Yopf", 0x1D550, // MATHEMATICAL DOUBLE-STRUCK CAPITAL Y + "yopf", 0x1D56A, // MATHEMATICAL DOUBLE-STRUCK SMALL Y + "Yscr", 0x1D4B4, // MATHEMATICAL SCRIPT CAPITAL Y + "yscr", 0x1D4CE, // MATHEMATICAL SCRIPT SMALL Y + "YUcy", 0x0042E, // CYRILLIC CAPITAL LETTER YU + "yucy", 0x0044E, // CYRILLIC SMALL LETTER YU + "yuml", 0x000FF, // LATIN SMALL LETTER Y WITH DIAERESIS + "Yuml", 0x00178, // LATIN CAPITAL LETTER Y WITH DIAERESIS + NULL, 0 +}; + +static NameId namesZ[]={ + "Zacute", 0x00179, // LATIN CAPITAL LETTER Z WITH ACUTE + "zacute", 0x0017A, // LATIN SMALL LETTER Z WITH ACUTE + "Zcaron", 0x0017D, // LATIN CAPITAL LETTER Z WITH CARON + "zcaron", 0x0017E, // LATIN SMALL LETTER Z WITH CARON + "Zcy", 0x00417, // CYRILLIC CAPITAL LETTER ZE + "zcy", 0x00437, // CYRILLIC SMALL LETTER ZE + "Zdot", 0x0017B, // LATIN CAPITAL LETTER Z WITH DOT ABOVE + "zdot", 0x0017C, // LATIN SMALL LETTER Z WITH DOT ABOVE + "zeetrf", 0x02128, // BLACK-LETTER CAPITAL Z + "ZeroWidthSpace", 0x0200B, // ZERO WIDTH SPACE + "Zeta", 0x00396, // GREEK CAPITAL LETTER ZETA + "zeta", 0x003B6, // GREEK SMALL LETTER ZETA + "Zfr", 0x02128, // BLACK-LETTER CAPITAL Z + "zfr", 0x1D537, // MATHEMATICAL FRAKTUR SMALL Z + "Zgr", 0x00396, // GREEK CAPITAL LETTER ZETA + "zgr", 0x003B6, // GREEK SMALL LETTER ZETA + "ZHcy", 0x00416, // CYRILLIC CAPITAL LETTER ZHE + "zhcy", 0x00436, // CYRILLIC SMALL LETTER ZHE + "zigrarr", 0x021DD, // RIGHTWARDS SQUIGGLE ARROW + "Zopf", 0x02124, // DOUBLE-STRUCK CAPITAL Z + "zopf", 0x1D56B, // MATHEMATICAL DOUBLE-STRUCK SMALL Z + "Zscr", 0x1D4B5, // MATHEMATICAL SCRIPT CAPITAL Z + "zscr", 0x1D4CF, // MATHEMATICAL SCRIPT SMALL Z + "zwj", 0x0200D, // ZERO WIDTH JOINER + "zwnj", 0x0200C, // ZERO WIDTH NON-JOINER + NULL, 0 +}; + +// @todo@ order namesTable and names? by frequency +static NameId* namesTable[] = { + namesA, namesB, namesC, namesD, namesE, namesF, namesG, namesH, namesI, + namesJ, namesK, namesL, namesM, namesN, namesO, namesP, namesQ, namesR, + namesS, namesT, namesU, namesV, namesW, namesX, namesY, namesZ, NULL +}; + +int HtmlNamedEntity(unsigned char *p, int length) +{ + int tableIndex = tolower(*p) - 'a'; + if (tableIndex >= 0 && tableIndex < 26) + { + NameId* names = namesTable[tableIndex]; + int i; + + for (i = 0; names[i].name; i++) + { + if (strncmp(names[i].name, (char *)p, length) == 0) + return names[i].value; + } + } + return -1; +} + diff --git a/enum.c b/enum.c new file mode 100644 index 00000000..d88d6e3d --- /dev/null +++ b/enum.c @@ -0,0 +1,425 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "enum.h" +#include "mtype.h" +#include "scope.h" +#include "id.h" +#include "expression.h" +#include "module.h" +#include "declaration.h" + +/********************************* EnumDeclaration ****************************/ + +EnumDeclaration::EnumDeclaration(Loc loc, Identifier *id, Type *memtype) + : ScopeDsymbol(id) +{ + this->loc = loc; + type = new TypeEnum(this); + this->memtype = memtype; + maxval = NULL; + minval = NULL; + defaultval = NULL; + sinit = NULL; + isdeprecated = 0; + isdone = 0; +} + +Dsymbol *EnumDeclaration::syntaxCopy(Dsymbol *s) +{ + Type *t = NULL; + if (memtype) + t = memtype->syntaxCopy(); + + EnumDeclaration *ed; + if (s) + { ed = (EnumDeclaration *)s; + ed->memtype = t; + } + else + ed = new EnumDeclaration(loc, ident, t); + ScopeDsymbol::syntaxCopy(ed); + return ed; +} + +void EnumDeclaration::semantic0(Scope *sc) +{ + /* This function is a hack to get around a significant problem. + * The members of anonymous enums, like: + * enum { A, B, C } + * don't get installed into the symbol table until after they are + * semantically analyzed, yet they're supposed to go into the enclosing + * scope's table. Hence, when forward referenced, they come out as + * 'undefined'. The real fix is to add them in at addSymbol() time. + * But to get code to compile, we'll just do this quick hack at the moment + * to compile it if it doesn't depend on anything else. + */ + + if (isdone || !scope) + return; + if (!isAnonymous() || memtype) + return; + for (size_t i = 0; i < members->dim; i++) + { + EnumMember *em = (*members)[i]->isEnumMember(); + if (em && (em->type || em->value)) + return; + } + + // Can do it + semantic(sc); +} + +void EnumDeclaration::semantic(Scope *sc) +{ + Type *t; + Scope *sce; + + //printf("EnumDeclaration::semantic(sd = %p, '%s') %s\n", sc->scopesym, sc->scopesym->toChars(), toChars()); + //printf("EnumDeclaration::semantic() %s\n", toChars()); + if (!members) // enum ident; + return; + + if (!memtype && !isAnonymous()) + { // Set memtype if we can to reduce fwd reference errors + memtype = Type::tint32; // case 1) enum ident { ... } + } + + if (symtab) // if already done + { if (isdone || !scope) + 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; + + if (sc->stc & STCdeprecated) + isdeprecated = 1; + + parent = sc->parent; + + /* The separate, and distinct, cases are: + * 1. enum { ... } + * 2. enum : memtype { ... } + * 3. enum ident { ... } + * 4. enum ident : memtype { ... } + */ + + if (memtype) + { + memtype = memtype->semantic(loc, sc); + + /* Check to see if memtype is forward referenced + */ + if (memtype->ty == Tenum) + { EnumDeclaration *sym = (EnumDeclaration *)memtype->toDsymbol(sc); + if (!sym->memtype || !sym->members || !sym->symtab || sym->scope) + { // memtype is forward referenced, so try again later + scope = scx ? scx : new Scope(*sc); + scope->setNoFree(); + scope->module->addDeferredSemantic(this); + Module::dprogress = dprogress_save; + //printf("\tdeferring %s\n", toChars()); + return; + } + } +#if 0 // Decided to abandon this restriction for D 2.0 + if (!memtype->isintegral()) + { error("base type must be of integral type, not %s", memtype->toChars()); + memtype = Type::tint32; + } +#endif + } + + isdone = 1; + Module::dprogress++; + + type = type->semantic(loc, sc); + if (isAnonymous()) + sce = sc; + else + { sce = sc->push(this); + sce->parent = this; + } + if (members->dim == 0) + error("enum %s must have at least one member", toChars()); + int first = 1; + Expression *elast = NULL; + for (size_t i = 0; i < members->dim; i++) + { + EnumMember *em = (*members)[i]->isEnumMember(); + Expression *e; + + if (!em) + /* The e->semantic(sce) can insert other symbols, such as + * template instances and function literals. + */ + continue; + + //printf(" Enum member '%s'\n",em->toChars()); + if (em->type) + em->type = em->type->semantic(em->loc, sce); + e = em->value; + if (e) + { + assert(e->dyncast() == DYNCAST_EXPRESSION); + e = e->semantic(sce); + e = e->optimize(WANTvalue | WANTinterpret); + if (memtype) + { + e = e->implicitCastTo(sce, memtype); + e = e->optimize(WANTvalue | WANTinterpret); + if (!isAnonymous()) + e = e->castTo(sce, type); + t = memtype; + } + else if (em->type) + { + e = e->implicitCastTo(sce, em->type); + e = e->optimize(WANTvalue | WANTinterpret); + assert(isAnonymous()); + t = e->type; + } + else + t = e->type; + } + else if (first) + { + if (memtype) + t = memtype; + else if (em->type) + t = em->type; + else + t = Type::tint32; + e = new IntegerExp(em->loc, 0, Type::tint32); + e = e->implicitCastTo(sce, t); + e = e->optimize(WANTvalue | WANTinterpret); + if (!isAnonymous()) + e = e->castTo(sce, type); + } + else + { + // Set value to (elast + 1). + // But first check that (elast != t.max) + assert(elast); + e = new EqualExp(TOKequal, em->loc, elast, t->getProperty(0, Id::max)); + e = e->semantic(sce); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->toInteger()) + error("overflow of enum value %s", elast->toChars()); + + // Now set e to (elast + 1) + e = new AddExp(em->loc, elast, new IntegerExp(em->loc, 1, Type::tint32)); + e = e->semantic(sce); + e = e->castTo(sce, elast->type); + e = e->optimize(WANTvalue | WANTinterpret); + } + elast = e; + em->value = e; + + // Add to symbol table only after evaluating 'value' + if (isAnonymous()) + { + /* Anonymous enum members get added to enclosing scope. + */ + for (Scope *sct = sce; sct; sct = sct->enclosing) + { + if (sct->scopesym) + { + if (!sct->scopesym->symtab) + sct->scopesym->symtab = new DsymbolTable(); + em->addMember(sce, sct->scopesym, 1); + break; + } + } + } + else + em->addMember(sc, this, 1); + + /* Compute .min, .max and .default values. + * If enum doesn't have a name, we can never identify the enum type, + * so there is no purpose for a .min, .max or .default + */ + if (!isAnonymous()) + { + if (first) + { defaultval = e; + minval = e; + maxval = e; + } + else + { Expression *ec; + + /* In order to work successfully with UDTs, + * build expressions to do the comparisons, + * and let the semantic analyzer and constant + * folder give us the result. + */ + + // Compute if(e < minval) + ec = new CmpExp(TOKlt, em->loc, e, minval); + ec = ec->semantic(sce); + ec = ec->optimize(WANTvalue | WANTinterpret); + if (ec->toInteger()) + minval = e; + + ec = new CmpExp(TOKgt, em->loc, e, maxval); + ec = ec->semantic(sce); + ec = ec->optimize(WANTvalue | WANTinterpret); + if (ec->toInteger()) + maxval = e; + } + } + first = 0; + } + //printf("defaultval = %lld\n", defaultval); + + //if (defaultval) printf("defaultval: %s %s\n", defaultval->toChars(), defaultval->type->toChars()); + if (sc != sce) + sce->pop(); + //members->print(); +} + +int EnumDeclaration::oneMember(Dsymbol **ps, Identifier *ident) +{ + if (isAnonymous()) + return Dsymbol::oneMembers(members, ps, ident); + return Dsymbol::oneMember(ps, ident); +} + +void EnumDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("enum "); + if (ident) + { buf->writestring(ident->toChars()); + buf->writeByte(' '); + } + if (memtype) + { + buf->writestring(": "); + memtype->toCBuffer(buf, NULL, hgs); + } + if (!members) + { + buf->writeByte(';'); + buf->writenl(); + return; + } + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (size_t i = 0; i < members->dim; i++) + { + EnumMember *em = (*members)[i]->isEnumMember(); + if (!em) + continue; + //buf->writestring(" "); + em->toCBuffer(buf, hgs); + buf->writeByte(','); + buf->writenl(); + } + buf->writeByte('}'); + buf->writenl(); +} + +Type *EnumDeclaration::getType() +{ + return type; +} + +const char *EnumDeclaration::kind() +{ + return "enum"; +} + +int EnumDeclaration::isDeprecated() +{ + return isdeprecated; +} + +Dsymbol *EnumDeclaration::search(Loc loc, Identifier *ident, int flags) +{ + //printf("%s.EnumDeclaration::search('%s')\n", toChars(), ident->toChars()); + if (scope) + // Try one last time to resolve this enum + semantic(scope); + + if (!members || !symtab || scope) + { error("is forward referenced when looking for '%s'", ident->toChars()); + //*(char*)0=0; + return NULL; + } + + Dsymbol *s = ScopeDsymbol::search(loc, ident, flags); + return s; +} + +/********************************* EnumMember ****************************/ + +EnumMember::EnumMember(Loc loc, Identifier *id, Expression *value, Type *type) + : Dsymbol(id) +{ + this->value = value; + this->type = type; + this->loc = loc; +} + +Dsymbol *EnumMember::syntaxCopy(Dsymbol *s) +{ + Expression *e = NULL; + if (value) + e = value->syntaxCopy(); + + Type *t = NULL; + if (type) + t = type->syntaxCopy(); + + EnumMember *em; + if (s) + { em = (EnumMember *)s; + em->loc = loc; + em->value = e; + em->type = t; + } + else + em = new EnumMember(loc, ident, e, t); + return em; +} + +void EnumMember::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (type) + type->toCBuffer(buf, ident, hgs); + else + buf->writestring(ident->toChars()); + if (value) + { + buf->writestring(" = "); + value->toCBuffer(buf, hgs); + } +} + +const char *EnumMember::kind() +{ + return "enum member"; +} + + diff --git a/enum.h b/enum.h new file mode 100644 index 00000000..0d617630 --- /dev/null +++ b/enum.h @@ -0,0 +1,91 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2008 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_ENUM_H +#define DMD_ENUM_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "dsymbol.h" + +struct Identifier; +struct Type; +struct Expression; +struct HdrGenState; + + +struct EnumDeclaration : ScopeDsymbol +{ /* enum ident : memtype { ... } + */ + Type *type; // the TypeEnum + Type *memtype; // type of the members + +#if DMDV1 + dinteger_t maxval; + dinteger_t minval; + dinteger_t defaultval; // default initializer +#else + Expression *maxval; + Expression *minval; + Expression *defaultval; // default initializer +#endif + int isdeprecated; + int isdone; // 0: not done + // 1: semantic() successfully completed + + EnumDeclaration(Loc loc, Identifier *id, Type *memtype); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic0(Scope *sc); + void semantic(Scope *sc); + int oneMember(Dsymbol **ps, Identifier *ident = NULL); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Type *getType(); + const char *kind(); +#if DMDV2 + Dsymbol *search(Loc, Identifier *ident, int flags); +#endif + int isDeprecated(); // is Dsymbol deprecated? + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toDocBuffer(OutBuffer *buf); + + EnumDeclaration *isEnumDeclaration() { return this; } + + void toObjFile(int multiobj); // compile to .obj file + void toDebug(); + int cvMember(unsigned char *p); + + Symbol *sinit; + Symbol *toInitializer(); +}; + + +struct EnumMember : Dsymbol +{ + Expression *value; + Type *type; + + EnumMember(Loc loc, Identifier *id, Expression *value, Type *type); + Dsymbol *syntaxCopy(Dsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); + void toDocBuffer(OutBuffer *buf); + + EnumMember *isEnumMember() { return this; } +}; + +#endif /* DMD_ENUM_H */ diff --git a/expression.c b/expression.c new file mode 100644 index 00000000..3b41fd35 --- /dev/null +++ b/expression.c @@ -0,0 +1,12367 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include +#if _MSC_VER +#include +#else +#include +#endif + +#if _WIN32 && __DMC__ +extern "C" char * __cdecl __locale_decpoint; +#endif + +#include "rmem.h" +#include "port.h" +#include "root.h" + +#include "mtype.h" +#include "init.h" +#include "expression.h" +#include "template.h" +#include "utf.h" +#include "enum.h" +#include "scope.h" +#include "statement.h" +#include "declaration.h" +#include "aggregate.h" +#include "import.h" +#include "id.h" +#include "dsymbol.h" +#include "module.h" +#include "attrib.h" +#include "hdrgen.h" +#include "parse.h" +#include "doc.h" + + +Expression *createTypeInfoArray(Scope *sc, Expression *args[], unsigned dim); +Expression *expandVar(int result, VarDeclaration *v); + +#define LOGSEMANTIC 0 + +/************************************************************* + * Given var, we need to get the + * right 'this' pointer if var is in an outer class, but our + * existing 'this' pointer is in an inner class. + * Input: + * e1 existing 'this' + * ad struct or class we need the correct 'this' for + * var the specific member of ad we're accessing + */ + +Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, + Expression *e1, Declaration *var) +{ + //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars()); + L1: + Type *t = e1->type->toBasetype(); + //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars()); + + /* If e1 is not the 'this' pointer for ad + */ + if (ad && + !(t->ty == Tpointer && t->nextOf()->ty == Tstruct && + ((TypeStruct *)t->nextOf())->sym == ad) + && + !(t->ty == Tstruct && + ((TypeStruct *)t)->sym == ad) + ) + { + ClassDeclaration *cd = ad->isClassDeclaration(); + ClassDeclaration *tcd = t->isClassHandle(); + + /* e1 is the right this if ad is a base class of e1 + */ + if (!cd || !tcd || + !(tcd == cd || cd->isBaseOf(tcd, NULL)) + ) + { + /* Only classes can be inner classes with an 'outer' + * member pointing to the enclosing class instance + */ + if (tcd && tcd->isNested()) + { /* e1 is the 'this' pointer for an inner class: tcd. + * Rewrite it as the 'this' pointer for the outer class. + */ + + e1 = new DotVarExp(loc, e1, tcd->vthis); + e1->type = tcd->vthis->type; + // Do not call checkNestedRef() + //e1 = e1->semantic(sc); + + // Skip up over nested functions, and get the enclosing + // class type. + int n = 0; + Dsymbol *s; + for (s = tcd->toParent(); + s && s->isFuncDeclaration(); + s = s->toParent()) + { FuncDeclaration *f = s->isFuncDeclaration(); + if (f->vthis) + { + //printf("rewriting e1 to %s's this\n", f->toChars()); + n++; + e1 = new VarExp(loc, f->vthis); + } + else + { + e1->error("need 'this' of type %s to access member %s" + " from static function %s", + ad->toChars(), var->toChars(), f->toChars()); + e1 = new ErrorExp(); + return e1; + } + } + if (s && s->isClassDeclaration()) + { e1->type = s->isClassDeclaration()->type; + if (n > 1) + e1 = e1->semantic(sc); + } + else + e1 = e1->semantic(sc); + goto L1; + } + /* Can't find a path from e1 to ad + */ + e1->error("this for %s needs to be type %s not type %s", + var->toChars(), ad->toChars(), t->toChars()); + e1 = new ErrorExp(); + } + } + return e1; +} + +/***************************************** + * Determine if 'this' is available. + * If it is, return the FuncDeclaration that has it. + */ + +FuncDeclaration *hasThis(Scope *sc) +{ FuncDeclaration *fd; + FuncDeclaration *fdthis; + + //printf("hasThis()\n"); + fdthis = sc->parent->isFuncDeclaration(); + //printf("fdthis = %p, '%s'\n", fdthis, fdthis ? fdthis->toChars() : ""); + + /* Special case for inside template constraint + */ + if (fdthis && (sc->flags & SCOPEstaticif) && fdthis->parent->isTemplateDeclaration()) + { + //TemplateDeclaration *td = fdthis->parent->isTemplateDeclaration(); + //printf("[%s] td = %s, fdthis->vthis = %p\n", td->loc.toChars(), td->toChars(), fdthis->vthis); + return fdthis->vthis ? fdthis : NULL; + } + + // Go upwards until we find the enclosing member function + fd = fdthis; + while (1) + { + if (!fd) + { + goto Lno; + } + if (!fd->isNested()) + break; + + Dsymbol *parent = fd->parent; + while (1) + { + if (!parent) + goto Lno; + TemplateInstance *ti = parent->isTemplateInstance(); + if (ti) + parent = ti->parent; + else + break; + } + fd = parent->isFuncDeclaration(); + } + + if (!fd->isThis()) + { //printf("test '%s'\n", fd->toChars()); + goto Lno; + } + + assert(fd->vthis); + return fd; + +Lno: + return NULL; // don't have 'this' available +} + + +/*************************************** + * Pull out any properties. + */ + +Expression *resolveProperties(Scope *sc, Expression *e) +{ + //printf("resolveProperties(%s)\n", e->toChars()); + + TemplateDeclaration *td; + Objects *targsi; + Expression *ethis; + if (e->op == TOKdotti) + { + DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e; + td = dti->getTempdecl(sc); + dti->ti->semanticTiargs(sc); + targsi = dti->ti->tiargs; + ethis = dti->e1; + goto L1; + } + else if (e->op == TOKdottd) + { + DotTemplateExp *dte = (DotTemplateExp *)e; + td = dte->td; + targsi = NULL; + ethis = dte->e1; + goto L1; + } + else if (e->op == TOKtemplate) + { + td = ((TemplateExp *)e)->td; + targsi = NULL; + ethis = NULL; + L1: + assert(td); + unsigned errors = global.startGagging(); + FuncDeclaration *fd = td->deduceFunctionTemplate(sc, e->loc, targsi, ethis, NULL, 1); + if (global.endGagging(errors)) + fd = NULL; // eat "is not a function template" error + if (fd && fd->type) + { assert(fd->type->ty == Tfunction); + TypeFunction *tf = (TypeFunction *)fd->type; + if (!tf->isproperty && global.params.enforcePropertySyntax) + { error(e->loc, "not a property %s", e->toChars()); + return new ErrorExp(); + } + e = new CallExp(e->loc, e); + e = e->semantic(sc); + } + goto return_expr; + } + + if (e->type) + { + Type *t = e->type->toBasetype(); + + if (t->ty == Tfunction || e->op == TOKoverloadset) + { + if (t->ty == Tfunction && !((TypeFunction *)t)->isproperty && + global.params.enforcePropertySyntax) + { + error(e->loc, "not a property %s", e->toChars()); + return new ErrorExp(); + } + e = new CallExp(e->loc, e); + e = e->semantic(sc); + } + + /* Look for e being a lazy parameter; rewrite as delegate call + */ + else if (e->op == TOKvar) + { VarExp *ve = (VarExp *)e; + + if (ve->var->storage_class & STClazy) + { + e = new CallExp(e->loc, e); + e = e->semantic(sc); + } + } + + else if (e->op == TOKdotexp) + { + e->error("expression has no value"); + return new ErrorExp(); + } + + } + +return_expr: + if (!e->type) + { + error(e->loc, "cannot resolve type for %s", e->toChars()); + e->type = new TypeError(); + } + return e; +} + +/****************************** + * Perform semantic() on an array of Expressions. + */ + +Expressions *arrayExpressionSemantic(Expressions *exps, Scope *sc) +{ + if (exps) + { + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + if (e) + { e = e->semantic(sc); + (*exps)[i] = e; + } + } + } + return exps; +} + + +/****************************** + * Perform canThrow() on an array of Expressions. + */ + +#if DMDV2 +int arrayExpressionCanThrow(Expressions *exps, bool mustNotThrow) +{ + if (exps) + { + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + if (e && e->canThrow(mustNotThrow)) + return 1; + } + } + return 0; +} +#endif + +/**************************************** + * Expand tuples. + */ + +void expandTuples(Expressions *exps) +{ + //printf("expandTuples()\n"); + if (exps) + { + for (size_t i = 0; i < exps->dim; i++) + { Expression *arg = (*exps)[i]; + if (!arg) + continue; + + // Look for tuple with 0 members + if (arg->op == TOKtype) + { TypeExp *e = (TypeExp *)arg; + if (e->type->toBasetype()->ty == Ttuple) + { TypeTuple *tt = (TypeTuple *)e->type->toBasetype(); + + if (!tt->arguments || tt->arguments->dim == 0) + { + exps->remove(i); + if (i == exps->dim) + return; + i--; + continue; + } + } + } + + // Inline expand all the tuples + while (arg->op == TOKtuple) + { TupleExp *te = (TupleExp *)arg; + + exps->remove(i); // remove arg + exps->insert(i, te->exps); // replace with tuple contents + if (i == exps->dim) + return; // empty tuple, no more arguments + arg = (*exps)[i]; + } + } + } +} + +/**************************************** + * Expand alias this tuples. + */ + +TupleDeclaration *isAliasThisTuple(Expression *e) +{ + if (e->type) + { + Type *t = e->type->toBasetype(); + AggregateDeclaration *ad; + if (t->ty == Tstruct) + { + ad = ((TypeStruct *)t)->sym; + goto L1; + } + else if (t->ty == Tclass) + { + ad = ((TypeClass *)t)->sym; + L1: + Dsymbol *s = ad->aliasthis; + if (s && s->isVarDeclaration()) + { + TupleDeclaration *td = s->isVarDeclaration()->toAlias()->isTupleDeclaration(); + if (td && td->isexp) + return td; + } + } + } + return NULL; +} + +int expandAliasThisTuples(Expressions *exps, int starti) +{ + if (!exps || exps->dim == 0) + return -1; + + for (size_t u = starti; u < exps->dim; u++) + { + Expression *exp = exps->tdata()[u]; + TupleDeclaration *td = isAliasThisTuple(exp); + if (td) + { + exps->remove(u); + for (size_t i = 0; iobjects->dim; ++i) + { + Expression *e = isExpression(td->objects->tdata()[i]); + assert(e); + assert(e->op == TOKdsymbol); + DsymbolExp *se = (DsymbolExp *)e; + Declaration *d = se->s->isDeclaration(); + assert(d); + e = new DotVarExp(exp->loc, exp, d); + assert(d->type); + e->type = d->type; + exps->insert(u + i, e); + } + #if 0 + printf("expansion ->\n"); + for (size_t i = 0; idim; ++i) + { + Expression *e = exps->tdata()[i]; + printf("\texps[%d] e = %s %s\n", i, Token::tochars[e->op], e->toChars()); + } + #endif + return u; + } + } + + return -1; +} + +Expressions *arrayExpressionToCommonType(Scope *sc, Expressions *exps, Type **pt) +{ +#if DMDV1 + /* The first element sets the type + */ + Type *t0 = NULL; + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + + if (!e->type) + { error("%s has no value", e->toChars()); + e = new ErrorExp(); + } + e = resolveProperties(sc, e); + + if (!t0) + t0 = e->type; + else + e = e->implicitCastTo(sc, t0); + (*exps)[i] = e; + } + + if (!t0) + t0 = Type::tvoid; + if (pt) + *pt = t0; + + // Eventually, we want to make this copy-on-write + return exps; +#endif +#if DMDV2 + /* The type is determined by applying ?: to each pair. + */ + /* Still have a problem with: + * ubyte[][] = [ cast(ubyte[])"hello", [1]]; + * which works if the array literal is initialized top down with the ubyte[][] + * type, but fails with this function doing bottom up typing. + */ + //printf("arrayExpressionToCommonType()\n"); + IntegerExp integerexp(0); + CondExp condexp(0, &integerexp, NULL, NULL); + + Type *t0 = NULL; + Expression *e0; + int j0; + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + + e = resolveProperties(sc, e); + if (!e->type) + { error("%s has no value", e->toChars()); + e = new ErrorExp(); + } + + if (t0) + { if (t0 != e->type) + { + /* This applies ?: to merge the types. It's backwards; + * ?: should call this function to merge types. + */ + condexp.type = NULL; + condexp.e1 = e0; + condexp.e2 = e; + condexp.loc = e->loc; + condexp.semantic(sc); + (*exps)[j0] = condexp.e1; + e = condexp.e2; + j0 = i; + e0 = e; + t0 = e0->type; + } + } + else + { j0 = i; + e0 = e; + t0 = e->type; + } + (*exps)[i] = e; + } + + if (t0) + { + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + e = e->implicitCastTo(sc, t0); + (*exps)[i] = e; + } + } + else + t0 = Type::tvoid; // [] is typed as void[] + if (pt) + *pt = t0; + + // Eventually, we want to make this copy-on-write + return exps; +#endif +} + +/**************************************** + * Get TemplateDeclaration enclosing FuncDeclaration. + */ + +TemplateDeclaration *getFuncTemplateDecl(Dsymbol *s) +{ + FuncDeclaration *f = s->isFuncDeclaration(); + if (f && f->parent) + { TemplateInstance *ti = f->parent->isTemplateInstance(); + + if (ti && + !ti->isTemplateMixin() && + (ti->name == f->ident || + ti->toAlias()->ident == f->ident) + && + ti->tempdecl && ti->tempdecl->onemember) + { + return ti->tempdecl; + } + } + return NULL; +} + +/**************************************** + * Preprocess arguments to function. + */ + +void preFunctionParameters(Loc loc, Scope *sc, Expressions *exps) +{ + if (exps) + { + expandTuples(exps); + + for (size_t i = 0; i < exps->dim; i++) + { Expression *arg = (*exps)[i]; + + arg = resolveProperties(sc, arg); + (*exps)[i] = arg; + + //arg->rvalue(); +#if 0 + if (arg->type->ty == Tfunction) + { + arg = new AddrExp(arg->loc, arg); + arg = arg->semantic(sc); + (*exps)[i] = arg; + } +#endif + } + } +} + +/************************************************ + * If we want the value of this expression, but do not want to call + * the destructor on it. + */ + +void valueNoDtor(Expression *e) +{ + if (e->op == TOKcall) + { + /* The struct value returned from the function is transferred + * so do not call the destructor on it. + * Recognize: + * ((S _ctmp = S.init), _ctmp).this(...) + * and make sure the destructor is not called on _ctmp + * BUG: if e is a CommaExp, we should go down the right side. + */ + CallExp *ce = (CallExp *)e; + if (ce->e1->op == TOKdotvar) + { DotVarExp *dve = (DotVarExp *)ce->e1; + if (dve->var->isCtorDeclaration()) + { // It's a constructor call + if (dve->e1->op == TOKcomma) + { CommaExp *comma = (CommaExp *)dve->e1; + if (comma->e2->op == TOKvar) + { VarExp *ve = (VarExp *)comma->e2; + VarDeclaration *ctmp = ve->var->isVarDeclaration(); + if (ctmp) + ctmp->noscope = 1; + } + } + } + } + } +} + +/********************************************* + * Call copy constructor for struct value argument. + */ +#if DMDV2 +Expression *callCpCtor(Loc loc, Scope *sc, Expression *e, int noscope) +{ + Type *tb = e->type->toBasetype(); + assert(tb->ty == Tstruct); + StructDeclaration *sd = ((TypeStruct *)tb)->sym; + if (sd->cpctor) + { + /* Create a variable tmp, and replace the argument e with: + * (tmp = e),tmp + * and let AssignExp() handle the construction. + * This is not the most efficent, ideally tmp would be constructed + * directly onto the stack. + */ + Identifier *idtmp = Lexer::uniqueId("__cpcttmp"); + VarDeclaration *tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(0, e)); + tmp->storage_class |= STCctfe; + tmp->noscope = noscope; + Expression *ae = new DeclarationExp(loc, tmp); + e = new CommaExp(loc, ae, new VarExp(loc, tmp)); + e = e->semantic(sc); + } + return e; +} +#endif + +// Check if this function is a member of a template which has only been +// instantiated speculatively, eg from inside is(typeof()). +// Return the speculative template instance it is part of, +// or NULL if not speculative. +TemplateInstance *isSpeculativeFunction(FuncDeclaration *fd) +{ + Dsymbol * par = fd->parent; + while (par) + { + TemplateInstance *ti = par->isTemplateInstance(); + if (ti && ti->speculative) + return ti; + par = par->toParent(); + } + return NULL; +} + +/**************************************** + * Now that we know the exact type of the function we're calling, + * the arguments[] need to be adjusted: + * 1. implicitly convert argument to the corresponding parameter type + * 2. add default arguments for any missing arguments + * 3. do default promotions on arguments corresponding to ... + * 4. add hidden _arguments[] argument + * 5. call copy constructor for struct value arguments + * Returns: + * return type from function + */ + +Type *functionParameters(Loc loc, Scope *sc, TypeFunction *tf, + Expression *ethis, Expressions *arguments, FuncDeclaration *fd) +{ + //printf("functionParameters()\n"); + assert(arguments); + assert(fd || tf->next); + size_t nargs = arguments ? arguments->dim : 0; + size_t nparams = Parameter::dim(tf->parameters); + + if (nargs > nparams && tf->varargs == 0) + { error(loc, "expected %zu arguments, not %zu for non-variadic function type %s", nparams, nargs, tf->toChars()); + return Type::terror; + } + + // If inferring return type, and semantic3() needs to be run if not already run + if (!tf->next && fd->inferRetType) + { + TemplateInstance *spec = isSpeculativeFunction(fd); + int olderrs = global.errors; + fd->semantic3(fd->scope); + // Update the template instantiation with the number + // of errors which occured. + if (spec && global.errors != olderrs) + spec->errors = global.errors - olderrs; + } + + unsigned n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams) + + unsigned wildmatch = 0; + if (ethis && tf->isWild()) + { + Type *t = ethis->type; + if (t->isWild()) + wildmatch |= MODwild; + else if (t->isConst()) + wildmatch |= MODconst; + else if (t->isImmutable()) + wildmatch |= MODimmutable; + else + wildmatch |= MODmutable; + } + + int done = 0; + for (size_t i = 0; i < n; i++) + { + Expression *arg; + + if (i < nargs) + arg = arguments->tdata()[i]; + else + arg = NULL; + + if (i < nparams) + { + Parameter *p = Parameter::getNth(tf->parameters, i); + + if (!arg) + { + if (!p->defaultArg) + { + if (tf->varargs == 2 && i + 1 == nparams) + goto L2; + error(loc, "expected %zu function arguments, not %zu", nparams, nargs); + return Type::terror; + } + arg = p->defaultArg; + arg = arg->inlineCopy(sc); +#if DMDV2 + arg = arg->resolveLoc(loc, sc); // __FILE__ and __LINE__ +#endif + arguments->push(arg); + nargs++; + } + else if (arg->op == TOKfunction) + { FuncExp *fe = (FuncExp *)arg; + Type *pt = p->type; + if (tf->varargs == 2 && i + 1 == nparams && pt->nextOf()) + pt = pt->nextOf(); + fe->setType(pt); + arg = fe->semantic(sc); + arguments->tdata()[i] = arg; + } + + if (tf->varargs == 2 && i + 1 == nparams) + { + //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars()); + if (arg->implicitConvTo(p->type)) + { + if (p->type->nextOf() && arg->implicitConvTo(p->type->nextOf())) + goto L2; + else if (nargs != nparams) + { error(loc, "expected %zu function arguments, not %zu", nparams, nargs); + return Type::terror; + } + goto L1; + } + L2: + Type *tb = p->type->toBasetype(); + Type *tret = p->isLazyArray(); + switch (tb->ty) + { + case Tsarray: + case Tarray: + { // Create a static array variable v of type arg->type +#ifdef IN_GCC + /* GCC 4.0 does not like zero length arrays used like + this; pass a null array value instead. Could also + just make a one-element array. */ + if (nargs - i == 0) + { + arg = new NullExp(loc); + break; + } +#endif + Identifier *id = Lexer::uniqueId("__arrayArg"); + Type *t = new TypeSArray(((TypeArray *)tb)->next, new IntegerExp(nargs - i)); + t = t->semantic(loc, sc); + bool isSafe = fd ? fd->isSafe() : tf->trust == TRUSTsafe; + VarDeclaration *v = new VarDeclaration(loc, t, id, + isSafe ? NULL : new VoidInitializer(loc)); + v->storage_class |= STCctfe; + v->semantic(sc); + v->parent = sc->parent; + //sc->insert(v); + + Expression *c = new DeclarationExp(0, v); + c->type = v->type; + + for (size_t u = i; u < nargs; u++) + { Expression *a = arguments->tdata()[u]; + if (tret && !((TypeArray *)tb)->next->equals(a->type)) + a = a->toDelegate(sc, tret); + + Expression *e = new VarExp(loc, v); + e = new IndexExp(loc, e, new IntegerExp(u + 1 - nparams)); + ConstructExp *ae = new ConstructExp(loc, e, a); + if (c) + c = new CommaExp(loc, c, ae); + else + c = ae; + } + arg = new VarExp(loc, v); + if (c) + arg = new CommaExp(loc, c, arg); + break; + } + case Tclass: + { /* Set arg to be: + * new Tclass(arg0, arg1, ..., argn) + */ + Expressions *args = new Expressions(); + args->setDim(nargs - i); + for (size_t u = i; u < nargs; u++) + args->tdata()[u - i] = arguments->tdata()[u]; + arg = new NewExp(loc, NULL, NULL, p->type, args); + break; + } + default: + if (!arg) + { error(loc, "not enough arguments"); + return Type::terror; + } + break; + } + arg = arg->semantic(sc); + //printf("\targ = '%s'\n", arg->toChars()); + arguments->setDim(i + 1); + arguments->tdata()[i] = arg; + nargs = i + 1; + done = 1; + } + + L1: + if (!(p->storageClass & STClazy && p->type->ty == Tvoid)) + { + unsigned mod = arg->type->wildConvTo(p->type); + if (mod) + { + wildmatch |= mod; + } + } + } + if (done) + break; + } + if (wildmatch) + { /* Calculate wild matching modifier + */ + if (wildmatch & MODconst || wildmatch & (wildmatch - 1)) + wildmatch = MODconst; + else if (wildmatch & MODimmutable) + wildmatch = MODimmutable; + else if (wildmatch & MODwild) + wildmatch = MODwild; + else + { assert(wildmatch & MODmutable); + wildmatch = MODmutable; + } + } + + assert(nargs >= nparams); + for (size_t i = 0; i < nargs; i++) + { + Expression *arg = arguments->tdata()[i]; + assert(arg); + + if (i < nparams) + { + Parameter *p = Parameter::getNth(tf->parameters, i); + + if (!(p->storageClass & STClazy && p->type->ty == Tvoid)) + { + if (p->type->hasWild()) + { + arg = arg->implicitCastTo(sc, p->type->substWildTo(wildmatch)); + arg = arg->optimize(WANTvalue); + } + else if (p->type != arg->type) + { + //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars()); + if (arg->op == TOKtype) + { arg->error("cannot pass type %s as function argument", arg->toChars()); + arg = new ErrorExp(); + goto L3; + } + else + arg = arg->implicitCastTo(sc, p->type); + arg = arg->optimize(WANTvalue); + } + } + if (p->storageClass & STCref) + { + arg = arg->toLvalue(sc, arg); + } + else if (p->storageClass & STCout) + { + arg = arg->modifiableLvalue(sc, arg); + } + + Type *tb = arg->type->toBasetype(); +#if !SARRAYVALUE + // Convert static arrays to pointers + if (tb->ty == Tsarray) + { + arg = arg->checkToPointer(); + } +#endif +#if DMDV2 + if (tb->ty == Tstruct && !(p->storageClass & (STCref | STCout))) + { + if (arg->op == TOKcall) + { + /* The struct value returned from the function is transferred + * to the function, so the callee should not call the destructor + * on it. + */ + valueNoDtor(arg); + } + else + { /* Not transferring it, so call the copy constructor + */ + arg = callCpCtor(loc, sc, arg, 1); + } + } +#endif + + //printf("arg: %s\n", arg->toChars()); + //printf("type: %s\n", arg->type->toChars()); + + // Convert lazy argument to a delegate + if (p->storageClass & STClazy) + { + arg = arg->toDelegate(sc, p->type); + } +#if DMDV2 + /* Look for arguments that cannot 'escape' from the called + * function. + */ + if (!tf->parameterEscapes(p)) + { + Expression *a = arg; + if (a->op == TOKcast) + a = ((CastExp *)a)->e1; + + /* Function literals can only appear once, so if this + * appearance was scoped, there cannot be any others. + */ + if (a->op == TOKfunction) + { FuncExp *fe = (FuncExp *)a; + fe->fd->tookAddressOf = 0; + } + + /* For passing a delegate to a scoped parameter, + * this doesn't count as taking the address of it. + * We only worry about 'escaping' references to the function. + */ + else if (a->op == TOKdelegate) + { DelegateExp *de = (DelegateExp *)a; + if (de->e1->op == TOKvar) + { VarExp *ve = (VarExp *)de->e1; + FuncDeclaration *f = ve->var->isFuncDeclaration(); + if (f) + { f->tookAddressOf--; + //printf("tookAddressOf = %d\n", f->tookAddressOf); + } + } + } + } +#endif + } + else + { + + // If not D linkage, do promotions + if (tf->linkage != LINKd) + { + // Promote bytes, words, etc., to ints + arg = arg->integralPromotions(sc); + + // Promote floats to doubles + switch (arg->type->ty) + { + case Tfloat32: + arg = arg->castTo(sc, Type::tfloat64); + break; + + case Timaginary32: + arg = arg->castTo(sc, Type::timaginary64); + break; + } + } + + // Do not allow types that need destructors + if (arg->type->needsDestruction()) + { arg->error("cannot pass types that need destruction as variadic arguments"); + arg = new ErrorExp(); + } + + // Convert static arrays to dynamic arrays + // BUG: I don't think this is right for D2 + Type *tb = arg->type->toBasetype(); + if (tb->ty == Tsarray) + { TypeSArray *ts = (TypeSArray *)tb; + Type *ta = ts->next->arrayOf(); + if (ts->size(arg->loc) == 0) + arg = new NullExp(arg->loc, ta); + else + arg = arg->castTo(sc, ta); + } +#if DMDV2 + if (tb->ty == Tstruct) + { + arg = callCpCtor(loc, sc, arg, 1); + } +#endif + + // Give error for overloaded function addresses + if (arg->op == TOKsymoff) + { SymOffExp *se = (SymOffExp *)arg; + if ( +#if DMDV2 + se->hasOverloads && +#endif + !se->var->isFuncDeclaration()->isUnique()) + { arg->error("function %s is overloaded", arg->toChars()); + arg = new ErrorExp(); + } + } + arg->rvalue(); + } + arg = arg->optimize(WANTvalue); + L3: + arguments->tdata()[i] = arg; + } + + // If D linkage and variadic, add _arguments[] as first argument + if (tf->linkage == LINKd && tf->varargs == 1) + { + assert(arguments->dim >= nparams); + Expression *e = createTypeInfoArray(sc, (Expression **)&arguments->tdata()[nparams], + arguments->dim - nparams); + arguments->insert(0, e); + } + + Type *tret = tf->next; + if (wildmatch) + { /* Adjust function return type based on wildmatch + */ + //printf("wildmatch = x%x, tret = %s\n", wildmatch, tret->toChars()); + tret = tret->substWildTo(wildmatch); + } + return tret; +} + +/************************************************** + * Write expression out to buf, but wrap it + * in ( ) if its precedence is less than pr. + */ + +void expToCBuffer(OutBuffer *buf, HdrGenState *hgs, Expression *e, enum PREC pr) +{ +#ifdef DEBUG + if (precedence[e->op] == PREC_zero) + printf("precedence not defined for token '%s'\n",Token::tochars[e->op]); +#endif + assert(precedence[e->op] != PREC_zero); + assert(pr != PREC_zero); + + //if (precedence[e->op] == 0) e->dump(0); + if (precedence[e->op] < pr || + /* Despite precedence, we don't allow aop] == pr)) + { + buf->writeByte('('); + e->toCBuffer(buf, hgs); + buf->writeByte(')'); + } + else + e->toCBuffer(buf, hgs); +} + +/************************************************** + * Write out argument list to buf. + */ + +void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) +{ + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { Expression *arg = arguments->tdata()[i]; + + if (arg) + { if (i) + buf->writeByte(','); + expToCBuffer(buf, hgs, arg, PREC_assign); + } + } + } +} + +/************************************************** + * Write out argument types to buf. + */ + +void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) +{ + if (arguments) + { OutBuffer argbuf; + + for (size_t i = 0; i < arguments->dim; i++) + { Expression *arg = arguments->tdata()[i]; + + if (i) + buf->writeByte(','); + argbuf.reset(); + arg->type->toCBuffer2(&argbuf, hgs, 0); + buf->write(&argbuf); + } + } +} + +/******************************** Expression **************************/ + +Expression::Expression(Loc loc, enum TOK op, int size) + : loc(loc) +{ + //printf("Expression::Expression(op = %d) this = %p\n", op, this); + this->loc = loc; + this->op = op; + this->size = size; + this->parens = 0; + type = NULL; +} + +Expression *Expression::syntaxCopy() +{ + //printf("Expression::syntaxCopy()\n"); + //dump(0); + return copy(); +} + +/********************************* + * Does *not* do a deep copy. + */ + +Expression *Expression::copy() +{ + Expression *e; + if (!size) + { +#ifdef DEBUG + fprintf(stdmsg, "No expression copy for: %s\n", toChars()); + printf("op = %d\n", op); + dump(0); +#endif + assert(0); + } + e = (Expression *)mem.malloc(size); + //printf("Expression::copy(op = %d) e = %p\n", op, e); + return (Expression *)memcpy(e, this, size); +} + +/************************** + * Semantically analyze Expression. + * Determine types, fold constants, etc. + */ + +Expression *Expression::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("Expression::semantic() %s\n", toChars()); +#endif + if (type) + type = type->semantic(loc, sc); + else + type = Type::tvoid; + return this; +} + +/********************************** + * Try to run semantic routines. + * If they fail, return NULL. + */ + +Expression *Expression::trySemantic(Scope *sc) +{ + //printf("+trySemantic(%s)\n", toChars()); + unsigned errors = global.startGagging(); + Expression *e = semantic(sc); + if (global.endGagging(errors)) + { + e = NULL; + } + //printf("-trySemantic(%s)\n", toChars()); + return e; +} + +void Expression::print() +{ + fprintf(stdmsg, "%s\n", toChars()); + fflush(stdmsg); +} + +char *Expression::toChars() +{ OutBuffer *buf; + HdrGenState hgs; + + memset(&hgs, 0, sizeof(hgs)); + buf = new OutBuffer(); + toCBuffer(buf, &hgs); + return buf->toChars(); +} + +void Expression::error(const char *format, ...) +{ + if (type != Type::terror) + { + va_list ap; + va_start(ap, format); + ::verror(loc, format, ap); + va_end( ap ); + } +} + +void Expression::warning(const char *format, ...) +{ + if (type != Type::terror) + { + va_list ap; + va_start(ap, format); + ::vwarning(loc, format, ap); + va_end( ap ); + } +} + +int Expression::rvalue() +{ + if (type && type->toBasetype()->ty == Tvoid) + { error("expression %s is void and has no value", toChars()); +#if 0 + dump(0); + halt(); +#endif + if (!global.gag) + type = Type::terror; + return 0; + } + return 1; +} + +Expression *Expression::combine(Expression *e1, Expression *e2) +{ + if (e1) + { + if (e2) + { + e1 = new CommaExp(e1->loc, e1, e2); + e1->type = e2->type; + } + } + else + e1 = e2; + return e1; +} + +dinteger_t Expression::toInteger() +{ + //printf("Expression %s\n", Token::toChars(op)); + error("Integer constant expression expected instead of %s", toChars()); + return 0; +} + +uinteger_t Expression::toUInteger() +{ + //printf("Expression %s\n", Token::toChars(op)); + return (uinteger_t)toInteger(); +} + +real_t Expression::toReal() +{ + error("Floating point constant expression expected instead of %s", toChars()); + return 0; +} + +real_t Expression::toImaginary() +{ + error("Floating point constant expression expected instead of %s", toChars()); + return 0; +} + +complex_t Expression::toComplex() +{ + error("Floating point constant expression expected instead of %s", toChars()); +#ifdef IN_GCC + return complex_t(real_t(0)); // %% nicer +#else + return 0; +#endif +} + +StringExp *Expression::toString() +{ + return NULL; +} + +void Expression::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(op)); +} + +void Expression::toMangleBuffer(OutBuffer *buf) +{ + error("expression %s is not a valid template value argument", toChars()); +#ifdef DEBUG +dump(0); +#endif +} + +/*************************************** + * Return !=0 if expression is an lvalue. + */ +#if DMDV2 +int Expression::isLvalue() +{ + return 0; +} +#endif + +/******************************* + * Give error if we're not an lvalue. + * If we can, convert expression to be an lvalue. + */ + +Expression *Expression::toLvalue(Scope *sc, Expression *e) +{ + if (!e) + e = this; + else if (!loc.filename) + loc = e->loc; + error("%s is not an lvalue", e->toChars()); + return new ErrorExp(); +} + +Expression *Expression::modifiableLvalue(Scope *sc, Expression *e) +{ + //printf("Expression::modifiableLvalue() %s, type = %s\n", toChars(), type->toChars()); + + // See if this expression is a modifiable lvalue (i.e. not const) +#if DMDV2 + if (type && (!type->isMutable() || !type->isAssignable())) + { error("%s is not mutable", e->toChars()); + return new ErrorExp(); + } +#endif + return toLvalue(sc, e); +} + + +/************************************ + * Detect cases where pointers to the stack can 'escape' the + * lifetime of the stack frame. + */ + +void Expression::checkEscape() +{ +} + +void Expression::checkEscapeRef() +{ +} + +void Expression::checkScalar() +{ + if (!type->isscalar() && type->toBasetype() != Type::terror) + error("'%s' is not a scalar, it is a %s", toChars(), type->toChars()); + rvalue(); +} + +void Expression::checkNoBool() +{ + if (type->toBasetype()->ty == Tbool) + error("operation not allowed on bool '%s'", toChars()); +} + +Expression *Expression::checkIntegral() +{ + if (!type->isintegral()) + { if (type->toBasetype() != Type::terror) + error("'%s' is not of integral type, it is a %s", toChars(), type->toChars()); + return new ErrorExp(); + } + if (!rvalue()) + return new ErrorExp(); + return this; +} + +Expression *Expression::checkArithmetic() +{ + if (!type->isintegral() && !type->isfloating()) + { if (type->toBasetype() != Type::terror) + error("'%s' is not of arithmetic type, it is a %s", toChars(), type->toChars()); + return new ErrorExp(); + } + if (!rvalue()) + return new ErrorExp(); + return this; +} + +void Expression::checkDeprecated(Scope *sc, Dsymbol *s) +{ + s->checkDeprecated(loc, sc); +} + +#if DMDV2 +/********************************************* + * Calling function f. + * Check the purity, i.e. if we're in a pure function + * we can only call other pure functions. + */ +void Expression::checkPurity(Scope *sc, FuncDeclaration *f) +{ +#if 1 + if (sc->func) + { + /* Given: + * void f() + * { pure void g() + * { + * void h() + * { + * void i() { } + * } + * } + * } + * g() can call h() but not f() + * i() can call h() and g() but not f() + */ + FuncDeclaration *outerfunc = sc->func; + // Find the closest pure parent of the calling function + while (outerfunc->toParent2() && + !outerfunc->isPureBypassingInference() && + outerfunc->toParent2()->isFuncDeclaration()) + { + outerfunc = outerfunc->toParent2()->isFuncDeclaration(); + } + // Find the closest pure parent of the called function + FuncDeclaration *calledparent = f; + while (calledparent->toParent2() && !calledparent->isPureBypassingInference() + && calledparent->toParent2()->isFuncDeclaration() ) + { + calledparent = calledparent->toParent2()->isFuncDeclaration(); + } + // If the caller has a pure parent, then either the called func must be pure, + // OR, they must have the same pure parent. + if (/*outerfunc->isPure() &&*/ // comment out because we deduce purity now + !sc->intypeof && + !(sc->flags & SCOPEdebug) && + !(f->isPure() || (calledparent == outerfunc))) + { + if (outerfunc->setImpure()) + error("pure function '%s' cannot call impure function '%s'", + outerfunc->toChars(), f->toChars()); + } + } +#else + if (sc->func && sc->func->isPure() && !sc->intypeof && !f->isPure()) + error("pure function '%s' cannot call impure function '%s'", + sc->func->toChars(), f->toChars()); +#endif +} + +/******************************************* + * Accessing variable v. + * Check for purity and safety violations. + * If ethis is not NULL, then ethis is the 'this' pointer as in ethis.v + */ + +void Expression::checkPurity(Scope *sc, VarDeclaration *v, Expression *ethis) +{ + /* Look for purity and safety violations when accessing variable v + * from current function. + */ + if (sc->func && + !sc->intypeof && // allow violations inside typeof(expression) + !(sc->flags & SCOPEdebug) && // allow violations inside debug conditionals + v->ident != Id::ctfe && // magic variable never violates pure and safe + !v->isImmutable() && // always safe and pure to access immutables... + !(v->isConst() && v->isDataseg() && !v->type->hasPointers()) && // const global value types are immutable + !(v->storage_class & STCmanifest) // ...or manifest constants + ) + { + if (v->isDataseg()) + { + /* Accessing global mutable state. + * Therefore, this function and all its immediately enclosing + * functions must be pure. + */ + bool msg = FALSE; + for (Dsymbol *s = sc->func; s; s = s->toParent2()) + { + FuncDeclaration *ff = s->isFuncDeclaration(); + if (!ff) + break; + if (ff->setImpure() && !msg) + { error("pure function '%s' cannot access mutable static data '%s'", + sc->func->toChars(), v->toChars()); + msg = TRUE; // only need the innermost message + } + } + } + else + { + /* Given: + * void f() + * { int fx; + * pure void g() + * { int gx; + * void h() + * { int hx; + * void i() { } + * } + * } + * } + * i() can modify hx and gx but not fx + */ + + Dsymbol *vparent = v->toParent2(); + for (Dsymbol *s = sc->func; s; s = s->toParent2()) + { + if (s == vparent) + break; + FuncDeclaration *ff = s->isFuncDeclaration(); + if (!ff) + break; + if (ff->setImpure()) + { error("pure nested function '%s' cannot access mutable data '%s'", + ff->toChars(), v->toChars()); + break; + } + } + } + + /* Do not allow safe functions to access __gshared data + */ + if (v->storage_class & STCgshared) + { + if (sc->func->setUnsafe()) + error("safe function '%s' cannot access __gshared data '%s'", + sc->func->toChars(), v->toChars()); + } + } +} + +void Expression::checkSafety(Scope *sc, FuncDeclaration *f) +{ + if (sc->func && !sc->intypeof && + !f->isSafe() && !f->isTrusted()) + { + if (sc->func->setUnsafe()) + error("safe function '%s' cannot call system function '%s'", + sc->func->toChars(), f->toChars()); + } +} +#endif + + +/***************************** + * Check that expression can be tested for true or false. + */ + +Expression *Expression::checkToBoolean(Scope *sc) +{ + // Default is 'yes' - do nothing + +#ifdef DEBUG + if (!type) + dump(0); +#endif + + // Structs can be converted to bool using opCast(bool)() + Type *tb = type->toBasetype(); + if (tb->ty == Tstruct) + { AggregateDeclaration *ad = ((TypeStruct *)tb)->sym; + /* Don't really need to check for opCast first, but by doing so we + * get better error messages if it isn't there. + */ + Dsymbol *fd = search_function(ad, Id::cast); + if (fd) + { + Expression *e = new CastExp(loc, this, Type::tbool); + e = e->semantic(sc); + return e; + } + + // Forward to aliasthis. + if (ad->aliasthis) + { + Expression *e = new DotIdExp(loc, this, ad->aliasthis->ident); + e = e->semantic(sc); + e = resolveProperties(sc, e); + e = e->checkToBoolean(sc); + return e; + } + } + + if (!type->checkBoolean()) + { if (type->toBasetype() != Type::terror) + error("expression %s of type %s does not have a boolean value", toChars(), type->toChars()); + return new ErrorExp(); + } + return this; +} + +/**************************** + */ + +Expression *Expression::checkToPointer() +{ + //printf("Expression::checkToPointer()\n"); + Expression *e = this; + +#if !SARRAYVALUE + // If C static array, convert to pointer + Type *tb = type->toBasetype(); + if (tb->ty == Tsarray) + { TypeSArray *ts = (TypeSArray *)tb; + if (ts->size(loc) == 0) + e = new NullExp(loc); + else + e = new AddrExp(loc, this); + e->type = ts->next->pointerTo(); + } +#endif + return e; +} + +/****************************** + * Take address of expression. + */ + +Expression *Expression::addressOf(Scope *sc) +{ + Expression *e; + Type *t = type; + + //printf("Expression::addressOf()\n"); + e = toLvalue(sc, NULL); + e = new AddrExp(loc, e); + e->type = t->pointerTo(); + return e; +} + +/****************************** + * If this is a reference, dereference it. + */ + +Expression *Expression::deref() +{ + //printf("Expression::deref()\n"); + // type could be null if forward referencing an 'auto' variable + if (type && type->ty == Treference) + { + Expression *e = new PtrExp(loc, this); + e->type = ((TypeReference *)type)->next; + return e; + } + return this; +} + +/******************************** + * Does this expression statically evaluate to a boolean TRUE or FALSE? + */ + +int Expression::isBool(int result) +{ + return FALSE; +} + +/******************************** + * Does this expression result in either a 1 or a 0? + */ + +int Expression::isBit() +{ + return FALSE; +} + +/**************************************** + * Resolve __LINE__ and __FILE__ to loc. + */ + +Expression *Expression::resolveLoc(Loc loc, Scope *sc) +{ + return this; +} + +Expressions *Expression::arraySyntaxCopy(Expressions *exps) +{ Expressions *a = NULL; + + if (exps) + { + a = new Expressions(); + a->setDim(exps->dim); + for (size_t i = 0; i < a->dim; i++) + { Expression *e = (*exps)[i]; + + if (e) + e = e->syntaxCopy(); + a->tdata()[i] = e; + } + } + return a; +} + +/*************************************************** + * Recognize expressions of the form: + * ((T v = init), v) + * where v is a temp. + * This is used in optimizing out unnecessary temporary generation. + * Returns initializer expression of v if so, NULL if not. + */ + +Expression *Expression::isTemp() +{ + //printf("isTemp() %s\n", toChars()); + if (op == TOKcomma) + { CommaExp *ec = (CommaExp *)this; + if (ec->e1->op == TOKdeclaration && + ec->e2->op == TOKvar) + { DeclarationExp *de = (DeclarationExp *)ec->e1; + VarExp *ve = (VarExp *)ec->e2; + if (ve->var == de->declaration && ve->var->storage_class & STCctfe) + { VarDeclaration *v = ve->var->isVarDeclaration(); + if (v && v->init) + { + ExpInitializer *ei = v->init->isExpInitializer(); + if (ei) + { Expression *e = ei->exp; + if (e->op == TOKconstruct) + { ConstructExp *ce = (ConstructExp *)e; + if (ce->e1->op == TOKvar && ((VarExp *)ce->e1)->var == ve->var) + e = ce->e2; + } + return e; + } + } + } + } + } + return NULL; +} + +/************************************************ + * Destructors are attached to VarDeclarations. + * Hence, if expression returns a temp that needs a destructor, + * make sure and create a VarDeclaration for that temp. + */ + +Expression *Expression::addDtorHook(Scope *sc) +{ + return this; +} + +/******************************** IntegerExp **************************/ + +IntegerExp::IntegerExp(Loc loc, dinteger_t value, Type *type) + : Expression(loc, TOKint64, sizeof(IntegerExp)) +{ + //printf("IntegerExp(value = %lld, type = '%s')\n", value, type ? type->toChars() : ""); + if (type && !type->isscalar()) + { + //printf("%s, loc = %d\n", toChars(), loc.linnum); + if (type->ty != Terror) + error("integral constant must be scalar type, not %s", type->toChars()); + type = Type::terror; + } + this->type = type; + this->value = value; +} + +IntegerExp::IntegerExp(dinteger_t value) + : Expression(0, TOKint64, sizeof(IntegerExp)) +{ + this->type = Type::tint32; + this->value = value; +} + +int IntegerExp::equals(Object *o) +{ IntegerExp *ne; + + if (this == o || + (((Expression *)o)->op == TOKint64 && + ((ne = (IntegerExp *)o), type->toHeadMutable()->equals(ne->type->toHeadMutable())) && + value == ne->value)) + return 1; + return 0; +} + +char *IntegerExp::toChars() +{ +#if 1 + return Expression::toChars(); +#else + static char buffer[sizeof(value) * 3 + 1]; + + sprintf(buffer, "%jd", value); + return buffer; +#endif +} + +dinteger_t IntegerExp::toInteger() +{ Type *t; + + t = type; + while (t) + { + switch (t->ty) + { + case Tbool: value = (value != 0); break; + case Tint8: value = (d_int8) value; break; + case Tchar: + case Tuns8: value = (d_uns8) value; break; + case Tint16: value = (d_int16) value; break; + case Twchar: + case Tuns16: value = (d_uns16) value; break; + case Tint32: value = (d_int32) value; break; + case Tdchar: + case Tuns32: value = (d_uns32) value; break; + case Tint64: value = (d_int64) value; break; + case Tuns64: value = (d_uns64) value; break; + case Tpointer: + if (PTRSIZE == 4) + value = (d_uns32) value; + else if (PTRSIZE == 8) + value = (d_uns64) value; + else + assert(0); + break; + + case Tenum: + { + TypeEnum *te = (TypeEnum *)t; + t = te->sym->memtype; + continue; + } + + case Ttypedef: + { + TypeTypedef *tt = (TypeTypedef *)t; + t = tt->sym->basetype; + continue; + } + + default: + /* This can happen if errors, such as + * the type is painted on like in fromConstInitializer(). + */ + if (!global.errors) + { + printf("e = %p, ty = %d\n", this, type->ty); + type->print(); + assert(0); + } + break; + } + break; + } + return value; +} + +real_t IntegerExp::toReal() +{ + Type *t; + + toInteger(); + t = type->toBasetype(); + if (t->ty == Tuns64) + return (real_t)(d_uns64)value; + else + return (real_t)(d_int64)value; +} + +real_t IntegerExp::toImaginary() +{ + return (real_t) 0; +} + +complex_t IntegerExp::toComplex() +{ + return toReal(); +} + +int IntegerExp::isBool(int result) +{ + int r = toInteger() != 0; + return result ? r : !r; +} + +Expression *IntegerExp::semantic(Scope *sc) +{ + if (!type) + { + // Determine what the type of this number is + dinteger_t number = value; + + if (number & 0x8000000000000000LL) + type = Type::tuns64; + else if (number & 0xFFFFFFFF80000000LL) + type = Type::tint64; + else + type = Type::tint32; + } + else + { if (!type->deco) + type = type->semantic(loc, sc); + } + return this; +} + +Expression *IntegerExp::toLvalue(Scope *sc, Expression *e) +{ + if (!e) + e = this; + else if (!loc.filename) + loc = e->loc; + e->error("constant %s is not an lvalue", e->toChars()); + return new ErrorExp(); +} + +void IntegerExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + dinteger_t v = toInteger(); + + if (type) + { Type *t = type; + + L1: + switch (t->ty) + { + case Tenum: + { TypeEnum *te = (TypeEnum *)t; + buf->printf("cast(%s)", te->sym->toChars()); + t = te->sym->memtype; + goto L1; + } + + case Ttypedef: + { TypeTypedef *tt = (TypeTypedef *)t; + buf->printf("cast(%s)", tt->sym->toChars()); + t = tt->sym->basetype; + goto L1; + } + + case Twchar: // BUG: need to cast(wchar) + case Tdchar: // BUG: need to cast(dchar) + if ((uinteger_t)v > 0xFF) + { + buf->printf("'\\U%08x'", v); + break; + } + case Tchar: + { + unsigned o = buf->offset; + if (v == '\'') + buf->writestring("'\\''"); + else if (isprint(v) && v != '\\') + buf->printf("'%c'", (int)v); + else + buf->printf("'\\x%02x'", (int)v); + if (hgs->ddoc) + escapeDdocString(buf, o); + break; + } + + case Tint8: + buf->writestring("cast(byte)"); + goto L2; + + case Tint16: + buf->writestring("cast(short)"); + goto L2; + + case Tint32: + L2: + buf->printf("%d", (int)v); + break; + + case Tuns8: + buf->writestring("cast(ubyte)"); + goto L3; + + case Tuns16: + buf->writestring("cast(ushort)"); + goto L3; + + case Tuns32: + L3: + buf->printf("%du", (unsigned)v); + break; + + case Tint64: + buf->printf("%jdL", v); + break; + + case Tuns64: + L4: + buf->printf("%juLU", v); + break; + + case Tbool: + buf->writestring((char *)(v ? "true" : "false")); + break; + + case Tpointer: + buf->writestring("cast("); + buf->writestring(t->toChars()); + buf->writeByte(')'); + if (PTRSIZE == 4) + goto L3; + else if (PTRSIZE == 8) + goto L4; + else + assert(0); + + default: + /* This can happen if errors, such as + * the type is painted on like in fromConstInitializer(). + */ + if (!global.errors) + { +#ifdef DEBUG + t->print(); +#endif + assert(0); + } + break; + } + } + else if (v & 0x8000000000000000LL) + buf->printf("0x%jx", v); + else + buf->printf("%jd", v); +} + +void IntegerExp::toMangleBuffer(OutBuffer *buf) +{ + if ((sinteger_t)value < 0) + buf->printf("N%jd", -value); + else + { + /* This is an awful hack to maintain backwards compatibility. + * There really always should be an 'i' before a number, but + * there wasn't in earlier implementations, so to maintain + * backwards compatibility it is only done if necessary to disambiguate. + * See bugzilla 3029 + */ + if (buf->offset > 0 && isdigit(buf->data[buf->offset - 1])) + buf->writeByte('i'); + + buf->printf("%jd", value); + } +} + +/******************************** ErrorExp **************************/ + +/* Use this expression for error recovery. + * It should behave as a 'sink' to prevent further cascaded error messages. + */ + +ErrorExp::ErrorExp() + : IntegerExp(0, 0, Type::terror) +{ + op = TOKerror; +} + +Expression *ErrorExp::toLvalue(Scope *sc, Expression *e) +{ + return this; +} + +void ErrorExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("__error"); +} + +/******************************** RealExp **************************/ + +RealExp::RealExp(Loc loc, real_t value, Type *type) + : Expression(loc, TOKfloat64, sizeof(RealExp)) +{ + //printf("RealExp::RealExp(%Lg)\n", value); + this->value = value; + this->type = type; +} + +char *RealExp::toChars() +{ + char buffer[sizeof(value) * 3 + 8 + 1 + 1]; + +#ifdef IN_GCC + value.format(buffer, sizeof(buffer)); + if (type->isimaginary()) + strcat(buffer, "i"); +#else + sprintf(buffer, type->isimaginary() ? "%Lgi" : "%Lg", value); +#endif + assert(strlen(buffer) < sizeof(buffer)); + return mem.strdup(buffer); +} + +dinteger_t RealExp::toInteger() +{ +#ifdef IN_GCC + return toReal().toInt(); +#else + return (sinteger_t) toReal(); +#endif +} + +uinteger_t RealExp::toUInteger() +{ +#ifdef IN_GCC + return (uinteger_t) toReal().toInt(); +#else + return (uinteger_t) toReal(); +#endif +} + +real_t RealExp::toReal() +{ + return type->isreal() ? value : 0; +} + +real_t RealExp::toImaginary() +{ + return type->isreal() ? 0 : value; +} + +complex_t RealExp::toComplex() +{ +#ifdef __DMC__ + return toReal() + toImaginary() * I; +#else + return complex_t(toReal(), toImaginary()); +#endif +} + +/******************************** + * Test to see if two reals are the same. + * Regard NaN's as equivalent. + * Regard +0 and -0 as different. + */ + +int RealEquals(real_t x1, real_t x2) +{ + return (Port::isNan(x1) && Port::isNan(x2)) || + /* In some cases, the REALPAD bytes get garbage in them, + * so be sure and ignore them. + */ + memcmp(&x1, &x2, REALSIZE - REALPAD) == 0; +} + +int RealExp::equals(Object *o) +{ RealExp *ne; + + if (this == o || + (((Expression *)o)->op == TOKfloat64 && + ((ne = (RealExp *)o), type->toHeadMutable()->equals(ne->type->toHeadMutable())) && + RealEquals(value, ne->value) + ) + ) + return 1; + return 0; +} + +Expression *RealExp::semantic(Scope *sc) +{ + if (!type) + type = Type::tfloat64; + else + type = type->semantic(loc, sc); + return this; +} + +int RealExp::isBool(int result) +{ +#ifdef IN_GCC + return result ? (! value.isZero()) : (value.isZero()); +#else + return result ? (value != 0) + : (value == 0); +#endif +} + +void floatToBuffer(OutBuffer *buf, Type *type, real_t value) +{ + /* In order to get an exact representation, try converting it + * to decimal then back again. If it matches, use it. + * If it doesn't, fall back to hex, which is + * always exact. + */ + char buffer[25]; + sprintf(buffer, "%Lg", value); + assert(strlen(buffer) < sizeof(buffer)); +#if _WIN32 && __DMC__ + char *save = __locale_decpoint; + __locale_decpoint = "."; + real_t r = strtold(buffer, NULL); + __locale_decpoint = save; +#else + real_t r = strtold(buffer, NULL); +#endif + if (r == value) // if exact duplication + buf->writestring(buffer); + else + buf->printf("%La", value); // ensure exact duplication + + if (type) + { + Type *t = type->toBasetype(); + switch (t->ty) + { + case Tfloat32: + case Timaginary32: + case Tcomplex32: + buf->writeByte('F'); + break; + + case Tfloat80: + case Timaginary80: + case Tcomplex80: + buf->writeByte('L'); + break; + + default: + break; + } + if (t->isimaginary()) + buf->writeByte('i'); + } +} + +void RealExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + floatToBuffer(buf, type, value); +} + +void realToMangleBuffer(OutBuffer *buf, real_t value) +{ + /* Rely on %A to get portable mangling. + * Must munge result to get only identifier characters. + * + * Possible values from %A => mangled result + * NAN => NAN + * -INF => NINF + * INF => INF + * -0X1.1BC18BA997B95P+79 => N11BC18BA997B95P79 + * 0X1.9P+2 => 19P2 + */ + + if (Port::isNan(value)) + buf->writestring("NAN"); // no -NAN bugs + else + { + char buffer[32]; + int n = sprintf(buffer, "%LA", value); + assert(n > 0 && n < sizeof(buffer)); + for (int i = 0; i < n; i++) + { char c = buffer[i]; + + switch (c) + { + case '-': + buf->writeByte('N'); + break; + + case '+': + case 'X': + case '.': + break; + + case '0': + if (i < 2) + break; // skip leading 0X + default: + buf->writeByte(c); + break; + } + } + } +} + +void RealExp::toMangleBuffer(OutBuffer *buf) +{ + buf->writeByte('e'); + realToMangleBuffer(buf, value); +} + + +/******************************** ComplexExp **************************/ + +ComplexExp::ComplexExp(Loc loc, complex_t value, Type *type) + : Expression(loc, TOKcomplex80, sizeof(ComplexExp)) +{ + this->value = value; + this->type = type; + //printf("ComplexExp::ComplexExp(%s)\n", toChars()); +} + +char *ComplexExp::toChars() +{ + char buffer[sizeof(value) * 3 + 8 + 1]; + +#ifdef IN_GCC + char buf1[sizeof(value) * 3 + 8 + 1]; + char buf2[sizeof(value) * 3 + 8 + 1]; + creall(value).format(buf1, sizeof(buf1)); + cimagl(value).format(buf2, sizeof(buf2)); + sprintf(buffer, "(%s+%si)", buf1, buf2); +#else + sprintf(buffer, "(%Lg+%Lgi)", creall(value), cimagl(value)); + assert(strlen(buffer) < sizeof(buffer)); +#endif + return mem.strdup(buffer); +} + +dinteger_t ComplexExp::toInteger() +{ +#ifdef IN_GCC + return (sinteger_t) toReal().toInt(); +#else + return (sinteger_t) toReal(); +#endif +} + +uinteger_t ComplexExp::toUInteger() +{ +#ifdef IN_GCC + return (uinteger_t) toReal().toInt(); +#else + return (uinteger_t) toReal(); +#endif +} + +real_t ComplexExp::toReal() +{ + return creall(value); +} + +real_t ComplexExp::toImaginary() +{ + return cimagl(value); +} + +complex_t ComplexExp::toComplex() +{ + return value; +} + +int ComplexExp::equals(Object *o) +{ ComplexExp *ne; + + if (this == o || + (((Expression *)o)->op == TOKcomplex80 && + ((ne = (ComplexExp *)o), type->toHeadMutable()->equals(ne->type->toHeadMutable())) && + RealEquals(creall(value), creall(ne->value)) && + RealEquals(cimagl(value), cimagl(ne->value)) + ) + ) + return 1; + return 0; +} + +Expression *ComplexExp::semantic(Scope *sc) +{ + if (!type) + type = Type::tcomplex80; + else + type = type->semantic(loc, sc); + return this; +} + +int ComplexExp::isBool(int result) +{ + if (result) + return (bool)(value); + else + return !value; +} + +void ComplexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + /* Print as: + * (re+imi) + */ +#ifdef IN_GCC + char buf1[sizeof(value) * 3 + 8 + 1]; + char buf2[sizeof(value) * 3 + 8 + 1]; + creall(value).format(buf1, sizeof(buf1)); + cimagl(value).format(buf2, sizeof(buf2)); + buf->printf("(%s+%si)", buf1, buf2); +#else + buf->writeByte('('); + floatToBuffer(buf, type, creall(value)); + buf->writeByte('+'); + floatToBuffer(buf, type, cimagl(value)); + buf->writestring("i)"); +#endif +} + +void ComplexExp::toMangleBuffer(OutBuffer *buf) +{ + buf->writeByte('c'); + real_t r = toReal(); + realToMangleBuffer(buf, r); + buf->writeByte('c'); // separate the two + r = toImaginary(); + realToMangleBuffer(buf, r); +} + +/******************************** IdentifierExp **************************/ + +IdentifierExp::IdentifierExp(Loc loc, Identifier *ident) + : Expression(loc, TOKidentifier, sizeof(IdentifierExp)) +{ + this->ident = ident; +} + +Expression *IdentifierExp::semantic(Scope *sc) +{ + Dsymbol *s; + Dsymbol *scopesym; + +#if LOGSEMANTIC + printf("IdentifierExp::semantic('%s')\n", ident->toChars()); +#endif + s = sc->search(loc, ident, &scopesym); + if (s) + { Expression *e; + WithScopeSymbol *withsym; + + /* See if the symbol was a member of an enclosing 'with' + */ + withsym = scopesym->isWithScopeSymbol(); + if (withsym) + { +#if DMDV2 + /* Disallow shadowing + */ + // First find the scope of the with + Scope *scwith = sc; + while (scwith->scopesym != scopesym) + { scwith = scwith->enclosing; + assert(scwith); + } + // Look at enclosing scopes for symbols with the same name, + // in the same function + for (Scope *scx = scwith; scx && scx->func == scwith->func; scx = scx->enclosing) + { Dsymbol *s2; + + if (scx->scopesym && scx->scopesym->symtab && + (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL && + s != s2) + { + error("with symbol %s is shadowing local symbol %s", s->toPrettyChars(), s2->toPrettyChars()); + return new ErrorExp(); + } + } +#endif + s = s->toAlias(); + + // Same as wthis.ident + if (s->needThis() || s->isTemplateDeclaration()) + { + e = new VarExp(loc, withsym->withstate->wthis); + e = new DotIdExp(loc, e, ident); + } + else + { Type *t = withsym->withstate->wthis->type; + if (t->ty == Tpointer) + t = ((TypePointer *)t)->next; + e = typeDotIdExp(loc, t, ident); + } + } + else + { + /* If f is really a function template, + * then replace f with the function template declaration. + */ + FuncDeclaration *f = s->isFuncDeclaration(); + if (f) + { TemplateDeclaration *tempdecl = getFuncTemplateDecl(f); + if (tempdecl) + { + if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's + tempdecl = tempdecl->overroot; // then get the start + e = new TemplateExp(loc, tempdecl); + e = e->semantic(sc); + return e; + } + } + // Haven't done overload resolution yet, so pass 1 + e = new DsymbolExp(loc, s, 1); + } + return e->semantic(sc); + } +#if DMDV2 + if (hasThis(sc)) + { + AggregateDeclaration *ad = sc->getStructClassScope(); + if (ad && ad->aliasthis) + { + Expression *e; + e = new IdentifierExp(loc, Id::This); + e = new DotIdExp(loc, e, ad->aliasthis->ident); + e = new DotIdExp(loc, e, ident); + e = e->trySemantic(sc); + if (e) + return e; + } + } + if (ident == Id::ctfe) + { // Create the magic __ctfe bool variable + VarDeclaration *vd = new VarDeclaration(loc, Type::tbool, Id::ctfe, NULL); + Expression *e = new VarExp(loc, vd); + e = e->semantic(sc); + return e; + } +#endif + const char *n = importHint(ident->toChars()); + if (n) + error("'%s' is not defined, perhaps you need to import %s; ?", ident->toChars(), n); + else + { + s = sc->search_correct(ident); + if (s) + error("undefined identifier %s, did you mean %s %s?", ident->toChars(), s->kind(), s->toChars()); + else + error("undefined identifier %s", ident->toChars()); + } + return new ErrorExp(); +} + +char *IdentifierExp::toChars() +{ + return ident->toChars(); +} + +void IdentifierExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen) + buf->writestring(ident->toHChars2()); + else + buf->writestring(ident->toChars()); +} + +#if DMDV2 +int IdentifierExp::isLvalue() +{ + return 1; +} +#endif + +Expression *IdentifierExp::toLvalue(Scope *sc, Expression *e) +{ +#if 0 + tym = tybasic(e1->ET->Tty); + if (!(tyscalar(tym) || + tym == TYstruct || + tym == TYarray && e->Eoper == TOKaddr)) + synerr(EM_lvalue); // lvalue expected +#endif + return this; +} + +/******************************** DollarExp **************************/ + +DollarExp::DollarExp(Loc loc) + : IdentifierExp(loc, Id::dollar) +{ +} + +/******************************** DsymbolExp **************************/ + +DsymbolExp::DsymbolExp(Loc loc, Dsymbol *s, int hasOverloads) + : Expression(loc, TOKdsymbol, sizeof(DsymbolExp)) +{ + this->s = s; + this->hasOverloads = hasOverloads; +} + +Expression *DsymbolExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DsymbolExp::semantic('%s')\n", s->toChars()); +#endif + +Lagain: + EnumMember *em; + Expression *e; + VarDeclaration *v; + FuncDeclaration *f; + FuncLiteralDeclaration *fld; + OverloadSet *o; + ClassDeclaration *cd; + ClassDeclaration *thiscd = NULL; + Import *imp; + Package *pkg; + Type *t; + + //printf("DsymbolExp:: %p '%s' is a symbol\n", this, toChars()); + //printf("s = '%s', s->kind = '%s'\n", s->toChars(), s->kind()); + if (type) + return this; + if (!s->isFuncDeclaration()) // functions are checked after overloading + checkDeprecated(sc, s); + Dsymbol *olds = s; + s = s->toAlias(); + //printf("s = '%s', s->kind = '%s', s->needThis() = %p\n", s->toChars(), s->kind(), s->needThis()); + if (s != olds && !s->isFuncDeclaration()) + checkDeprecated(sc, s); + + if (sc->func) + thiscd = sc->func->parent->isClassDeclaration(); + + // BUG: This should happen after overload resolution for functions, not before + if (s->needThis()) + { + if (hasThis(sc) +#if DMDV2 + && !s->isFuncDeclaration() +#endif + ) + { + // Supply an implicit 'this', as in + // this.ident + + DotVarExp *de; + + de = new DotVarExp(loc, new ThisExp(loc), s->isDeclaration()); + return de->semantic(sc); + } + } + + em = s->isEnumMember(); + if (em) + { + e = em->value; + e = e->semantic(sc); + return e; + } + v = s->isVarDeclaration(); + if (v) + { + //printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); + if (!type) + { if ((!v->type || !v->type->deco) && v->scope) + v->semantic(v->scope); + type = v->type; + if (!v->type) + { error("forward reference of %s %s", v->kind(), v->toChars()); + return new ErrorExp(); + } + } + + if ((v->storage_class & STCmanifest) && v->init) + { + e = v->init->toExpression(); + if (!e) + { error("cannot make expression out of initializer for %s", v->toChars()); + return new ErrorExp(); + } + e = e->copy(); + e->loc = loc; // for better error message + e = e->semantic(sc); + return e; + } + + e = new VarExp(loc, v); + e->type = type; + e = e->semantic(sc); + return e->deref(); + } + fld = s->isFuncLiteralDeclaration(); + if (fld) + { //printf("'%s' is a function literal\n", fld->toChars()); + e = new FuncExp(loc, fld); + return e->semantic(sc); + } + f = s->isFuncDeclaration(); + if (f) + { //printf("'%s' is a function\n", f->toChars()); + + if (!f->originalType && f->scope) // semantic not yet run + f->semantic(f->scope); + + // if inferring return type, sematic3 needs to be run + if (f->inferRetType && f->scope && f->type && !f->type->nextOf()) + { + TemplateInstance *spec = isSpeculativeFunction(f); + int olderrs = global.errors; + f->semantic3(f->scope); + // Update the template instantiation with the number + // of errors which occured. + if (spec && global.errors != olderrs) + spec->errors = global.errors - olderrs; + } + + if (f->isUnitTestDeclaration()) + { + error("cannot call unittest function %s", toChars()); + return new ErrorExp(); + } + if (!f->type->deco) + { + error("forward reference to %s", toChars()); + return new ErrorExp(); + } + return new VarExp(loc, f, hasOverloads); + } + o = s->isOverloadSet(); + if (o) + { //printf("'%s' is an overload set\n", o->toChars()); + return new OverExp(o); + } + cd = s->isClassDeclaration(); + if (cd && thiscd && cd->isBaseOf(thiscd, NULL) && sc->func->needThis()) + { + // We need to add an implicit 'this' if cd is this class or a base class. + DotTypeExp *dte; + + dte = new DotTypeExp(loc, new ThisExp(loc), s); + return dte->semantic(sc); + } + imp = s->isImport(); + if (imp) + { + if (!imp->pkg) + { error("forward reference of import %s", imp->toChars()); + return new ErrorExp(); + } + ScopeExp *ie = new ScopeExp(loc, imp->pkg); + return ie->semantic(sc); + } + pkg = s->isPackage(); + if (pkg) + { + ScopeExp *ie; + + ie = new ScopeExp(loc, pkg); + return ie->semantic(sc); + } + Module *mod = s->isModule(); + if (mod) + { + ScopeExp *ie; + + ie = new ScopeExp(loc, mod); + return ie->semantic(sc); + } + + t = s->getType(); + if (t) + { + TypeExp *te = new TypeExp(loc, t); + return te->semantic(sc); + } + + TupleDeclaration *tup = s->isTupleDeclaration(); + if (tup) + { + e = new TupleExp(loc, tup); + e = e->semantic(sc); + return e; + } + + TemplateInstance *ti = s->isTemplateInstance(); + if (ti && !global.errors) + { if (!ti->semanticRun) + ti->semantic(sc); + s = ti->inst->toAlias(); + if (!s->isTemplateInstance()) + goto Lagain; + e = new ScopeExp(loc, ti); + e = e->semantic(sc); + return e; + } + + TemplateDeclaration *td = s->isTemplateDeclaration(); + if (td) + { +#if 0 // This was the fix for Bugzilla 6738, but it breaks 7498 + Dsymbol *p = td->toParent2(); + if (hasThis(sc) && p && p->isAggregateDeclaration()) + e = new DotTemplateExp(loc, new ThisExp(loc), td); + else +#endif + e = new TemplateExp(loc, td); + e = e->semantic(sc); + return e; + } + + error("%s '%s' is not a variable", s->kind(), s->toChars()); + return new ErrorExp(); +} + +char *DsymbolExp::toChars() +{ + return s->toChars(); +} + +void DsymbolExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(s->toChars()); +} + +#if DMDV2 +int DsymbolExp::isLvalue() +{ + return 1; +} +#endif + +Expression *DsymbolExp::toLvalue(Scope *sc, Expression *e) +{ +#if 0 + tym = tybasic(e1->ET->Tty); + if (!(tyscalar(tym) || + tym == TYstruct || + tym == TYarray && e->Eoper == TOKaddr)) + synerr(EM_lvalue); // lvalue expected +#endif + return this; +} + +/******************************** ThisExp **************************/ + +ThisExp::ThisExp(Loc loc) + : Expression(loc, TOKthis, sizeof(ThisExp)) +{ + //printf("ThisExp::ThisExp() loc = %d\n", loc.linnum); + var = NULL; +} + +Expression *ThisExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("ThisExp::semantic()\n"); +#endif + if (type) + { //assert(global.errors || var); + return this; + } + + FuncDeclaration *fd = hasThis(sc); // fd is the uplevel function with the 'this' variable + + /* Special case for typeof(this) and typeof(super) since both + * should work even if they are not inside a non-static member function + */ + if (!fd && sc->intypeof) + { + // Find enclosing struct or class + for (Dsymbol *s = sc->getStructClassScope(); 1; s = s->parent) + { + if (!s) + { + error("%s is not in a class or struct scope", toChars()); + goto Lerr; + } + ClassDeclaration *cd = s->isClassDeclaration(); + if (cd) + { + type = cd->type; + return this; + } + StructDeclaration *sd = s->isStructDeclaration(); + if (sd) + { +#if STRUCTTHISREF + type = sd->type; +#else + type = sd->type->pointerTo(); +#endif + return this; + } + } + } + if (!fd) + goto Lerr; + + assert(fd->vthis); + var = fd->vthis; + assert(var->parent); + type = var->type; + var->isVarDeclaration()->checkNestedReference(sc, loc); + if (!sc->intypeof) + sc->callSuper |= CSXthis; + return this; + +Lerr: + error("'this' is only defined in non-static member functions, not %s", sc->parent->toChars()); + return new ErrorExp(); +} + +int ThisExp::isBool(int result) +{ + return result ? TRUE : FALSE; +} + +void ThisExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("this"); +} + +#if DMDV2 +int ThisExp::isLvalue() +{ + return 1; +} +#endif + +Expression *ThisExp::toLvalue(Scope *sc, Expression *e) +{ + return this; +} + +/******************************** SuperExp **************************/ + +SuperExp::SuperExp(Loc loc) + : ThisExp(loc) +{ + op = TOKsuper; +} + +Expression *SuperExp::semantic(Scope *sc) +{ + ClassDeclaration *cd; + Dsymbol *s; + +#if LOGSEMANTIC + printf("SuperExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + FuncDeclaration *fd = hasThis(sc); + + /* Special case for typeof(this) and typeof(super) since both + * should work even if they are not inside a non-static member function + */ + if (!fd && sc->intypeof) + { + // Find enclosing class + for (Dsymbol *s = sc->getStructClassScope(); 1; s = s->parent) + { + if (!s) + { + error("%s is not in a class scope", toChars()); + goto Lerr; + } + ClassDeclaration *cd = s->isClassDeclaration(); + if (cd) + { + cd = cd->baseClass; + if (!cd) + { error("class %s has no 'super'", s->toChars()); + goto Lerr; + } + type = cd->type; + return this; + } + } + } + if (!fd) + goto Lerr; + + assert(fd->vthis); + var = fd->vthis; + assert(var->parent); + + s = fd->toParent(); + while (s && s->isTemplateInstance()) + s = s->toParent(); + assert(s); + cd = s->isClassDeclaration(); +//printf("parent is %s %s\n", fd->toParent()->kind(), fd->toParent()->toChars()); + if (!cd) + goto Lerr; + if (!cd->baseClass) + { + error("no base class for %s", cd->toChars()); + type = fd->vthis->type; + } + else + { + type = cd->baseClass->type; + type = type->castMod(var->type->mod); + } + + var->isVarDeclaration()->checkNestedReference(sc, loc); + + if (!sc->intypeof) + sc->callSuper |= CSXsuper; + return this; + + +Lerr: + error("'super' is only allowed in non-static class member functions"); + return new ErrorExp(); +} + +void SuperExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("super"); +} + + +/******************************** NullExp **************************/ + +NullExp::NullExp(Loc loc, Type *type) + : Expression(loc, TOKnull, sizeof(NullExp)) +{ + committed = 0; + this->type = type; +} + +int NullExp::equals(Object *o) +{ + if (o && o->dyncast() == DYNCAST_EXPRESSION) + { Expression *e = (Expression *)o; + + if (e->op == TOKnull) + return TRUE; + } + return FALSE; +} + +Expression *NullExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("NullExp::semantic('%s')\n", toChars()); +#endif + // NULL is the same as (void *)0 + if (!type) + type = Type::tnull; + return this; +} + +int NullExp::isBool(int result) +{ + return result ? FALSE : TRUE; +} + +StringExp *NullExp::toString() +{ + if (implicitConvTo(Type::tstring)) + { + StringExp *se = new StringExp(loc, (char*)mem.calloc(1, 1), 0); + se->type = Type::tstring; + return se; + } + return NULL; +} + +void NullExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("null"); +} + +void NullExp::toMangleBuffer(OutBuffer *buf) +{ + buf->writeByte('n'); +} + +/******************************** StringExp **************************/ + +StringExp::StringExp(Loc loc, char *string) + : Expression(loc, TOKstring, sizeof(StringExp)) +{ + this->string = string; + this->len = strlen(string); + this->sz = 1; + this->committed = 0; + this->postfix = 0; + this->ownedByCtfe = false; +} + +StringExp::StringExp(Loc loc, void *string, size_t len) + : Expression(loc, TOKstring, sizeof(StringExp)) +{ + this->string = string; + this->len = len; + this->sz = 1; + this->committed = 0; + this->postfix = 0; + this->ownedByCtfe = false; +} + +StringExp::StringExp(Loc loc, void *string, size_t len, unsigned char postfix) + : Expression(loc, TOKstring, sizeof(StringExp)) +{ + this->string = string; + this->len = len; + this->sz = 1; + this->committed = 0; + this->postfix = postfix; + this->ownedByCtfe = false; +} + +#if 0 +Expression *StringExp::syntaxCopy() +{ + printf("StringExp::syntaxCopy() %s\n", toChars()); + return copy(); +} +#endif + +int StringExp::equals(Object *o) +{ + //printf("StringExp::equals('%s') %s\n", o->toChars(), toChars()); + if (o && o->dyncast() == DYNCAST_EXPRESSION) + { Expression *e = (Expression *)o; + + if (e->op == TOKstring) + { + return compare(o) == 0; + } + } + return FALSE; +} + +char *StringExp::toChars() +{ + OutBuffer buf; + HdrGenState hgs; + char *p; + + memset(&hgs, 0, sizeof(hgs)); + toCBuffer(&buf, &hgs); + buf.writeByte(0); + p = (char *)buf.data; + buf.data = NULL; + return p; +} + +Expression *StringExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("StringExp::semantic() %s\n", toChars()); +#endif + if (!type) + { OutBuffer buffer; + size_t newlen = 0; + const char *p; + size_t u; + unsigned c; + + switch (postfix) + { + case 'd': + for (u = 0; u < len;) + { + p = utf_decodeChar((unsigned char *)string, len, &u, &c); + if (p) + { error("%s", p); + return new ErrorExp(); + } + else + { buffer.write4(c); + newlen++; + } + } + buffer.write4(0); + string = buffer.extractData(); + len = newlen; + sz = 4; + //type = new TypeSArray(Type::tdchar, new IntegerExp(loc, len, Type::tindex)); + type = new TypeDArray(Type::tdchar->invariantOf()); + committed = 1; + break; + + case 'w': + for (u = 0; u < len;) + { + p = utf_decodeChar((unsigned char *)string, len, &u, &c); + if (p) + { error("%s", p); + return new ErrorExp(); + } + else + { buffer.writeUTF16(c); + newlen++; + if (c >= 0x10000) + newlen++; + } + } + buffer.writeUTF16(0); + string = buffer.extractData(); + len = newlen; + sz = 2; + //type = new TypeSArray(Type::twchar, new IntegerExp(loc, len, Type::tindex)); + type = new TypeDArray(Type::twchar->invariantOf()); + committed = 1; + break; + + case 'c': + committed = 1; + default: + //type = new TypeSArray(Type::tchar, new IntegerExp(loc, len, Type::tindex)); + type = new TypeDArray(Type::tchar->invariantOf()); + break; + } + type = type->semantic(loc, sc); + //type = type->invariantOf(); + //printf("type = %s\n", type->toChars()); + } + return this; +} + +/********************************** + * Return length of string. + */ + +size_t StringExp::length() +{ + size_t result = 0; + dchar_t c; + const char *p; + + switch (sz) + { + case 1: + for (size_t u = 0; u < len;) + { + p = utf_decodeChar((unsigned char *)string, len, &u, &c); + if (p) + { error("%s", p); + return 0; + } + else + result++; + } + break; + + case 2: + for (size_t u = 0; u < len;) + { + p = utf_decodeWchar((unsigned short *)string, len, &u, &c); + if (p) + { error("%s", p); + return 0; + } + else + result++; + } + break; + + case 4: + result = len; + break; + + default: + assert(0); + } + return result; +} + +StringExp *StringExp::toString() +{ + return this; +} + +/**************************************** + * Convert string to char[]. + */ + +StringExp *StringExp::toUTF8(Scope *sc) +{ + if (sz != 1) + { // Convert to UTF-8 string + committed = 0; + Expression *e = castTo(sc, Type::tchar->arrayOf()); + e = e->optimize(WANTvalue); + assert(e->op == TOKstring); + StringExp *se = (StringExp *)e; + assert(se->sz == 1); + return se; + } + return this; +} + +int StringExp::compare(Object *obj) +{ + //printf("StringExp::compare()\n"); + // Used to sort case statement expressions so we can do an efficient lookup + StringExp *se2 = (StringExp *)(obj); + + // This is a kludge so isExpression() in template.c will return 5 + // for StringExp's. + if (!se2) + return 5; + + assert(se2->op == TOKstring); + + int len1 = len; + int len2 = se2->len; + + //printf("sz = %d, len1 = %d, len2 = %d\n", sz, len1, len2); + if (len1 == len2) + { + switch (sz) + { + case 1: + return memcmp((char *)string, (char *)se2->string, len1); + + case 2: + { unsigned u; + d_wchar *s1 = (d_wchar *)string; + d_wchar *s2 = (d_wchar *)se2->string; + + for (u = 0; u < len; u++) + { + if (s1[u] != s2[u]) + return s1[u] - s2[u]; + } + } + + case 4: + { unsigned u; + d_dchar *s1 = (d_dchar *)string; + d_dchar *s2 = (d_dchar *)se2->string; + + for (u = 0; u < len; u++) + { + if (s1[u] != s2[u]) + return s1[u] - s2[u]; + } + } + break; + + default: + assert(0); + } + } + return len1 - len2; +} + +int StringExp::isBool(int result) +{ + return result ? TRUE : FALSE; +} + +#if DMDV2 +int StringExp::isLvalue() +{ + /* string literal is rvalue in default, but + * conversion to reference of static array is only allowed. + */ + return 0; +} +#endif + +Expression *StringExp::toLvalue(Scope *sc, Expression *e) +{ + //printf("StringExp::toLvalue(%s)\n", toChars()); + return this; +} + +Expression *StringExp::modifiableLvalue(Scope *sc, Expression *e) +{ + error("Cannot modify '%s'", toChars()); + return new ErrorExp(); +} + +unsigned StringExp::charAt(size_t i) +{ unsigned value; + + switch (sz) + { + case 1: + value = ((unsigned char *)string)[i]; + break; + + case 2: + value = ((unsigned short *)string)[i]; + break; + + case 4: + value = ((unsigned int *)string)[i]; + break; + + default: + assert(0); + break; + } + return value; +} + +void StringExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('"'); + unsigned o = buf->offset; + for (size_t i = 0; i < len; i++) + { unsigned c = charAt(i); + + switch (c) + { + case '"': + case '\\': + if (!hgs->console) + buf->writeByte('\\'); + default: + if (c <= 0xFF) + { if (c <= 0x7F && (isprint(c) || hgs->console)) + buf->writeByte(c); + else + buf->printf("\\x%02x", c); + } + else if (c <= 0xFFFF) + buf->printf("\\x%02x\\x%02x", c & 0xFF, c >> 8); + else + buf->printf("\\x%02x\\x%02x\\x%02x\\x%02x", + c & 0xFF, (c >> 8) & 0xFF, (c >> 16) & 0xFF, c >> 24); + break; + } + } + if (hgs->ddoc) + escapeDdocString(buf, o); + buf->writeByte('"'); + if (postfix) + buf->writeByte(postfix); +} + +void StringExp::toMangleBuffer(OutBuffer *buf) +{ char m; + OutBuffer tmp; + const char *p; + unsigned c; + size_t u; + unsigned char *q; + unsigned qlen; + + /* Write string in UTF-8 format + */ + switch (sz) + { case 1: + m = 'a'; + q = (unsigned char *)string; + qlen = len; + break; + case 2: + m = 'w'; + for (u = 0; u < len; ) + { + p = utf_decodeWchar((unsigned short *)string, len, &u, &c); + if (p) + error("%s", p); + else + tmp.writeUTF8(c); + } + q = tmp.data; + qlen = tmp.offset; + break; + case 4: + m = 'd'; + for (u = 0; u < len; u++) + { + c = ((unsigned *)string)[u]; + if (!utf_isValidDchar(c)) + error("invalid UCS-32 char \\U%08x", c); + else + tmp.writeUTF8(c); + } + q = tmp.data; + qlen = tmp.offset; + break; + default: + assert(0); + } + buf->reserve(1 + 11 + 2 * qlen); + buf->writeByte(m); + buf->printf("%d_", qlen); // nbytes <= 11 + + for (unsigned char *p = buf->data + buf->offset, *pend = p + 2 * qlen; + p < pend; p += 2, ++q) + { + unsigned char hi = *q >> 4 & 0xF; + p[0] = (hi < 10 ? hi + '0' : hi - 10 + 'a'); + unsigned char lo = *q & 0xF; + p[1] = (lo < 10 ? lo + '0' : lo - 10 + 'a'); + } + buf->offset += 2 * qlen; +} + +/************************ ArrayLiteralExp ************************************/ + +// [ e1, e2, e3, ... ] + +ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expressions *elements) + : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) +{ + this->elements = elements; + this->ownedByCtfe = false; +} + +ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expression *e) + : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) +{ + elements = new Expressions; + elements->push(e); +} + +Expression *ArrayLiteralExp::syntaxCopy() +{ + return new ArrayLiteralExp(loc, arraySyntaxCopy(elements)); +} + +Expression *ArrayLiteralExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("ArrayLiteralExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + /* Perhaps an empty array literal [ ] should be rewritten as null? + */ + + arrayExpressionSemantic(elements, sc); // run semantic() on each element + expandTuples(elements); + + Type *t0; + elements = arrayExpressionToCommonType(sc, elements, &t0); + + type = t0->arrayOf(); + //type = new TypeSArray(t0, new IntegerExp(elements->dim)); + type = type->semantic(loc, sc); + + /* Disallow array literals of type void being used. + */ + if (elements->dim > 0 && t0->ty == Tvoid) + { error("%s of type %s has no value", toChars(), type->toChars()); + return new ErrorExp(); + } + + return this; +} + +int ArrayLiteralExp::isBool(int result) +{ + size_t dim = elements ? elements->dim : 0; + return result ? (dim != 0) : (dim == 0); +} + +StringExp *ArrayLiteralExp::toString() +{ + TY telem = type->nextOf()->toBasetype()->ty; + + if (telem == Tchar || telem == Twchar || telem == Tdchar || + (telem == Tvoid && (!elements || elements->dim == 0))) + { + OutBuffer buf; + if (elements) + for (int i = 0; i < elements->dim; ++i) + { + Expression *ch = elements->tdata()[i]; + if (ch->op != TOKint64) + return NULL; + buf.writedchar(ch->toInteger()); + } + buf.writebyte(0); + + char prefix = 'c'; + if (telem == Twchar) prefix = 'w'; + else if (telem == Tdchar) prefix = 'd'; + + StringExp *se = new StringExp(loc, buf.extractData(), buf.size - 1, prefix); + se->type = type; + return se; + } + return NULL; +} + +void ArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('['); + argsToCBuffer(buf, elements, hgs); + buf->writeByte(']'); +} + +void ArrayLiteralExp::toMangleBuffer(OutBuffer *buf) +{ + size_t dim = elements ? elements->dim : 0; + buf->printf("A%u", dim); + for (size_t i = 0; i < dim; i++) + { Expression *e = elements->tdata()[i]; + e->toMangleBuffer(buf); + } +} + +/************************ AssocArrayLiteralExp ************************************/ + +// [ key0 : value0, key1 : value1, ... ] + +AssocArrayLiteralExp::AssocArrayLiteralExp(Loc loc, + Expressions *keys, Expressions *values) + : Expression(loc, TOKassocarrayliteral, sizeof(AssocArrayLiteralExp)) +{ + assert(keys->dim == values->dim); + this->keys = keys; + this->values = values; + this->ownedByCtfe = false; +} + +Expression *AssocArrayLiteralExp::syntaxCopy() +{ + return new AssocArrayLiteralExp(loc, + arraySyntaxCopy(keys), arraySyntaxCopy(values)); +} + +Expression *AssocArrayLiteralExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("AssocArrayLiteralExp::semantic('%s')\n", toChars()); +#endif + + if (type) + return this; + + // Run semantic() on each element + arrayExpressionSemantic(keys, sc); + arrayExpressionSemantic(values, sc); + expandTuples(keys); + expandTuples(values); + if (keys->dim != values->dim) + { + error("number of keys is %u, must match number of values %u", keys->dim, values->dim); + return new ErrorExp(); + } + + Type *tkey = NULL; + Type *tvalue = NULL; + keys = arrayExpressionToCommonType(sc, keys, &tkey); + values = arrayExpressionToCommonType(sc, values, &tvalue); + + type = new TypeAArray(tvalue, tkey); + type = type->semantic(loc, sc); + return this; +} + + +int AssocArrayLiteralExp::isBool(int result) +{ + size_t dim = keys->dim; + return result ? (dim != 0) : (dim == 0); +} + +void AssocArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('['); + for (size_t i = 0; i < keys->dim; i++) + { Expression *key = keys->tdata()[i]; + Expression *value = values->tdata()[i]; + + if (i) + buf->writeByte(','); + expToCBuffer(buf, hgs, key, PREC_assign); + buf->writeByte(':'); + expToCBuffer(buf, hgs, value, PREC_assign); + } + buf->writeByte(']'); +} + +void AssocArrayLiteralExp::toMangleBuffer(OutBuffer *buf) +{ + size_t dim = keys->dim; + buf->printf("A%u", dim); + for (size_t i = 0; i < dim; i++) + { Expression *key = keys->tdata()[i]; + Expression *value = values->tdata()[i]; + + key->toMangleBuffer(buf); + value->toMangleBuffer(buf); + } +} + +/************************ StructLiteralExp ************************************/ + +// sd( e1, e2, e3, ... ) + +StructLiteralExp::StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements, Type *stype) + : Expression(loc, TOKstructliteral, sizeof(StructLiteralExp)) +{ + this->sd = sd; + this->elements = elements; + this->stype = stype; + this->sym = NULL; + this->soffset = 0; + this->fillHoles = 1; + this->ownedByCtfe = false; +} + +Expression *StructLiteralExp::syntaxCopy() +{ + return new StructLiteralExp(loc, sd, arraySyntaxCopy(elements), stype); +} + +Expression *StructLiteralExp::semantic(Scope *sc) +{ Expression *e; + size_t nfields = sd->fields.dim - sd->isnested; + +#if LOGSEMANTIC + printf("StructLiteralExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + elements = arrayExpressionSemantic(elements, sc); // run semantic() on each element + expandTuples(elements); + size_t offset = 0; + for (size_t i = 0; i < elements->dim; i++) + { e = elements->tdata()[i]; + if (!e) + continue; + + e = resolveProperties(sc, e); + if (i >= nfields) + { error("more initializers than fields of %s", sd->toChars()); + return new ErrorExp(); + } + Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + if (v->offset < offset) + { error("overlapping initialization for %s", v->toChars()); + return new ErrorExp(); + } + offset = v->offset + v->type->size(); + + Type *telem = v->type; + if (stype) + telem = telem->addMod(stype->mod); + while (!e->implicitConvTo(telem) && telem->toBasetype()->ty == Tsarray) + { /* Static array initialization, as in: + * T[3][5] = e; + */ + telem = telem->toBasetype()->nextOf(); + } + + if (e->op == TOKfunction) + { e = ((FuncExp *)e)->inferType(sc, telem); + if (!e) + { error("cannot infer function literal type from %s", telem->toChars()); + e = new ErrorExp(); + } + } + + e = e->implicitCastTo(sc, telem); + + elements->tdata()[i] = e; + } + + /* Fill out remainder of elements[] with default initializers for fields[] + */ + for (size_t i = elements->dim; i < nfields; i++) + { Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + assert(!v->isThisDeclaration()); + + if (v->offset < offset) + { e = NULL; + sd->hasUnions = 1; + } + else + { + if (v->init) + { if (v->init->isVoidInitializer()) + e = NULL; + else + { e = v->init->toExpression(); + if (!e) + { error("cannot make expression out of initializer for %s", v->toChars()); + return new ErrorExp(); + } + else if (v->scope) + { // Do deferred semantic analysis + Initializer *i2 = v->init->syntaxCopy(); + i2 = i2->semantic(v->scope, v->type, WANTinterpret); + e = i2->toExpression(); + // remove v->scope (see bug 3426) + // but not if gagged, for we might be called again. + if (!global.gag) + v->scope = NULL; + } + } + } + else + e = v->type->defaultInitLiteral(loc); + offset = v->offset + v->type->size(); + } + elements->push(e); + } + + type = stype ? stype : sd->type; + + /* If struct requires a destructor, rewrite as: + * (S tmp = S()),tmp + * so that the destructor can be hung on tmp. + */ + if (sd->dtor && sc->func) + { + Identifier *idtmp = Lexer::uniqueId("__sl"); + VarDeclaration *tmp = new VarDeclaration(loc, type, idtmp, new ExpInitializer(0, this)); + tmp->storage_class |= STCctfe; + Expression *ae = new DeclarationExp(loc, tmp); + Expression *e = new CommaExp(loc, ae, new VarExp(loc, tmp)); + e = e->semantic(sc); + return e; + } + + return this; +} + +/************************************** + * Gets expression at offset of type. + * Returns NULL if not found. + */ + +Expression *StructLiteralExp::getField(Type *type, unsigned offset) +{ + //printf("StructLiteralExp::getField(this = %s, type = %s, offset = %u)\n", +// /*toChars()*/"", type->toChars(), offset); + Expression *e = NULL; + int i = getFieldIndex(type, offset); + + if (i != -1) + { + //printf("\ti = %d\n", i); + assert(i < elements->dim); + e = elements->tdata()[i]; + if (e) + { + //printf("e = %s, e->type = %s\n", e->toChars(), e->type->toChars()); + + /* If type is a static array, and e is an initializer for that array, + * then the field initializer should be an array literal of e. + */ + if (e->type->castMod(0) != type->castMod(0) && type->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)type; + uinteger_t length = tsa->dim->toInteger(); + Expressions *z = new Expressions; + z->setDim(length); + for (int q = 0; q < length; ++q) + z->tdata()[q] = e->copy(); + e = new ArrayLiteralExp(loc, z); + e->type = type; + } + else + { + e = e->copy(); + e->type = type; + } + } + } + return e; +} + +/************************************ + * Get index of field. + * Returns -1 if not found. + */ + +int StructLiteralExp::getFieldIndex(Type *type, unsigned offset) +{ + /* Find which field offset is by looking at the field offsets + */ + if (elements->dim) + { + for (size_t i = 0; i < sd->fields.dim; i++) + { + Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + + if (offset == v->offset && + type->size() == v->type->size()) + { Expression *e = elements->tdata()[i]; + if (e) + { + return i; + } + break; + } + } + } + return -1; +} + +#if DMDV2 +int StructLiteralExp::isLvalue() +{ + return 1; +} +#endif + +Expression *StructLiteralExp::toLvalue(Scope *sc, Expression *e) +{ + return this; +} + + +void StructLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(sd->toChars()); + buf->writeByte('('); + argsToCBuffer(buf, elements, hgs); + buf->writeByte(')'); +} + +void StructLiteralExp::toMangleBuffer(OutBuffer *buf) +{ + size_t dim = elements ? elements->dim : 0; + buf->printf("S%u", dim); + for (size_t i = 0; i < dim; i++) + { Expression *e = elements->tdata()[i]; + if (e) + e->toMangleBuffer(buf); + else + buf->writeByte('v'); // 'v' for void + } +} + +/************************ TypeDotIdExp ************************************/ + +/* Things like: + * int.size + * foo.size + * (foo).size + * cast(foo).size + */ + +Expression *typeDotIdExp(Loc loc, Type *type, Identifier *ident) +{ + return new DotIdExp(loc, new TypeExp(loc, type), ident); +} + + +/************************************************************/ + +// Mainly just a placeholder + +TypeExp::TypeExp(Loc loc, Type *type) + : Expression(loc, TOKtype, sizeof(TypeExp)) +{ + //printf("TypeExp::TypeExp(%s)\n", type->toChars()); + this->type = type; +} + +Expression *TypeExp::syntaxCopy() +{ + //printf("TypeExp::syntaxCopy()\n"); + return new TypeExp(loc, type->syntaxCopy()); +} + +Expression *TypeExp::semantic(Scope *sc) +{ + //printf("TypeExp::semantic(%s)\n", type->toChars()); + type = type->semantic(loc, sc); + return this; +} + +int TypeExp::rvalue() +{ + error("type %s has no value", toChars()); + return 0; +} + +void TypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + type->toCBuffer(buf, NULL, hgs); +} + +/************************************************************/ + +// Mainly just a placeholder + +ScopeExp::ScopeExp(Loc loc, ScopeDsymbol *pkg) + : Expression(loc, TOKimport, sizeof(ScopeExp)) +{ + //printf("ScopeExp::ScopeExp(pkg = '%s')\n", pkg->toChars()); + //static int count; if (++count == 38) *(char*)0=0; + this->sds = pkg; +} + +Expression *ScopeExp::syntaxCopy() +{ + ScopeExp *se = new ScopeExp(loc, (ScopeDsymbol *)sds->syntaxCopy(NULL)); + return se; +} + +Expression *ScopeExp::semantic(Scope *sc) +{ + TemplateInstance *ti; + ScopeDsymbol *sds2; + +#if LOGSEMANTIC + printf("+ScopeExp::semantic('%s')\n", toChars()); +#endif +Lagain: + ti = sds->isTemplateInstance(); + if (ti && !global.errors) + { + if (!ti->semanticRun) + ti->semantic(sc); + if (ti->inst) + { + Dsymbol *s = ti->inst->toAlias(); + sds2 = s->isScopeDsymbol(); + if (!sds2) + { Expression *e; + + //printf("s = %s, '%s'\n", s->kind(), s->toChars()); + if (ti->withsym) + { + // Same as wthis.s + e = new VarExp(loc, ti->withsym->withstate->wthis); + e = new DotVarExp(loc, e, s->isDeclaration()); + } + else + e = new DsymbolExp(loc, s); + e = e->semantic(sc); + //printf("-1ScopeExp::semantic()\n"); + return e; + } + if (sds2 != sds) + { + sds = sds2; + goto Lagain; + } + //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); + } + if (global.errors) + return new ErrorExp(); + } + else + { + //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); + //printf("\tparent = '%s'\n", sds->parent->toChars()); + sds->semantic(sc); + + AggregateDeclaration *ad = sds->isAggregateDeclaration(); + if (ad) + return (new TypeExp(loc, ad->type))->semantic(sc); + } + type = Type::tvoid; + //printf("-2ScopeExp::semantic() %s\n", toChars()); + return this; +} + +void ScopeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (sds->isTemplateInstance()) + { + sds->toCBuffer(buf, hgs); + } + else if (hgs != NULL && hgs->ddoc) + { // fixes bug 6491 + Module *module = sds->isModule(); + if (module) + buf->writestring(module->md->toChars()); + else + buf->writestring(sds->toChars()); + } + else + { + buf->writestring(sds->kind()); + buf->writestring(" "); + buf->writestring(sds->toChars()); + } +} + +/********************** TemplateExp **************************************/ + +// Mainly just a placeholder + +TemplateExp::TemplateExp(Loc loc, TemplateDeclaration *td) + : Expression(loc, TOKtemplate, sizeof(TemplateExp)) +{ + //printf("TemplateExp(): %s\n", td->toChars()); + this->td = td; +} + +void TemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(td->toChars()); +} + +int TemplateExp::rvalue() +{ + error("template %s has no value", toChars()); + return 0; +} + +/********************** NewExp **************************************/ + +/* thisexp.new(newargs) newtype(arguments) */ + +NewExp::NewExp(Loc loc, Expression *thisexp, Expressions *newargs, + Type *newtype, Expressions *arguments) + : Expression(loc, TOKnew, sizeof(NewExp)) +{ + this->thisexp = thisexp; + this->newargs = newargs; + this->newtype = newtype; + this->arguments = arguments; + member = NULL; + allocator = NULL; + onstack = 0; +} + +Expression *NewExp::syntaxCopy() +{ + return new NewExp(loc, + thisexp ? thisexp->syntaxCopy() : NULL, + arraySyntaxCopy(newargs), + newtype->syntaxCopy(), arraySyntaxCopy(arguments)); +} + + +Expression *NewExp::semantic(Scope *sc) +{ + Type *tb; + ClassDeclaration *cdthis = NULL; + +#if LOGSEMANTIC + printf("NewExp::semantic() %s\n", toChars()); + if (thisexp) + printf("\tthisexp = %s\n", thisexp->toChars()); + printf("\tnewtype: %s\n", newtype->toChars()); +#endif + if (type) // if semantic() already run + return this; + +Lagain: + if (thisexp) + { thisexp = thisexp->semantic(sc); + cdthis = thisexp->type->isClassHandle(); + if (cdthis) + { + sc = sc->push(cdthis); + type = newtype->semantic(loc, sc); + sc = sc->pop(); + } + else + { + error("'this' for nested class must be a class type, not %s", thisexp->type->toChars()); + goto Lerr; + } + } + else + type = newtype->semantic(loc, sc); + newtype = type; // in case type gets cast to something else + tb = type->toBasetype(); + //printf("tb: %s, deco = %s\n", tb->toChars(), tb->deco); + + arrayExpressionSemantic(newargs, sc); + preFunctionParameters(loc, sc, newargs); + arrayExpressionSemantic(arguments, sc); + preFunctionParameters(loc, sc, arguments); + + if (thisexp && tb->ty != Tclass) + { error("e.new is only for allocating nested classes, not %s", tb->toChars()); + goto Lerr; + } + + if (tb->ty == Tclass) + { + TypeClass *tc = (TypeClass *)(tb); + ClassDeclaration *cd = tc->sym->isClassDeclaration(); + if (cd->isInterfaceDeclaration()) + { error("cannot create instance of interface %s", cd->toChars()); + goto Lerr; + } + else if (cd->isAbstract()) + { error("cannot create instance of abstract class %s", cd->toChars()); + for (size_t i = 0; i < cd->vtbl.dim; i++) + { FuncDeclaration *fd = cd->vtbl.tdata()[i]->isFuncDeclaration(); + if (fd && fd->isAbstract()) + error("function %s is abstract", fd->toChars()); + } + goto Lerr; + } + + if (cd->noDefaultCtor && (!arguments || !arguments->dim)) + { error("default construction is disabled for type %s", cd->toChars()); + goto Lerr; + } + checkDeprecated(sc, cd); + if (cd->isNested()) + { /* We need a 'this' pointer for the nested class. + * Ensure we have the right one. + */ + Dsymbol *s = cd->toParent2(); + ClassDeclaration *cdn = s->isClassDeclaration(); + FuncDeclaration *fdn = s->isFuncDeclaration(); + + //printf("cd isNested, cdn = %s\n", cdn ? cdn->toChars() : "null"); + if (cdn) + { + if (!cdthis) + { + // Supply an implicit 'this' and try again + thisexp = new ThisExp(loc); + for (Dsymbol *sp = sc->parent; 1; sp = sp->parent) + { if (!sp) + { + error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); + goto Lerr; + } + ClassDeclaration *cdp = sp->isClassDeclaration(); + if (!cdp) + continue; + if (cdp == cdn || cdn->isBaseOf(cdp, NULL)) + break; + // Add a '.outer' and try again + thisexp = new DotIdExp(loc, thisexp, Id::outer); + } + if (!global.errors) + goto Lagain; + } + if (cdthis) + { + //printf("cdthis = %s\n", cdthis->toChars()); + if (cdthis != cdn && !cdn->isBaseOf(cdthis, NULL)) + { error("'this' for nested class must be of type %s, not %s", cdn->toChars(), thisexp->type->toChars()); + goto Lerr; + } + } +#if 0 + else + { + for (Dsymbol *sf = sc->func; 1; sf= sf->toParent2()->isFuncDeclaration()) + { + if (!sf) + { + error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); + goto Lerr; + } + printf("sf = %s\n", sf->toChars()); + AggregateDeclaration *ad = sf->isThis(); + if (ad && (ad == cdn || cdn->isBaseOf(ad->isClassDeclaration(), NULL))) + break; + } + } +#endif + } +#if 1 + else if (thisexp) + { error("e.new is only for allocating nested classes"); + goto Lerr; + } + else if (fdn) + { + // make sure the parent context fdn of cd is reachable from sc + for (Dsymbol *sp = sc->parent; 1; sp = sp->parent) + { + if (fdn == sp) + break; + FuncDeclaration *fsp = sp ? sp->isFuncDeclaration() : NULL; + if (!sp || (fsp && fsp->isStatic())) + { + error("outer function context of %s is needed to 'new' nested class %s", fdn->toPrettyChars(), cd->toPrettyChars()); + goto Lerr; + } + } + } +#else + else if (fdn) + { /* The nested class cd is nested inside a function, + * we'll let getEthis() look for errors. + */ + //printf("nested class %s is nested inside function %s, we're in %s\n", cd->toChars(), fdn->toChars(), sc->func->toChars()); + if (thisexp) + { // Because thisexp cannot be a function frame pointer + error("e.new is only for allocating nested classes"); + goto Lerr; + } + } +#endif + else + assert(0); + } + else if (thisexp) + { error("e.new is only for allocating nested classes"); + goto Lerr; + } + + FuncDeclaration *f = NULL; + if (cd->ctor) + f = resolveFuncCall(sc, loc, cd->ctor, NULL, NULL, arguments, 0); + if (f) + { + checkDeprecated(sc, f); + member = f->isCtorDeclaration(); + assert(member); + + cd->accessCheck(loc, sc, member); + + TypeFunction *tf = (TypeFunction *)f->type; + + if (!arguments) + arguments = new Expressions(); + unsigned olderrors = global.errors; + functionParameters(loc, sc, tf, NULL, arguments, f); + if (olderrors != global.errors) + return new ErrorExp(); + type = type->addMod(tf->nextOf()->mod); + } + else + { + if (arguments && arguments->dim) + { error("no constructor for %s", cd->toChars()); + goto Lerr; + } + } + + if (cd->aggNew) + { + // Prepend the size argument to newargs[] + Expression *e = new IntegerExp(loc, cd->size(loc), Type::tsize_t); + if (!newargs) + newargs = new Expressions(); + newargs->shift(e); + + f = cd->aggNew->overloadResolve(loc, NULL, newargs); + allocator = f->isNewDeclaration(); + assert(allocator); + + TypeFunction *tf = (TypeFunction *)f->type; + unsigned olderrors = global.errors; + functionParameters(loc, sc, tf, NULL, newargs, f); + if (olderrors != global.errors) + return new ErrorExp(); + + } + else + { + if (newargs && newargs->dim) + { error("no allocator for %s", cd->toChars()); + goto Lerr; + } + } + } + else if (tb->ty == Tstruct) + { + TypeStruct *ts = (TypeStruct *)tb; + StructDeclaration *sd = ts->sym; + TypeFunction *tf; + + if (sd->noDefaultCtor && (!arguments || !arguments->dim)) + { error("default construction is disabled for type %s", sd->toChars()); + goto Lerr; + } + FuncDeclaration *f = NULL; + if (sd->ctor) + f = resolveFuncCall(sc, loc, sd->ctor, NULL, NULL, arguments, 0); + if (f) + { + checkDeprecated(sc, f); + member = f->isCtorDeclaration(); + assert(member); + + sd->accessCheck(loc, sc, member); + + tf = (TypeFunction *)f->type; + type = tf->next; + + if (!arguments) + arguments = new Expressions(); + unsigned olderrors = global.errors; + functionParameters(loc, sc, tf, NULL, arguments, f); + if (olderrors != global.errors) + return new ErrorExp(); + + } + else + { + if (arguments && arguments->dim) + { error("no constructor for %s", sd->toChars()); + goto Lerr; + } + } + + + if (sd->aggNew) + { + // Prepend the uint size argument to newargs[] + Expression *e = new IntegerExp(loc, sd->size(loc), Type::tuns32); + if (!newargs) + newargs = new Expressions(); + newargs->shift(e); + + f = sd->aggNew->overloadResolve(loc, NULL, newargs); + allocator = f->isNewDeclaration(); + assert(allocator); + + tf = (TypeFunction *)f->type; + unsigned olderrors = global.errors; + functionParameters(loc, sc, tf, NULL, newargs, f); + if (olderrors != global.errors) + return new ErrorExp(); + +#if 0 + e = new VarExp(loc, f); + e = new CallExp(loc, e, newargs); + e = e->semantic(sc); + e->type = type->pointerTo(); + return e; +#endif + } + else + { + if (newargs && newargs->dim) + { error("no allocator for %s", sd->toChars()); + goto Lerr; + } + } + + type = type->pointerTo(); + } + else if (tb->ty == Tarray && (arguments && arguments->dim)) + { + for (size_t i = 0; i < arguments->dim; i++) + { + if (tb->ty != Tarray) + { error("too many arguments for array"); + goto Lerr; + } + + Expression *arg = arguments->tdata()[i]; + arg = resolveProperties(sc, arg); + arg = arg->implicitCastTo(sc, Type::tsize_t); + arg = arg->optimize(WANTvalue); + if (arg->op == TOKint64 && (sinteger_t)arg->toInteger() < 0) + { error("negative array index %s", arg->toChars()); + goto Lerr; + } + arguments->tdata()[i] = arg; + tb = ((TypeDArray *)tb)->next->toBasetype(); + } + } + else if (tb->isscalar()) + { + if (arguments && arguments->dim) + { error("no constructor for %s", type->toChars()); + goto Lerr; + } + + type = type->pointerTo(); + } + else + { + error("new can only create structs, dynamic arrays or class objects, not %s's", type->toChars()); + goto Lerr; + } + +//printf("NewExp: '%s'\n", toChars()); +//printf("NewExp:type '%s'\n", type->toChars()); + + return this; + +Lerr: + return new ErrorExp(); +} + + +void NewExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (thisexp) + { expToCBuffer(buf, hgs, thisexp, PREC_primary); + buf->writeByte('.'); + } + buf->writestring("new "); + if (newargs && newargs->dim) + { + buf->writeByte('('); + argsToCBuffer(buf, newargs, hgs); + buf->writeByte(')'); + } + newtype->toCBuffer(buf, NULL, hgs); + if (arguments && arguments->dim) + { + buf->writeByte('('); + argsToCBuffer(buf, arguments, hgs); + buf->writeByte(')'); + } +} + +/********************** NewAnonClassExp **************************************/ + +NewAnonClassExp::NewAnonClassExp(Loc loc, Expression *thisexp, + Expressions *newargs, ClassDeclaration *cd, Expressions *arguments) + : Expression(loc, TOKnewanonclass, sizeof(NewAnonClassExp)) +{ + this->thisexp = thisexp; + this->newargs = newargs; + this->cd = cd; + this->arguments = arguments; +} + +Expression *NewAnonClassExp::syntaxCopy() +{ + return new NewAnonClassExp(loc, + thisexp ? thisexp->syntaxCopy() : NULL, + arraySyntaxCopy(newargs), + (ClassDeclaration *)cd->syntaxCopy(NULL), + arraySyntaxCopy(arguments)); +} + + +Expression *NewAnonClassExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("NewAnonClassExp::semantic() %s\n", toChars()); + //printf("thisexp = %p\n", thisexp); + //printf("type: %s\n", type->toChars()); +#endif + + Expression *d = new DeclarationExp(loc, cd); + d = d->semantic(sc); + + Expression *n = new NewExp(loc, thisexp, newargs, cd->type, arguments); + + Expression *c = new CommaExp(loc, d, n); + return c->semantic(sc); +} + + +void NewAnonClassExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (thisexp) + { expToCBuffer(buf, hgs, thisexp, PREC_primary); + buf->writeByte('.'); + } + buf->writestring("new"); + if (newargs && newargs->dim) + { + buf->writeByte('('); + argsToCBuffer(buf, newargs, hgs); + buf->writeByte(')'); + } + buf->writestring(" class "); + if (arguments && arguments->dim) + { + buf->writeByte('('); + argsToCBuffer(buf, arguments, hgs); + buf->writeByte(')'); + } + //buf->writestring(" { }"); + if (cd) + { + cd->toCBuffer(buf, hgs); + } +} + +/********************** SymbolExp **************************************/ + +#if DMDV2 +SymbolExp::SymbolExp(Loc loc, enum TOK op, int size, Declaration *var, int hasOverloads) + : Expression(loc, op, size) +{ + assert(var); + this->var = var; + this->hasOverloads = hasOverloads; +} +#endif + +/********************** SymOffExp **************************************/ + +SymOffExp::SymOffExp(Loc loc, Declaration *var, unsigned offset, int hasOverloads) + : SymbolExp(loc, TOKsymoff, sizeof(SymOffExp), var, hasOverloads) +{ + this->offset = offset; + VarDeclaration *v = var->isVarDeclaration(); + if (v && v->needThis()) + error("need 'this' for address of %s", v->toChars()); +} + +Expression *SymOffExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("SymOffExp::semantic('%s')\n", toChars()); +#endif + //var->semantic(sc); + if (!type) + type = var->type->pointerTo(); + VarDeclaration *v = var->isVarDeclaration(); + if (v) + v->checkNestedReference(sc, loc); + FuncDeclaration *f = var->isFuncDeclaration(); + if (f) + f->checkNestedReference(sc, loc); + return this; +} + +int SymOffExp::isBool(int result) +{ + return result ? TRUE : FALSE; +} + +void SymOffExp::checkEscape() +{ + VarDeclaration *v = var->isVarDeclaration(); + if (v) + { + if (!v->isDataseg() && !(v->storage_class & (STCref | STCout))) + { /* BUG: This should be allowed: + * void foo() + * { int a; + * int* bar() { return &a; } + * } + */ + error("escaping reference to local %s", v->toChars()); + } + } +} + +void SymOffExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (offset) + buf->printf("(& %s+%u)", var->toChars(), offset); + else + buf->printf("& %s", var->toChars()); +} + +/******************************** VarExp **************************/ + +VarExp::VarExp(Loc loc, Declaration *var, int hasOverloads) + : SymbolExp(loc, TOKvar, sizeof(VarExp), var, hasOverloads) +{ + //printf("VarExp(this = %p, '%s', loc = %s)\n", this, var->toChars(), loc.toChars()); + //if (strcmp(var->ident->toChars(), "func") == 0) halt(); + this->type = var->type; +} + +int VarExp::equals(Object *o) +{ VarExp *ne; + + if (this == o || + (((Expression *)o)->op == TOKvar && + ((ne = (VarExp *)o), type->toHeadMutable()->equals(ne->type->toHeadMutable())) && + var == ne->var)) + return 1; + return 0; +} + +Expression *VarExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("VarExp::semantic(%s)\n", toChars()); +#endif +// if (var->sem == SemanticStart && var->scope) // if forward referenced +// var->semantic(sc); + if (!type) + { type = var->type; +#if 0 + if (var->storage_class & STClazy) + { + TypeFunction *tf = new TypeFunction(NULL, type, 0, LINKd); + type = new TypeDelegate(tf); + type = type->semantic(loc, sc); + } +#endif + } + + if (type && !type->deco) + type = type->semantic(loc, sc); + + /* Fix for 1161 doesn't work because it causes protection + * problems when instantiating imported templates passing private + * variables as alias template parameters. + */ + //accessCheck(loc, sc, NULL, var); + + VarDeclaration *v = var->isVarDeclaration(); + if (v) + { + v->checkNestedReference(sc, loc); +#if DMDV2 + checkPurity(sc, v, NULL); +#endif + } + FuncDeclaration *f = var->isFuncDeclaration(); + if (f) + f->checkNestedReference(sc, loc); +#if 0 + else if ((fd = var->isFuncLiteralDeclaration()) != NULL) + { Expression *e; + e = new FuncExp(loc, fd); + e->type = type; + return e; + } +#endif + + return this; +} + +char *VarExp::toChars() +{ + return var->toChars(); +} + +void VarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(var->toChars()); +} + +void VarExp::checkEscape() +{ + VarDeclaration *v = var->isVarDeclaration(); + if (v) + { Type *tb = v->type->toBasetype(); + // if reference type + if (tb->ty == Tarray || tb->ty == Tsarray || tb->ty == Tclass || tb->ty == Tdelegate) + { + if (v->isScope() && (!v->noscope || tb->ty == Tclass)) + error("escaping reference to scope local %s", v->toChars()); + else if (v->storage_class & STCvariadic) + error("escaping reference to variadic parameter %s", v->toChars()); + } + } +} + +void VarExp::checkEscapeRef() +{ + VarDeclaration *v = var->isVarDeclaration(); + if (v) + { + if (!v->isDataseg() && !(v->storage_class & (STCref | STCout))) + error("escaping reference to local variable %s", v->toChars()); + } +} + +#if DMDV2 +int VarExp::isLvalue() +{ + if (var->storage_class & STClazy) + return 0; + return 1; +} +#endif + +Expression *VarExp::toLvalue(Scope *sc, Expression *e) +{ +#if 0 + tym = tybasic(e1->ET->Tty); + if (!(tyscalar(tym) || + tym == TYstruct || + tym == TYarray && e->Eoper == TOKaddr)) + synerr(EM_lvalue); // lvalue expected +#endif + if (var->storage_class & STClazy) + { error("lazy variables cannot be lvalues"); + return new ErrorExp(); + } + return this; +} + +Expression *VarExp::modifiableLvalue(Scope *sc, Expression *e) +{ + //printf("VarExp::modifiableLvalue('%s')\n", var->toChars()); + //if (type && type->toBasetype()->ty == Tsarray) + //error("cannot change reference to static array '%s'", var->toChars()); + + var->checkModify(loc, sc, type); + + // See if this expression is a modifiable lvalue (i.e. not const) + return toLvalue(sc, e); +} + + +/******************************** OverExp **************************/ + +#if DMDV2 +OverExp::OverExp(OverloadSet *s) + : Expression(loc, TOKoverloadset, sizeof(OverExp)) +{ + //printf("OverExp(this = %p, '%s')\n", this, var->toChars()); + vars = s; + type = Type::tvoid; +} + +int OverExp::isLvalue() +{ + return 1; +} + +Expression *OverExp::toLvalue(Scope *sc, Expression *e) +{ + return this; +} +#endif + + +/******************************** TupleExp **************************/ + +TupleExp::TupleExp(Loc loc, Expressions *exps) + : Expression(loc, TOKtuple, sizeof(TupleExp)) +{ + //printf("TupleExp(this = %p)\n", this); + this->exps = exps; + this->type = NULL; +} + + +TupleExp::TupleExp(Loc loc, TupleDeclaration *tup) + : Expression(loc, TOKtuple, sizeof(TupleExp)) +{ + exps = new Expressions(); + type = NULL; + + exps->reserve(tup->objects->dim); + for (size_t i = 0; i < tup->objects->dim; i++) + { Object *o = tup->objects->tdata()[i]; + if (o->dyncast() == DYNCAST_EXPRESSION) + { + Expression *e = (Expression *)o; + if (e->op == TOKdsymbol) + e = e->syntaxCopy(); + exps->push(e); + } + else if (o->dyncast() == DYNCAST_DSYMBOL) + { + Dsymbol *s = (Dsymbol *)o; + Expression *e = new DsymbolExp(loc, s); + exps->push(e); + } + else if (o->dyncast() == DYNCAST_TYPE) + { + Type *t = (Type *)o; + Expression *e = new TypeExp(loc, t); + exps->push(e); + } + else + { + error("%s is not an expression", o->toChars()); + } + } +} + +int TupleExp::equals(Object *o) +{ + if (this == o) + return 1; + if (((Expression *)o)->op == TOKtuple) + { + TupleExp *te = (TupleExp *)o; + if (exps->dim != te->exps->dim) + return 0; + for (size_t i = 0; i < exps->dim; i++) + { Expression *e1 = (*exps)[i]; + Expression *e2 = (*te->exps)[i]; + + if (!e1->equals(e2)) + return 0; + } + return 1; + } + return 0; +} + +Expression *TupleExp::syntaxCopy() +{ + return new TupleExp(loc, arraySyntaxCopy(exps)); +} + +Expression *TupleExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("+TupleExp::semantic(%s)\n", toChars()); +#endif + if (type) + return this; + + // Run semantic() on each argument + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + + e = e->semantic(sc); + if (!e->type) + { error("%s has no value", e->toChars()); + return new ErrorExp(); + } + (*exps)[i] = e; + } + + expandTuples(exps); + type = new TypeTuple(exps); + type = type->semantic(loc, sc); + //printf("-TupleExp::semantic(%s)\n", toChars()); + return this; +} + +void TupleExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("tuple("); + argsToCBuffer(buf, exps, hgs); + buf->writeByte(')'); +} + + +void TupleExp::checkEscape() +{ + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*exps)[i]; + e->checkEscape(); + } +} + +/******************************** FuncExp *********************************/ + +FuncExp::FuncExp(Loc loc, FuncLiteralDeclaration *fd, TemplateDeclaration *td) + : Expression(loc, TOKfunction, sizeof(FuncExp)) +{ + this->fd = fd; + this->td = td; + tok = fd->tok; // save original kind of function/delegate/(infer) + tded = NULL; + scope = NULL; +} + +Expression *FuncExp::syntaxCopy() +{ + return new FuncExp(loc, (FuncLiteralDeclaration *)fd->syntaxCopy(NULL)); +} + +Expression *FuncExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("FuncExp::semantic(%s)\n", toChars()); +#endif + if (!type || type == Type::tvoid) + { + // save for later use + scope = sc; + + //printf("td = %p, tded = %p\n", td, tded); + if (td) + { + assert(td->parameters && td->parameters->dim); + td->semantic(sc); + + if (!tded) + { // defer type determination + type = Type::tvoid; // temporary type + return this; + } + else + { + Expression *e = inferType(sc, tded); + if (e) + { e = e->castTo(sc, tded); + e = e->semantic(sc); + } + if (!e) + { error("cannot infer function literal type"); + e = new ErrorExp(); + } + return e; + } + } + + unsigned olderrors = global.errors; + fd->semantic(sc); + //fd->parent = sc->parent; + if (olderrors != global.errors) + { + } + else + { + fd->semantic2(sc); + if ( (olderrors == global.errors) || + // need to infer return type + (fd->type && fd->type->ty == Tfunction && !fd->type->nextOf())) + { + fd->semantic3(sc); + + if ( (olderrors == global.errors) && global.params.useInline) + fd->inlineScan(); + } + } + + // need to infer return type + if ((olderrors != global.errors) && fd->type && fd->type->ty == Tfunction && !fd->type->nextOf()) + ((TypeFunction *)fd->type)->next = Type::terror; + + // Type is a "delegate to" or "pointer to" the function literal + if ((fd->isNested() && fd->tok == TOKdelegate) || + (tok == TOKreserved && tded && tded->ty == Tdelegate)) + { + type = new TypeDelegate(fd->type); + type = type->semantic(loc, sc); + } + else + { + type = fd->type->pointerTo(); + } + fd->tookAddressOf++; + } + return this; +} + +// used from CallExp::semantic() +Expression *FuncExp::semantic(Scope *sc, Expressions *arguments) +{ + assert(!tded); + assert(!scope); + + if ((!type || type == Type::tvoid) && td && arguments && arguments->dim) + { + for (size_t k = 0; k < arguments->dim; k++) + { Expression *checkarg = arguments->tdata()[k]; + if (checkarg->op == TOKerror) + return checkarg; + } + + assert(td->parameters && td->parameters->dim); + td->semantic(sc); + + TypeFunction *tfl = (TypeFunction *)fd->type; + size_t dim = Parameter::dim(tfl->parameters); + + if ((!tfl->varargs && arguments->dim == dim) || + ( tfl->varargs && arguments->dim >= dim)) + { + Objects *tiargs = new Objects(); + tiargs->reserve(td->parameters->dim); + + for (size_t i = 0; i < td->parameters->dim; i++) + { + TemplateParameter *tp = (*td->parameters)[i]; + for (size_t u = 0; u < dim; u++) + { Parameter *p = Parameter::getNth(tfl->parameters, u); + if (p->type->ty == Tident && + ((TypeIdentifier *)p->type)->ident == tp->ident) + { Expression *e = (*arguments)[u]; + tiargs->push(e->type); + u = dim; // break inner loop + } + } + } + + TemplateInstance *ti = new TemplateInstance(loc, td, tiargs); + return (new ScopeExp(loc, ti))->semantic(sc); + } + error("cannot infer function literal type"); + return new ErrorExp(); + } + return semantic(sc); +} + +Expression *FuncExp::inferType(Scope *sc, Type *to) +{ + //printf("inferType sc = %p, to = %s\n", sc, to->toChars()); + if (!sc) + { // used from TypeFunction::callMatch() + assert(scope); + sc = scope; + } + + Expression *e = NULL; + if (td) + { /// Parameter types inference from + assert(!type || type == Type::tvoid); + Type *t = to; + if (t->ty == Tdelegate || + t->ty == Tpointer && t->nextOf()->ty == Tfunction) + { t = t->nextOf(); + } + if (t->ty == Tfunction) + { + TypeFunction *tfv = (TypeFunction *)t; + TypeFunction *tfl = (TypeFunction *)fd->type; + size_t dim = Parameter::dim(tfl->parameters); + + if (Parameter::dim(tfv->parameters) == dim && + tfv->varargs == tfl->varargs) + { + Objects *tiargs = new Objects(); + tiargs->reserve(td->parameters->dim); + + for (size_t i = 0; i < td->parameters->dim; i++) + { + TemplateParameter *tp = (*td->parameters)[i]; + for (size_t u = 0; u < dim; u++) + { Parameter *p = Parameter::getNth(tfl->parameters, u); + if (p->type->ty == Tident && + ((TypeIdentifier *)p->type)->ident == tp->ident) + { p = Parameter::getNth(tfv->parameters, u); + if (p->type->ty == Tident) + return NULL; + tiargs->push(p->type); + u = dim; // break inner loop + } + } + } + + TemplateInstance *ti = new TemplateInstance(loc, td, tiargs); + e = (new ScopeExp(loc, ti))->semantic(sc); + } + } + } + else + { + assert(type && type != Type::tvoid); // semantic is already done + e = this; + } + + if (e) + { // Check implicit function to delegate conversion + if (e->implicitConvTo(to)) + e = e->castTo(sc, to); + else + e = NULL; + } + return e; +} + +void FuncExp::setType(Type *t) +{ + assert(t); + + if (t->ty == Tdelegate || + t->ty == Tpointer && t->nextOf()->ty == Tfunction) + { tded = t; + } +} + +char *FuncExp::toChars() +{ + return fd->toChars(); +} + +void FuncExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + fd->toCBuffer(buf, hgs); + //buf->writestring(fd->toChars()); +} + + +/******************************** DeclarationExp **************************/ + +DeclarationExp::DeclarationExp(Loc loc, Dsymbol *declaration) + : Expression(loc, TOKdeclaration, sizeof(DeclarationExp)) +{ + this->declaration = declaration; +} + +Expression *DeclarationExp::syntaxCopy() +{ + return new DeclarationExp(loc, declaration->syntaxCopy(NULL)); +} + +Expression *DeclarationExp::semantic(Scope *sc) +{ + if (type) + return this; + +#if LOGSEMANTIC + printf("DeclarationExp::semantic() %s\n", toChars()); +#endif + + unsigned olderrors = global.errors; + + /* This is here to support extern(linkage) declaration, + * where the extern(linkage) winds up being an AttribDeclaration + * wrapper. + */ + Dsymbol *s = declaration; + + AttribDeclaration *ad = declaration->isAttribDeclaration(); + if (ad) + { + if (ad->decl && ad->decl->dim == 1) + s = ad->decl->tdata()[0]; + } + + if (s->isVarDeclaration()) + { // Do semantic() on initializer first, so: + // int a = a; + // will be illegal. + declaration->semantic(sc); + s->parent = sc->parent; + } + + //printf("inserting '%s' %p into sc = %p\n", s->toChars(), s, sc); + // Insert into both local scope and function scope. + // Must be unique in both. + if (s->ident) + { + if (!sc->insert(s)) + { error("declaration %s is already defined", s->toPrettyChars()); + return new ErrorExp(); + } + else if (sc->func) + { VarDeclaration *v = s->isVarDeclaration(); + if ( (s->isFuncDeclaration() || s->isTypedefDeclaration() || + s->isAggregateDeclaration() || s->isEnumDeclaration() || + s->isInterfaceDeclaration()) && + !sc->func->localsymtab->insert(s)) + { + error("declaration %s is already defined in another scope in %s", + s->toPrettyChars(), sc->func->toChars()); + return new ErrorExp(); + } + else if (!global.params.useDeprecated) + { // Disallow shadowing + + for (Scope *scx = sc->enclosing; scx && scx->func == sc->func; scx = scx->enclosing) + { Dsymbol *s2; + + if (scx->scopesym && scx->scopesym->symtab && + (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL && + s != s2) + { + error("shadowing declaration %s is deprecated", s->toPrettyChars()); + return new ErrorExp(); + } + } + } + } + } + if (!s->isVarDeclaration()) + { + Scope *sc2 = sc; + if (sc2->stc & (STCpure | STCnothrow)) + sc2 = sc->push(); + sc2->stc &= ~(STCpure | STCnothrow); + declaration->semantic(sc2); + if (sc2 != sc) + sc2->pop(); + s->parent = sc->parent; + } + if (global.errors == olderrors) + { + declaration->semantic2(sc); + if (global.errors == olderrors) + { + declaration->semantic3(sc); + + if ((global.errors == olderrors) && global.params.useInline) + declaration->inlineScan(); + } + } + + type = Type::tvoid; + return this; +} + + +void DeclarationExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + declaration->toCBuffer(buf, hgs); +} + + +/************************ TypeidExp ************************************/ + +/* + * typeid(int) + */ + +TypeidExp::TypeidExp(Loc loc, Object *o) + : Expression(loc, TOKtypeid, sizeof(TypeidExp)) +{ + this->obj = o; +} + + +Expression *TypeidExp::syntaxCopy() +{ + return new TypeidExp(loc, objectSyntaxCopy(obj)); +} + + +Expression *TypeidExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("TypeidExp::semantic() %s\n", toChars()); +#endif + Type *ta = isType(obj); + Expression *ea = isExpression(obj); + Dsymbol *sa = isDsymbol(obj); + + //printf("ta %p ea %p sa %p\n", ta, ea, sa); + + if (ta) + { + ta->resolve(loc, sc, &ea, &ta, &sa); + } + + if (ea) + { + ea = ea->semantic(sc); + ea = resolveProperties(sc, ea); + ta = ea->type; + if (ea->op == TOKtype) + ea = NULL; + } + + if (!ta) + { + //printf("ta %p ea %p sa %p\n", ta, ea, sa); + error("no type for typeid(%s)", ea ? ea->toChars() : (sa ? sa->toChars() : "")); + return new ErrorExp(); + } + + if (ea && ta->toBasetype()->ty == Tclass) + { /* Get the dynamic type, which is .classinfo + */ + e = new DotIdExp(ea->loc, ea, Id::classinfo); + e = e->semantic(sc); + } + else + { /* Get the static type + */ + e = ta->getTypeInfo(sc); + if (e->loc.linnum == 0) + e->loc = loc; // so there's at least some line number info + if (ea) + { + e = new CommaExp(loc, ea, e); // execute ea + e = e->semantic(sc); + } + } + return e; +} + +void TypeidExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("typeid("); + ObjectToCBuffer(buf, hgs, obj); + buf->writeByte(')'); +} + +/************************ TraitsExp ************************************/ +#if DMDV2 +/* + * __traits(identifier, args...) + */ + +TraitsExp::TraitsExp(Loc loc, Identifier *ident, Objects *args) + : Expression(loc, TOKtraits, sizeof(TraitsExp)) +{ + this->ident = ident; + this->args = args; +} + + +Expression *TraitsExp::syntaxCopy() +{ + return new TraitsExp(loc, ident, TemplateInstance::arraySyntaxCopy(args)); +} + + +void TraitsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("__traits("); + buf->writestring(ident->toChars()); + if (args) + { + for (size_t i = 0; i < args->dim; i++) + { + buf->writeByte(','); + Object *oarg = args->tdata()[i]; + ObjectToCBuffer(buf, hgs, oarg); + } + } + buf->writeByte(')'); +} +#endif + +/************************************************************/ + +HaltExp::HaltExp(Loc loc) + : Expression(loc, TOKhalt, sizeof(HaltExp)) +{ +} + +Expression *HaltExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("HaltExp::semantic()\n"); +#endif + type = Type::tvoid; + return this; +} + + +void HaltExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("halt"); +} + +/************************************************************/ + +IsExp::IsExp(Loc loc, Type *targ, Identifier *id, enum TOK tok, + Type *tspec, enum TOK tok2, TemplateParameters *parameters) + : Expression(loc, TOKis, sizeof(IsExp)) +{ + this->targ = targ; + this->id = id; + this->tok = tok; + this->tspec = tspec; + this->tok2 = tok2; + this->parameters = parameters; +} + +Expression *IsExp::syntaxCopy() +{ + // This section is identical to that in TemplateDeclaration::syntaxCopy() + TemplateParameters *p = NULL; + if (parameters) + { + p = new TemplateParameters(); + p->setDim(parameters->dim); + for (size_t i = 0; i < p->dim; i++) + { TemplateParameter *tp = parameters->tdata()[i]; + p->tdata()[i] = tp->syntaxCopy(); + } + } + + return new IsExp(loc, + targ->syntaxCopy(), + id, + tok, + tspec ? tspec->syntaxCopy() : NULL, + tok2, + p); +} + +Expression *IsExp::semantic(Scope *sc) +{ Type *tded; + + /* is(targ id tok tspec) + * is(targ id : tok2) + * is(targ id == tok2) + */ + + //printf("IsExp::semantic(%s)\n", toChars()); + if (id && !(sc->flags & (SCOPEstaticif | SCOPEstaticassert))) + { error("can only declare type aliases within static if conditionals or static asserts"); + return new ErrorExp(); + } + + Type *t = targ->trySemantic(loc, sc); + if (!t) + goto Lno; // errors, so condition is false + targ = t; + if (tok2 != TOKreserved) + { + switch (tok2) + { + case TOKtypedef: + if (targ->ty != Ttypedef) + goto Lno; + tded = ((TypeTypedef *)targ)->sym->basetype; + break; + + case TOKstruct: + if (targ->ty != Tstruct) + goto Lno; + if (((TypeStruct *)targ)->sym->isUnionDeclaration()) + goto Lno; + tded = targ; + break; + + case TOKunion: + if (targ->ty != Tstruct) + goto Lno; + if (!((TypeStruct *)targ)->sym->isUnionDeclaration()) + goto Lno; + tded = targ; + break; + + case TOKclass: + if (targ->ty != Tclass) + goto Lno; + if (((TypeClass *)targ)->sym->isInterfaceDeclaration()) + goto Lno; + tded = targ; + break; + + case TOKinterface: + if (targ->ty != Tclass) + goto Lno; + if (!((TypeClass *)targ)->sym->isInterfaceDeclaration()) + goto Lno; + tded = targ; + break; +#if DMDV2 + case TOKconst: + if (!targ->isConst()) + goto Lno; + tded = targ; + break; + + case TOKinvariant: + if (!global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + case TOKimmutable: + if (!targ->isImmutable()) + goto Lno; + tded = targ; + break; + + case TOKshared: + if (!targ->isShared()) + goto Lno; + tded = targ; + break; + + case TOKwild: + if (!targ->isWild()) + goto Lno; + tded = targ; + break; +#endif + + case TOKsuper: + // If class or interface, get the base class and interfaces + if (targ->ty != Tclass) + goto Lno; + else + { ClassDeclaration *cd = ((TypeClass *)targ)->sym; + Parameters *args = new Parameters; + args->reserve(cd->baseclasses->dim); + for (size_t i = 0; i < cd->baseclasses->dim; i++) + { BaseClass *b = cd->baseclasses->tdata()[i]; + args->push(new Parameter(STCin, b->type, NULL, NULL)); + } + tded = new TypeTuple(args); + } + break; + + case TOKenum: + if (targ->ty != Tenum) + goto Lno; + tded = ((TypeEnum *)targ)->sym->memtype; + break; + + case TOKdelegate: + if (targ->ty != Tdelegate) + goto Lno; + tded = ((TypeDelegate *)targ)->next; // the underlying function type + break; + + case TOKfunction: + { + if (targ->ty != Tfunction) + goto Lno; + tded = targ; + + /* Generate tuple from function parameter types. + */ + assert(tded->ty == Tfunction); + Parameters *params = ((TypeFunction *)tded)->parameters; + size_t dim = Parameter::dim(params); + Parameters *args = new Parameters; + args->reserve(dim); + for (size_t i = 0; i < dim; i++) + { Parameter *arg = Parameter::getNth(params, i); + assert(arg && arg->type); + args->push(new Parameter(arg->storageClass, arg->type, NULL, NULL)); + } + tded = new TypeTuple(args); + break; + } + case TOKreturn: + /* Get the 'return type' for the function, + * delegate, or pointer to function. + */ + if (targ->ty == Tfunction) + tded = ((TypeFunction *)targ)->next; + else if (targ->ty == Tdelegate) + { tded = ((TypeDelegate *)targ)->next; + tded = ((TypeFunction *)tded)->next; + } + else if (targ->ty == Tpointer && + ((TypePointer *)targ)->next->ty == Tfunction) + { tded = ((TypePointer *)targ)->next; + tded = ((TypeFunction *)tded)->next; + } + else + goto Lno; + break; + + case TOKargTypes: + /* Generate a type tuple of the equivalent types used to determine if a + * function argument of this type can be passed in registers. + * The results of this are highly platform dependent, and intended + * primarly for use in implementing va_arg(). + */ + tded = targ->toArgTypes(); + if (!tded) + goto Lno; // not valid for a parameter + break; + + default: + assert(0); + } + goto Lyes; + } + else if (id && tspec) + { + /* Evaluate to TRUE if targ matches tspec. + * If TRUE, declare id as an alias for the specialized type. + */ + + assert(parameters && parameters->dim); + + Objects dedtypes; + dedtypes.setDim(parameters->dim); + dedtypes.zero(); + + MATCH m = targ->deduceType(sc, tspec, parameters, &dedtypes); +//printf("targ: %s\n", targ->toChars()); +//printf("tspec: %s\n", tspec->toChars()); + if (m == MATCHnomatch || + (m != MATCHexact && tok == TOKequal)) + { + goto Lno; + } + else + { + tded = (Type *)dedtypes.tdata()[0]; + if (!tded) + tded = targ; +#if DMDV2 + Objects tiargs; + tiargs.setDim(1); + tiargs.tdata()[0] = targ; + + /* Declare trailing parameters + */ + for (size_t i = 1; i < parameters->dim; i++) + { TemplateParameter *tp = (*parameters)[i]; + Declaration *s = NULL; + + m = tp->matchArg(sc, &tiargs, i, parameters, &dedtypes, &s); + if (m == MATCHnomatch) + goto Lno; + s->semantic(sc); + if (sc->sd) + s->addMember(sc, sc->sd, 1); + else if (!sc->insert(s)) + error("declaration %s is already defined", s->toChars()); + } +#endif + goto Lyes; + } + } + else if (id) + { + /* Declare id as an alias for type targ. Evaluate to TRUE + */ + tded = targ; + goto Lyes; + } + else if (tspec) + { + /* Evaluate to TRUE if targ matches tspec + * is(targ == tspec) + * is(targ : tspec) + */ + tspec = tspec->semantic(loc, sc); + //printf("targ = %s, %s\n", targ->toChars(), targ->deco); + //printf("tspec = %s, %s\n", tspec->toChars(), tspec->deco); + if (tok == TOKcolon) + { if (targ->implicitConvTo(tspec)) + goto Lyes; + else + goto Lno; + } + else /* == */ + { if (targ->equals(tspec)) + goto Lyes; + else + goto Lno; + } + } + +Lyes: + if (id) + { + Dsymbol *s; + Tuple *tup = isTuple(tded); + if (tup) + s = new TupleDeclaration(loc, id, &(tup->objects)); + else + s = new AliasDeclaration(loc, id, tded); + s->semantic(sc); + /* The reason for the !tup is unclear. It fails Phobos unittests if it is not there. + * More investigation is needed. + */ + if (!tup && !sc->insert(s)) + error("declaration %s is already defined", s->toChars()); + if (sc->sd) + s->addMember(sc, sc->sd, 1); + } + //printf("Lyes\n"); + return new IntegerExp(loc, 1, Type::tbool); + +Lno: + //printf("Lno\n"); + return new IntegerExp(loc, 0, Type::tbool); +} + +void IsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("is("); + targ->toCBuffer(buf, id, hgs); + if (tok2 != TOKreserved) + { + buf->printf(" %s %s", Token::toChars(tok), Token::toChars(tok2)); + } + else if (tspec) + { + if (tok == TOKcolon) + buf->writestring(" : "); + else + buf->writestring(" == "); + tspec->toCBuffer(buf, NULL, hgs); + } +#if DMDV2 + if (parameters) + { // First parameter is already output, so start with second + for (size_t i = 1; i < parameters->dim; i++) + { + buf->writeByte(','); + TemplateParameter *tp = parameters->tdata()[i]; + tp->toCBuffer(buf, hgs); + } + } +#endif + buf->writeByte(')'); +} + + +/************************************************************/ + +UnaExp::UnaExp(Loc loc, enum TOK op, int size, Expression *e1) + : Expression(loc, op, size) +{ + this->e1 = e1; +} + +Expression *UnaExp::syntaxCopy() +{ + UnaExp *e = (UnaExp *)copy(); + e->type = NULL; + e->e1 = e->e1->syntaxCopy(); + return e; +} + +Expression *UnaExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("UnaExp::semantic('%s')\n", toChars()); +#endif + e1 = e1->semantic(sc); +// if (!e1->type) +// error("%s has no value", e1->toChars()); + return this; +} + +Expression *UnaExp::resolveLoc(Loc loc, Scope *sc) +{ + e1 = e1->resolveLoc(loc, sc); + return this; +} + +void UnaExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(op)); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + +/************************************************************/ + +BinExp::BinExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2) + : Expression(loc, op, size) +{ + this->e1 = e1; + this->e2 = e2; +} + +Expression *BinExp::syntaxCopy() +{ + BinExp *e = (BinExp *)copy(); + e->type = NULL; + e->e1 = e->e1->syntaxCopy(); + e->e2 = e->e2->syntaxCopy(); + return e; +} + +Expression *BinExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("BinExp::semantic('%s')\n", toChars()); +#endif + e1 = e1->semantic(sc); + e2 = e2->semantic(sc); + if (e1->op == TOKerror || e2->op == TOKerror) + return new ErrorExp(); + return this; +} + +Expression *BinExp::semanticp(Scope *sc) +{ + BinExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e2 = resolveProperties(sc, e2); + return this; +} + + +// generate an error if this is a nonsensical *=,/=, or %=, eg real *= imaginary +void BinExp::checkComplexMulAssign() +{ + // Any multiplication by an imaginary or complex number yields a complex result. + // r *= c, i*=c, r*=i, i*=i are all forbidden operations. + const char *opstr = Token::toChars(op); + if ( e1->type->isreal() && e2->type->iscomplex()) + { + error("%s %s %s is undefined. Did you mean %s %s %s.re ?", + e1->type->toChars(), opstr, e2->type->toChars(), + e1->type->toChars(), opstr, e2->type->toChars()); + } + else if (e1->type->isimaginary() && e2->type->iscomplex()) + { + error("%s %s %s is undefined. Did you mean %s %s %s.im ?", + e1->type->toChars(), opstr, e2->type->toChars(), + e1->type->toChars(), opstr, e2->type->toChars()); + } + else if ((e1->type->isreal() || e1->type->isimaginary()) && + e2->type->isimaginary()) + { + error("%s %s %s is an undefined operation", e1->type->toChars(), + opstr, e2->type->toChars()); + } +} + +// generate an error if this is a nonsensical += or -=, eg real += imaginary +void BinExp::checkComplexAddAssign() +{ + // Addition or subtraction of a real and an imaginary is a complex result. + // Thus, r+=i, r+=c, i+=r, i+=c are all forbidden operations. + if ( (e1->type->isreal() && (e2->type->isimaginary() || e2->type->iscomplex())) || + (e1->type->isimaginary() && (e2->type->isreal() || e2->type->iscomplex())) + ) + { + error("%s %s %s is undefined (result is complex)", + e1->type->toChars(), Token::toChars(op), e2->type->toChars()); + } +} + +void BinExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, precedence[op]); + buf->writeByte(' '); + buf->writestring(Token::toChars(op)); + buf->writeByte(' '); + expToCBuffer(buf, hgs, e2, (enum PREC)(precedence[op] + 1)); +} + +int BinExp::isunsigned() +{ + return e1->type->isunsigned() || e2->type->isunsigned(); +} + +Expression *BinExp::incompatibleTypes() +{ + if (e1->type->toBasetype() != Type::terror && + e2->type->toBasetype() != Type::terror + ) + { error("incompatible types for ((%s) %s (%s)): '%s' and '%s'", + e1->toChars(), Token::toChars(op), e2->toChars(), + e1->type->toChars(), e2->type->toChars()); + return new ErrorExp(); + } + return this; +} + +/********************** BinAssignExp **************************************/ + +/*************************** + * Common semantic routine for some xxxAssignExp's. + */ + +Expression *BinAssignExp::commonSemanticAssign(Scope *sc) +{ Expression *e; + + if (!type) + { + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + if (e1->op == TOKslice) + { // T[] op= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + type = e1->type; + return arrayOp(sc); + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + type = e1->type; + if (type->toBasetype()->ty == Tbool) + { + error("operator not allowed on bool expression %s", toChars()); + return new ErrorExp(); + } + typeCombine(sc); + e1->checkArithmetic(); + e2->checkArithmetic(); + + if (op == TOKmodass) + { + if (e2->type->iscomplex()) + { error("cannot perform modulo complex arithmetic"); + return new ErrorExp(); + } + else if (type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + } + } + return this; +} + +Expression *BinAssignExp::commonSemanticAssignIntegral(Scope *sc) +{ Expression *e; + + if (!type) + { + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + if (e1->op == TOKslice) + { // T[] op= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + type = e1->type; + return arrayOp(sc); + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + type = e1->type; + if (type->toBasetype()->ty == Tbool) + { + e2 = e2->implicitCastTo(sc, type); + } + + typeCombine(sc); + e1->checkIntegral(); + e2->checkIntegral(); + } + return this; +} + +#if DMDV2 +int BinAssignExp::isLvalue() +{ + return 1; +} + +Expression *BinAssignExp::toLvalue(Scope *sc, Expression *ex) +{ Expression *e; + + if (e1->op == TOKvar) + { + /* Convert (e1 op= e2) to + * e1 op= e2; + * e1 + */ + e = e1->copy(); + e = new CommaExp(loc, this, e); + e = e->semantic(sc); + } + else + { + /* Convert (e1 op= e2) to + * ref v = e1; + * v op= e2; + * v + */ + + // ref v = e1; + Identifier *id = Lexer::uniqueId("__assignop"); + ExpInitializer *ei = new ExpInitializer(loc, e1); + VarDeclaration *v = new VarDeclaration(loc, e1->type, id, ei); + v->storage_class |= STCref | STCforeach; + Expression *de = new DeclarationExp(loc, v); + + // v op= e2 + e1 = new VarExp(e1->loc, v); + + e = new CommaExp(loc, de, this); + e = new CommaExp(loc, e, new VarExp(loc, v)); + e = e->semantic(sc); + } + return e; +} + +Expression *BinAssignExp::modifiableLvalue(Scope *sc, Expression *e) +{ + return toLvalue(sc, this); +} + +#endif + +/************************************************************/ + +CompileExp::CompileExp(Loc loc, Expression *e) + : UnaExp(loc, TOKmixin, sizeof(CompileExp), e) +{ +} + +Expression *CompileExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("CompileExp::semantic('%s')\n", toChars()); +#endif + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + if (e1->op == TOKerror) + return e1; + if (!e1->type->isString()) + { + error("argument to mixin must be a string type, not %s\n", e1->type->toChars()); + return new ErrorExp(); + } + e1 = e1->optimize(WANTvalue | WANTinterpret); + StringExp *se = e1->toString(); + if (!se) + { error("argument to mixin must be a string, not (%s)", e1->toChars()); + return new ErrorExp(); + } + se = se->toUTF8(sc); + Parser p(sc->module, (unsigned char *)se->string, se->len, 0); + p.loc = loc; + p.nextToken(); + //printf("p.loc.linnum = %d\n", p.loc.linnum); + Expression *e = p.parseExpression(); + if (p.token.value != TOKeof) + { error("incomplete mixin expression (%s)", se->toChars()); + return new ErrorExp(); + } + return e->semantic(sc); +} + +void CompileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("mixin("); + expToCBuffer(buf, hgs, e1, PREC_assign); + buf->writeByte(')'); +} + +/************************************************************/ + +FileExp::FileExp(Loc loc, Expression *e) + : UnaExp(loc, TOKmixin, sizeof(FileExp), e) +{ +} + +Expression *FileExp::semantic(Scope *sc) +{ char *name; + StringExp *se; + +#if LOGSEMANTIC + printf("FileExp::semantic('%s')\n", toChars()); +#endif + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->optimize(WANTvalue | WANTinterpret); + if (e1->op != TOKstring) + { error("file name argument must be a string, not (%s)", e1->toChars()); + goto Lerror; + } + se = (StringExp *)e1; + se = se->toUTF8(sc); + name = (char *)se->string; + + if (!global.params.fileImppath) + { error("need -Jpath switch to import text file %s", name); + goto Lerror; + } + + /* Be wary of CWE-22: Improper Limitation of a Pathname to a Restricted Directory + * ('Path Traversal') attacks. + * http://cwe.mitre.org/data/definitions/22.html + */ + + name = FileName::safeSearchPath(global.filePath, name); + if (!name) + { error("file %s cannot be found or not in a path specified with -J", se->toChars()); + goto Lerror; + } + + if (global.params.verbose) + printf("file %s\t(%s)\n", (char *)se->string, name); + + { File f(name); + if (f.read()) + { error("cannot read file %s", f.toChars()); + goto Lerror; + } + else + { + f.ref = 1; + se = new StringExp(loc, f.buffer, f.len); + } + } + return se->semantic(sc); + + Lerror: + return new ErrorExp(); +} + +void FileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("import("); + expToCBuffer(buf, hgs, e1, PREC_assign); + buf->writeByte(')'); +} + +/************************************************************/ + +AssertExp::AssertExp(Loc loc, Expression *e, Expression *msg) + : UnaExp(loc, TOKassert, sizeof(AssertExp), e) +{ + this->msg = msg; +} + +Expression *AssertExp::syntaxCopy() +{ + AssertExp *ae = new AssertExp(loc, e1->syntaxCopy(), + msg ? msg->syntaxCopy() : NULL); + return ae; +} + +Expression *AssertExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("AssertExp::semantic('%s')\n", toChars()); +#endif + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + // BUG: see if we can do compile time elimination of the Assert + e1 = e1->optimize(WANTvalue); + e1 = e1->checkToBoolean(sc); + if (msg) + { + msg = msg->semantic(sc); + msg = resolveProperties(sc, msg); + msg = msg->implicitCastTo(sc, Type::tchar->constOf()->arrayOf()); + msg = msg->optimize(WANTvalue); + } + if (e1->isBool(FALSE)) + { + FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + if (fd) + fd->hasReturnExp |= 4; + + if (!global.params.useAssert) + { Expression *e = new HaltExp(loc); + e = e->semantic(sc); + return e; + } + } + type = Type::tvoid; + return this; +} + + +void AssertExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("assert("); + expToCBuffer(buf, hgs, e1, PREC_assign); + if (msg) + { + buf->writeByte(','); + expToCBuffer(buf, hgs, msg, PREC_assign); + } + buf->writeByte(')'); +} + +/************************************************************/ + +DotIdExp::DotIdExp(Loc loc, Expression *e, Identifier *ident) + : UnaExp(loc, TOKdot, sizeof(DotIdExp), e) +{ + this->ident = ident; +} + +Expression *DotIdExp::semantic(Scope *sc) +{ + // Indicate we didn't come from CallExp::semantic() + return semantic(sc, 0); +} + +Expression *DotIdExp::semantic(Scope *sc, int flag) +{ Expression *e; + Expression *eleft; + Expression *eright; + +#if LOGSEMANTIC + printf("DotIdExp::semantic(this = %p, '%s')\n", this, toChars()); + //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); +#endif + +//{ static int z; fflush(stdout); if (++z == 10) *(char*)0=0; } + +#if 0 + /* Don't do semantic analysis if we'll be converting + * it to a string. + */ + if (ident == Id::stringof) + { char *s = e1->toChars(); + e = new StringExp(loc, s, strlen(s), 'c'); + e = e->semantic(sc); + return e; + } +#endif + + /* Special case: rewrite this.id and super.id + * to be classtype.id and baseclasstype.id + * if we have no this pointer. + */ + if ((e1->op == TOKthis || e1->op == TOKsuper) && !hasThis(sc)) + { ClassDeclaration *cd; + StructDeclaration *sd; + AggregateDeclaration *ad; + + ad = sc->getStructClassScope(); + if (ad) + { + cd = ad->isClassDeclaration(); + if (cd) + { + if (e1->op == TOKthis) + { + e = typeDotIdExp(loc, cd->type, ident); + return e->semantic(sc); + } + else if (cd->baseClass && e1->op == TOKsuper) + { + e = typeDotIdExp(loc, cd->baseClass->type, ident); + return e->semantic(sc); + } + } + else + { + sd = ad->isStructDeclaration(); + if (sd) + { + if (e1->op == TOKthis) + { + e = typeDotIdExp(loc, sd->type, ident); + return e->semantic(sc); + } + } + } + } + } + + UnaExp::semantic(sc); + + if (ident == Id::mangleof) + { // symbol.mangleof + Dsymbol *ds; + switch (e1->op) + { + case TOKimport: ds = ((ScopeExp *)e1)->sds; goto L1; + case TOKvar: ds = ((VarExp *)e1)->var; goto L1; + case TOKdotvar: ds = ((DotVarExp *)e1)->var; goto L1; + L1: + char* s = ds->mangle(); + e = new StringExp(loc, s, strlen(s), 'c'); + e = e->semantic(sc); + return e; + } + } + + if (e1->op == TOKdotexp) + { + DotExp *de = (DotExp *)e1; + eleft = de->e1; + eright = de->e2; + } + else + { + if (e1->op != TOKtype) + e1 = resolveProperties(sc, e1); + eleft = NULL; + eright = e1; + } +#if DMDV2 + if (e1->op == TOKtuple && ident == Id::offsetof) + { /* 'distribute' the .offsetof to each of the tuple elements. + */ + TupleExp *te = (TupleExp *)e1; + Expressions *exps = new Expressions(); + exps->setDim(te->exps->dim); + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = (*te->exps)[i]; + e = e->semantic(sc); + e = new DotIdExp(e->loc, e, Id::offsetof); + (*exps)[i] = e; + } + e = new TupleExp(loc, exps); + e = e->semantic(sc); + return e; + } +#endif + + if (e1->op == TOKtuple && ident == Id::length) + { + TupleExp *te = (TupleExp *)e1; + e = new IntegerExp(loc, te->exps->dim, Type::tsize_t); + return e; + } + + if (e1->op == TOKdottd) + { + error("template %s does not have property %s", e1->toChars(), ident->toChars()); + return new ErrorExp(); + } + + if (!e1->type) + { + error("expression %s does not have property %s", e1->toChars(), ident->toChars()); + return new ErrorExp(); + } + + Type *t1b = e1->type->toBasetype(); + + if (eright->op == TOKimport) // also used for template alias's + { + ScopeExp *ie = (ScopeExp *)eright; + + /* Disable access to another module's private imports. + * The check for 'is sds our current module' is because + * the current module should have access to its own imports. + */ + Dsymbol *s = ie->sds->search(loc, ident, + (ie->sds->isModule() && ie->sds != sc->module) ? 1 : 0); + if (s) + { + /* Check for access before resolving aliases because public + * aliases to private symbols are public. + */ + if (Declaration *d = s->isDeclaration()) + accessCheck(loc, sc, 0, d); + + s = s->toAlias(); + checkDeprecated(sc, s); + + EnumMember *em = s->isEnumMember(); + if (em) + { + e = em->value; + e = e->semantic(sc); + return e; + } + + VarDeclaration *v = s->isVarDeclaration(); + if (v) + { + //printf("DotIdExp:: Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); + if (v->inuse) + { + error("circular reference to '%s'", v->toChars()); + return new ErrorExp(); + } + type = v->type; + if (v->needThis()) + { + if (!eleft) + eleft = new ThisExp(loc); + e = new DotVarExp(loc, eleft, v); + e = e->semantic(sc); + } + else + { + e = new VarExp(loc, v); + if (eleft) + { e = new CommaExp(loc, eleft, e); + e->type = v->type; + } + } + e = e->deref(); + return e->semantic(sc); + } + + FuncDeclaration *f = s->isFuncDeclaration(); + if (f) + { + //printf("it's a function\n"); + if (f->needThis()) + { + if (!eleft) + eleft = new ThisExp(loc); + e = new DotVarExp(loc, eleft, f); + e = e->semantic(sc); + } + else + { + e = new VarExp(loc, f, 1); + if (eleft) + { e = new CommaExp(loc, eleft, e); + e->type = f->type; + } + } + return e; + } +#if DMDV2 + OverloadSet *o = s->isOverloadSet(); + if (o) + { //printf("'%s' is an overload set\n", o->toChars()); + return new OverExp(o); + } +#endif + + Type *t = s->getType(); + if (t) + { + return new TypeExp(loc, t); + } + + TupleDeclaration *tup = s->isTupleDeclaration(); + if (tup) + { + if (eleft) + { error("cannot have e.tuple"); + return new ErrorExp(); + } + e = new TupleExp(loc, tup); + e = e->semantic(sc); + return e; + } + + ScopeDsymbol *sds = s->isScopeDsymbol(); + if (sds) + { + //printf("it's a ScopeDsymbol\n"); + e = new ScopeExp(loc, sds); + e = e->semantic(sc); + if (eleft) + e = new DotExp(loc, eleft, e); + return e; + } + + Import *imp = s->isImport(); + if (imp) + { + ScopeExp *ie; + + ie = new ScopeExp(loc, imp->pkg); + return ie->semantic(sc); + } + + // BUG: handle other cases like in IdentifierExp::semantic() +#ifdef DEBUG + printf("s = '%s', kind = '%s'\n", s->toChars(), s->kind()); +#endif + assert(0); + } + else if (ident == Id::stringof) + { char *s = ie->toChars(); + e = new StringExp(loc, s, strlen(s), 'c'); + e = e->semantic(sc); + return e; + } + error("undefined identifier %s", toChars()); + return new ErrorExp(); + } + else if (t1b->ty == Tpointer && + ident != Id::init && ident != Id::__sizeof && + ident != Id::__xalignof && ident != Id::offsetof && + ident != Id::mangleof && ident != Id::stringof) + { /* Rewrite: + * p.ident + * as: + * (*p).ident + */ + e = new PtrExp(loc, e1); + e->type = ((TypePointer *)t1b)->next; + return e->type->dotExp(sc, e, ident); + } +#if DMDV2 + else if ((t1b->ty == Tarray || t1b->ty == Tsarray || + t1b->ty == Taarray) && + ident != Id::sort && ident != Id::reverse && + ident != Id::dup && ident != Id::idup) + { /* If ident is not a valid property, rewrite: + * e1.ident + * as: + * .ident(e1) + */ + unsigned errors = global.startGagging(); + Type *t1 = e1->type; + e = e1->type->dotExp(sc, e1, ident); + if (global.endGagging(errors)) // if failed to find the property + { + e1->type = t1; // kludge to restore type + e = new DotIdExp(loc, new IdentifierExp(loc, Id::empty), ident); + e = new CallExp(loc, e, e1); + } + e = e->semantic(sc); + return e; + } +#endif + else + { + e = e1->type->dotExp(sc, e1, ident); + if (!(flag && e->op == TOKdotti)) // let CallExp::semantic() handle this + e = e->semantic(sc); + return e; + } +} + +void DotIdExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + //printf("DotIdExp::toCBuffer()\n"); + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + buf->writestring(ident->toChars()); +} + +/********************** DotTemplateExp ***********************************/ + +// Mainly just a placeholder + +DotTemplateExp::DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td) + : UnaExp(loc, TOKdottd, sizeof(DotTemplateExp), e) + +{ + this->td = td; +} + +void DotTemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + buf->writestring(td->toChars()); +} + + +/************************************************************/ + +DotVarExp::DotVarExp(Loc loc, Expression *e, Declaration *v, int hasOverloads) + : UnaExp(loc, TOKdotvar, sizeof(DotVarExp), e) +{ + //printf("DotVarExp()\n"); + this->var = v; + this->hasOverloads = hasOverloads; +} + +Expression *DotVarExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DotVarExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + var = var->toAlias()->isDeclaration(); + + TupleDeclaration *tup = var->isTupleDeclaration(); + if (tup) + { /* Replace: + * e1.tuple(a, b, c) + * with: + * tuple(e1.a, e1.b, e1.c) + */ + Expressions *exps = new Expressions; + Expression *ev = e1; + + exps->reserve(tup->objects->dim); + for (size_t i = 0; i < tup->objects->dim; i++) + { Object *o = tup->objects->tdata()[i]; + if (o->dyncast() != DYNCAST_EXPRESSION) + { + error("%s is not an expression", o->toChars()); + goto Lerr; + } + + Expression *e = (Expression *)o; + if (e->op != TOKdsymbol) + { error("%s is not a member", e->toChars()); + goto Lerr; + } + + Dsymbol *s = ((DsymbolExp *)e)->s; + if (i == 0 && sc->func && tup->objects->dim > 1 && + e1->hasSideEffect()) + { + Identifier *id = Lexer::uniqueId("__tup"); + ExpInitializer *ei = new ExpInitializer(e1->loc, e1); + VarDeclaration *v = new VarDeclaration(e1->loc, NULL, id, ei); + v->storage_class |= STCctfe | STCref | STCforeach; + + ev = new VarExp(e->loc, v); + e = new CommaExp(e1->loc, new DeclarationExp(e1->loc, v), ev); + e = new DotVarExp(loc, e, s->isDeclaration()); + } + else + e = new DotVarExp(loc, ev, s->isDeclaration()); + exps->push(e); + } + Expression *e = new TupleExp(loc, exps); + e = e->semantic(sc); + return e; + } + + e1 = e1->semantic(sc); + e1 = e1->addDtorHook(sc); + type = var->type; + if (!type && global.errors) + { // var is goofed up, just return 0 + return new ErrorExp(); + } + assert(type); + + Type *t1 = e1->type; + if (!var->isFuncDeclaration()) // for functions, do checks after overload resolution + { + if (t1->ty == Tpointer) + t1 = t1->nextOf(); + + type = type->addMod(t1->mod); + + Dsymbol *vparent = var->toParent(); + AggregateDeclaration *ad = vparent ? vparent->isAggregateDeclaration() : NULL; + e1 = getRightThis(loc, sc, ad, e1, var); + if (!sc->noaccesscheck) + accessCheck(loc, sc, e1, var); + + VarDeclaration *v = var->isVarDeclaration(); + Expression *e = expandVar(WANTvalue, v); + if (e) + return e; + } + Dsymbol *s; + if (sc->func && !sc->intypeof && t1->hasPointers() && + (s = t1->toDsymbol(sc)) != NULL) + { + AggregateDeclaration *ad = s->isAggregateDeclaration(); + if (ad && ad->hasUnions) + { + if (sc->func->setUnsafe()) + { error("union %s containing pointers are not allowed in @safe functions", t1->toChars()); + goto Lerr; + } + } + } + } + + //printf("-DotVarExp::semantic('%s')\n", toChars()); + return this; + +Lerr: + return new ErrorExp(); +} + +#if DMDV2 +int DotVarExp::isLvalue() +{ + return 1; +} +#endif + +Expression *DotVarExp::toLvalue(Scope *sc, Expression *e) +{ + //printf("DotVarExp::toLvalue(%s)\n", toChars()); + return this; +} + +/*********************************************** + * Mark variable v as modified if it is inside a constructor that var + * is a field in. + */ +void modifyFieldVar(Loc loc, Scope *sc, VarDeclaration *var, Expression *e1) +{ + //printf("modifyFieldVar(var = %s)\n", var->toChars()); + Dsymbol *s = sc->func; + while (1) + { + FuncDeclaration *fd = NULL; + if (s) + fd = s->isFuncDeclaration(); + if (fd && + ((fd->isCtorDeclaration() && var->storage_class & STCfield) || + (fd->isStaticCtorDeclaration() && !(var->storage_class & STCfield))) && + fd->toParent2() == var->toParent2() && + (!e1 || e1->op == TOKthis) + ) + { + var->ctorinit = 1; + //printf("setting ctorinit\n"); + } + else + { + if (s) + { s = s->toParent2(); + continue; + } + else if (var->storage_class & STCctorinit) + { + const char *p = var->isStatic() ? "static " : ""; + error(loc, "can only initialize %sconst member %s inside %sconstructor", + p, var->toChars(), p); + } + } + break; + } +} + +Expression *DotVarExp::modifiableLvalue(Scope *sc, Expression *e) +{ +#if 0 + printf("DotVarExp::modifiableLvalue(%s)\n", toChars()); + printf("e1->type = %s\n", e1->type->toChars()); + printf("var->type = %s\n", var->type->toChars()); +#endif + + Type *t1 = e1->type->toBasetype(); + + if (!t1->isMutable() || + (t1->ty == Tpointer && !t1->nextOf()->isMutable()) || + !var->type->isMutable() || + !var->type->isAssignable() || + var->storage_class & STCmanifest + ) + { + if (var->isCtorinit()) + { // It's only modifiable if inside the right constructor + modifyFieldVar(loc, sc, var->isVarDeclaration(), e1); + } + else + { + error("cannot modify const/immutable/inout expression %s", toChars()); + } + } + else if (var->storage_class & STCnodefaultctor) + { + modifyFieldVar(loc, sc, var->isVarDeclaration(), e1); + } + return this; +} + +void DotVarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + buf->writestring(var->toChars()); +} + +/************************************************************/ + +/* Things like: + * foo.bar!(args) + */ + +DotTemplateInstanceExp::DotTemplateInstanceExp(Loc loc, Expression *e, Identifier *name, Objects *tiargs) + : UnaExp(loc, TOKdotti, sizeof(DotTemplateInstanceExp), e) +{ + //printf("DotTemplateInstanceExp()\n"); + this->ti = new TemplateInstance(loc, name); + this->ti->tiargs = tiargs; +} + +Expression *DotTemplateInstanceExp::syntaxCopy() +{ + DotTemplateInstanceExp *de = new DotTemplateInstanceExp(loc, + e1->syntaxCopy(), + ti->name, + TemplateInstance::arraySyntaxCopy(ti->tiargs)); + return de; +} + +TemplateDeclaration *DotTemplateInstanceExp::getTempdecl(Scope *sc) +{ +#if LOGSEMANTIC + printf("DotTemplateInstanceExp::getTempdecl('%s')\n", toChars()); +#endif + if (!ti->tempdecl) + { + Expression *e = new DotIdExp(loc, e1, ti->name); + e = e->semantic(sc); + if (e->op == TOKdottd) + { + DotTemplateExp *dte = (DotTemplateExp *)e; + ti->tempdecl = dte->td; + } + else if (e->op == TOKimport) + { ScopeExp *se = (ScopeExp *)e; + ti->tempdecl = se->sds->isTemplateDeclaration(); + } + } + return ti->tempdecl; +} + +Expression *DotTemplateInstanceExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DotTemplateInstanceExp::semantic('%s')\n", toChars()); +#endif + Expression *eleft; + Expression *e = new DotIdExp(loc, e1, ti->name); +L1: + e = e->semantic(sc); + if (e->op == TOKerror) + return e; + if (e->op == TOKdottd) + { + if (global.errors) + return new ErrorExp(); // TemplateInstance::semantic() will fail anyway + DotTemplateExp *dte = (DotTemplateExp *)e; + TemplateDeclaration *td = dte->td; + eleft = dte->e1; + ti->tempdecl = td; + if (ti->needsTypeInference(sc)) + { + e1 = eleft; // save result of semantic() + return this; + } + else + ti->semantic(sc); + if (!ti->inst) // if template failed to expand + return new ErrorExp(); + Dsymbol *s = ti->inst->toAlias(); + Declaration *v = s->isDeclaration(); + if (v) + { + /* Fix for Bugzilla 4003 + * The problem is a class template member function v returning a reference to the same + * type as the enclosing template instantiation. This results in a nested instantiation, + * which of course gets short circuited. The return type then gets set to + * the template instance type before instantiation, rather than after. + * We can detect this by the deco not being set. If so, go ahead and retry + * the return type semantic. + * The offending code is the return type from std.typecons.Tuple.slice: + * ref Tuple!(Types[from .. to]) slice(uint from, uint to)() + * { + * return *cast(typeof(return) *) &(field[from]); + * } + * and this line from the following unittest: + * auto s = a.slice!(1, 3); + * where s's type wound up not having semantic() run on it. + */ + if (v->type && !v->type->deco) + v->type = v->type->semantic(v->loc, sc); + + e = new DotVarExp(loc, eleft, v); + e = e->semantic(sc); + return e; + } + e = new ScopeExp(loc, ti); + e = new DotExp(loc, eleft, e); + e = e->semantic(sc); + return e; + } + else if (e->op == TOKimport) + { ScopeExp *se = (ScopeExp *)e; + TemplateDeclaration *td = se->sds->isTemplateDeclaration(); + if (!td) + { error("%s is not a template", e->toChars()); + return new ErrorExp(); + } + ti->tempdecl = td; + e = new ScopeExp(loc, ti); + e = e->semantic(sc); + return e; + } + else if (e->op == TOKdotexp) + { DotExp *de = (DotExp *)e; + + if (de->e2->op == TOKoverloadset) + { + return e; + } + + if (de->e2->op == TOKimport) + { // This should *really* be moved to ScopeExp::semantic() + ScopeExp *se = (ScopeExp *)de->e2; + de->e2 = new DsymbolExp(loc, se->sds); + de->e2 = de->e2->semantic(sc); + } + + if (de->e2->op == TOKtemplate) + { TemplateExp *te = (TemplateExp *) de->e2; + e = new DotTemplateExp(loc,de->e1,te->td); + } + goto L1; + } + error("%s isn't a template", e->toChars()); + return new ErrorExp(); +} + +void DotTemplateInstanceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + ti->toCBuffer(buf, hgs); +} + +/************************************************************/ + +DelegateExp::DelegateExp(Loc loc, Expression *e, FuncDeclaration *f, int hasOverloads) + : UnaExp(loc, TOKdelegate, sizeof(DelegateExp), e) +{ + this->func = f; + this->hasOverloads = hasOverloads; +} + +Expression *DelegateExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DelegateExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + e1 = e1->semantic(sc); + type = new TypeDelegate(func->type); + type = type->semantic(loc, sc); + AggregateDeclaration *ad = func->toParent()->isAggregateDeclaration(); + if (func->needThis()) + e1 = getRightThis(loc, sc, ad, e1, func); + if (ad && ad->isClassDeclaration() && ad->type != e1->type) + { // A downcast is required for interfaces, see Bugzilla 3706 + e1 = new CastExp(loc, e1, ad->type); + e1 = e1->semantic(sc); + } + } + return this; +} + +void DelegateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('&'); + if (!func->isNested()) + { + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + } + buf->writestring(func->toChars()); +} + +/************************************************************/ + +DotTypeExp::DotTypeExp(Loc loc, Expression *e, Dsymbol *s) + : UnaExp(loc, TOKdottype, sizeof(DotTypeExp), e) +{ + this->sym = s; + this->type = s->getType(); +} + +Expression *DotTypeExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DotTypeExp::semantic('%s')\n", toChars()); +#endif + UnaExp::semantic(sc); + return this; +} + +void DotTypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + buf->writestring(sym->toChars()); +} + +/************************************************************/ + +CallExp::CallExp(Loc loc, Expression *e, Expressions *exps) + : UnaExp(loc, TOKcall, sizeof(CallExp), e) +{ + this->arguments = exps; + this->f = NULL; +} + +CallExp::CallExp(Loc loc, Expression *e) + : UnaExp(loc, TOKcall, sizeof(CallExp), e) +{ + this->arguments = NULL; +} + +CallExp::CallExp(Loc loc, Expression *e, Expression *earg1) + : UnaExp(loc, TOKcall, sizeof(CallExp), e) +{ + Expressions *arguments = new Expressions(); + if (earg1) + { arguments->setDim(1); + arguments->tdata()[0] = earg1; + } + this->arguments = arguments; +} + +CallExp::CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2) + : UnaExp(loc, TOKcall, sizeof(CallExp), e) +{ + Expressions *arguments = new Expressions(); + arguments->setDim(2); + arguments->tdata()[0] = earg1; + arguments->tdata()[1] = earg2; + + this->arguments = arguments; +} + +Expression *CallExp::syntaxCopy() +{ + return new CallExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); +} + + +Expression *CallExp::resolveUFCS(Scope *sc) +{ + Expression *ethis = NULL; + DotIdExp *dotid; + DotTemplateInstanceExp *dotti; + Identifier *ident; + + if (e1->op == TOKdot) + { + dotid = (DotIdExp *)e1; + ident = dotid->ident; + ethis = dotid->e1 = dotid->e1->semantic(sc); + if (ethis->op == TOKdotexp) + return NULL; + ethis = resolveProperties(sc, ethis); + } + else if (e1->op == TOKdotti) + { + dotti = (DotTemplateInstanceExp *)e1; + ident = dotti->ti->name; + ethis = dotti->e1 = dotti->e1->semantic(sc); + if (ethis->op == TOKdotexp) + return NULL; + ethis = resolveProperties(sc, ethis); + } + + if (ethis && ethis->type) + { + AggregateDeclaration *ad; +Lagain: + Type *tthis = ethis->type->toBasetype(); + if (tthis->ty == Tclass) + { + ad = ((TypeClass *)tthis)->sym; + if (search_function(ad, ident)) + return NULL; + goto L1; + } + else if (tthis->ty == Tstruct) + { + ad = ((TypeStruct *)tthis)->sym; + if (search_function(ad, ident)) + return NULL; + L1: + if (ad->aliasthis) + { + ethis = new DotIdExp(ethis->loc, ethis, ad->aliasthis->ident); + ethis = ethis->semantic(sc); + ethis = resolveProperties(sc, ethis); + goto Lagain; + } + } + else if (tthis->ty == Taarray && e1->op == TOKdot) + { + if (ident == Id::remove) + { + /* Transform: + * aa.remove(arg) into delete aa[arg] + */ + if (!arguments || arguments->dim != 1) + { error("expected key as argument to aa.remove()"); + return new ErrorExp(); + } + Expression *key = arguments->tdata()[0]; + key = key->semantic(sc); + key = resolveProperties(sc, key); + if (!key->rvalue()) + return new ErrorExp(); + + TypeAArray *taa = (TypeAArray *)tthis; + key = key->implicitCastTo(sc, taa->index); + + return new RemoveExp(loc, ethis, key); + } + else if (ident == Id::apply || ident == Id::applyReverse) + { + return NULL; + } + else + { TypeAArray *taa = (TypeAArray *)tthis; + assert(taa->ty == Taarray); + StructDeclaration *sd = taa->getImpl(); + Dsymbol *s = sd->search(0, ident, 2); + if (s) + return NULL; + goto Lshift; + } + } + else if (tthis->ty == Tarray || tthis->ty == Tsarray) + { +Lshift: + if (!arguments) + arguments = new Expressions(); + arguments->shift(ethis); + if (e1->op == TOKdot) + { + /* Transform: + * array.id(args) into .id(array,args) + */ +#if DMDV2 + e1 = new DotIdExp(dotid->loc, + new IdentifierExp(dotid->loc, Id::empty), + ident); +#else + e1 = new IdentifierExp(dotid->loc, ident); +#endif + } + else if (e1->op == TOKdotti) + { + /* Transform: + * array.foo!(tiargs)(args) into .foo!(tiargs)(array,args) + */ +#if DMDV2 + e1 = new DotTemplateInstanceExp(dotti->loc, + new IdentifierExp(dotti->loc, Id::empty), + dotti->ti->name, dotti->ti->tiargs); +#else + e1 = new ScopeExp(dotti->loc, dotti->ti); +#endif + } + //printf("-> this = %s\n", toChars()); + } + } + return NULL; +} + +Expression *CallExp::semantic(Scope *sc) +{ + TypeFunction *tf; + Type *t1; + int istemp; + Objects *targsi = NULL; // initial list of template arguments + TemplateInstance *tierror = NULL; + Expression *ethis = NULL; + +#if LOGSEMANTIC + printf("CallExp::semantic() %s\n", toChars()); +#endif + if (type) + return this; // semantic() already run +#if 0 + if (arguments && arguments->dim) + { + Expression *earg = arguments->tdata()[0]; + earg->print(); + if (earg->type) earg->type->print(); + } +#endif + + if (e1->op == TOKcomma) + { /* Rewrite (a,b)(args) as (a,(b(args))) + */ + CommaExp *ce = (CommaExp *)e1; + + e1 = ce->e2; + e1->type = ce->type; + ce->e2 = this; + ce->type = NULL; + return ce->semantic(sc); + } + + if (e1->op == TOKdelegate) + { DelegateExp *de = (DelegateExp *)e1; + + e1 = new DotVarExp(de->loc, de->e1, de->func); + return semantic(sc); + } + + if (e1->op == TOKfunction) + { FuncExp *fe = (FuncExp *)e1; + + arguments = arrayExpressionSemantic(arguments, sc); + preFunctionParameters(loc, sc, arguments); + e1 = fe->semantic(sc, arguments); + if (e1->op == TOKerror) + return e1; + } + + Expression *e = resolveUFCS(sc); + if (e) + return e; + +#if 1 + /* This recognizes: + * foo!(tiargs)(funcargs) + */ + if (e1->op == TOKimport && !e1->type) + { ScopeExp *se = (ScopeExp *)e1; + TemplateInstance *ti = se->sds->isTemplateInstance(); + if (ti && !ti->semanticRun) + { + /* Attempt to instantiate ti. If that works, go with it. + * If not, go with partial explicit specialization. + */ + ti->semanticTiargs(sc); + if (ti->needsTypeInference(sc)) + { + /* Go with partial explicit specialization + */ + targsi = ti->tiargs; + tierror = ti; // for error reporting + e1 = new IdentifierExp(loc, ti->name); + } + else + { + ti->semantic(sc); + } + } + } + + /* This recognizes: + * expr.foo!(tiargs)(funcargs) + */ +Ldotti: + if (e1->op == TOKdotti && !e1->type) + { DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)e1; + TemplateInstance *ti = se->ti; + if (!ti->semanticRun) + { + /* Attempt to instantiate ti. If that works, go with it. + * If not, go with partial explicit specialization. + */ + ti->semanticTiargs(sc); +#if 0 + Expression *etmp = e1->trySemantic(sc); + if (etmp) + e1 = etmp; // it worked + else // didn't work + { + targsi = ti->tiargs; + tierror = ti; // for error reporting + e1 = new DotIdExp(loc, se->e1, ti->name); + } +#else + if (!ti->tempdecl) + { + se->getTempdecl(sc); + } + if (ti->tempdecl && ti->needsTypeInference(sc)) + { + /* Go with partial explicit specialization + */ + targsi = ti->tiargs; + tierror = ti; // for error reporting + e1 = new DotIdExp(loc, se->e1, ti->name); + } + else + { + e1 = e1->semantic(sc); + } +#endif + } + } +#endif + + istemp = 0; +Lagain: + //printf("Lagain: %s\n", toChars()); + f = NULL; + if (e1->op == TOKthis || e1->op == TOKsuper) + { + // semantic() run later for these + } + else + { + if (e1->op == TOKdot) + { DotIdExp *die = (DotIdExp *)e1; + e1 = die->semantic(sc, 1); + /* Look for e1 having been rewritten to expr.opDispatch!(string) + * We handle such earlier, so go back. + * Note that in the rewrite, we carefully did not run semantic() on e1 + */ + if (e1->op == TOKdotti && !e1->type) + { + goto Ldotti; + } + } + else + { + static int nest; + if (++nest > 500) + { + error("recursive evaluation of %s", toChars()); + --nest; + return new ErrorExp(); + } + UnaExp::semantic(sc); + --nest; + } + + /* Look for e1 being a lazy parameter + */ + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + + if (ve->var->storage_class & STClazy) + { + // lazy paramaters can be called without violating purity and safety + TypeFunction *tf = new TypeFunction(NULL, ve->var->type, 0, LINKd, STCsafe | STCpure); + TypeDelegate *t = new TypeDelegate(tf); + ve->type = t->semantic(loc, sc); + } + } + + if (e1->op == TOKimport) + { // Perhaps this should be moved to ScopeExp::semantic() + ScopeExp *se = (ScopeExp *)e1; + e1 = new DsymbolExp(loc, se->sds); + e1 = e1->semantic(sc); + } + else if (e1->op == TOKsymoff && ((SymOffExp *)e1)->hasOverloads) + { + SymOffExp *se = (SymOffExp *)e1; + e1 = new VarExp(se->loc, se->var, 1); + e1 = e1->semantic(sc); + } +#if 1 // patch for #540 by Oskar Linde + else if (e1->op == TOKdotexp) + { + DotExp *de = (DotExp *) e1; + + if (de->e2->op == TOKoverloadset) + { + ethis = de->e1; + e1 = de->e2; + } + + if (de->e2->op == TOKimport) + { // This should *really* be moved to ScopeExp::semantic() + ScopeExp *se = (ScopeExp *)de->e2; + de->e2 = new DsymbolExp(loc, se->sds); + de->e2 = de->e2->semantic(sc); + } + + if (de->e2->op == TOKtemplate) + { TemplateExp *te = (TemplateExp *) de->e2; + e1 = new DotTemplateExp(loc,de->e1,te->td); + } + } +#endif + } + + t1 = NULL; + if (e1->type) + t1 = e1->type->toBasetype(); + + // Check for call operator overload + if (t1) + { AggregateDeclaration *ad; + + if (t1->ty == Tstruct) + { + ad = ((TypeStruct *)t1)->sym; +#if DMDV2 + // First look for constructor + if (ad->ctor && arguments && arguments->dim) + { + // Create variable that will get constructed + Identifier *idtmp = Lexer::uniqueId("__ctmp"); + VarDeclaration *tmp = new VarDeclaration(loc, t1, idtmp, NULL); + tmp->storage_class |= STCctfe; + Expression *av = new DeclarationExp(loc, tmp); + av = new CommaExp(loc, av, new VarExp(loc, tmp)); + + Expression *e; + CtorDeclaration *cf = ad->ctor->isCtorDeclaration(); + if (cf) + e = new DotVarExp(loc, av, cf, 1); + else + { TemplateDeclaration *td = ad->ctor->isTemplateDeclaration(); + assert(td); + e = new DotTemplateExp(loc, av, td); + } + e = new CallExp(loc, e, arguments); +#if !STRUCTTHISREF + /* Constructors return a pointer to the instance + */ + e = new PtrExp(loc, e); +#endif + e = e->semantic(sc); + return e; + } +#endif + // No constructor, look for overload of opCall + if (search_function(ad, Id::call)) + goto L1; // overload of opCall, therefore it's a call + + if (e1->op != TOKtype) + { error("%s %s does not overload ()", ad->kind(), ad->toChars()); + return new ErrorExp(); + } + + /* It's a struct literal + */ + Expression *e = new StructLiteralExp(loc, (StructDeclaration *)ad, arguments, e1->type); + e = e->semantic(sc); + return e; + } + else if (t1->ty == Tclass) + { + ad = ((TypeClass *)t1)->sym; + goto L1; + L1: + // Rewrite as e1.call(arguments) + Expression *e = new DotIdExp(loc, e1, Id::call); + e = new CallExp(loc, e, arguments); + e = e->semantic(sc); + return e; + } + } + + arguments = arrayExpressionSemantic(arguments, sc); + preFunctionParameters(loc, sc, arguments); + + // If there was an error processing any argument, or the call, + // return an error without trying to resolve the function call. + if (arguments && arguments->dim) + { + for (size_t k = 0; k < arguments->dim; k++) + { Expression *checkarg = arguments->tdata()[k]; + if (checkarg->op == TOKerror) + return checkarg; + } + } + if (e1->op == TOKerror) + return e1; + + if (e1->op == TOKdotvar && t1->ty == Tfunction || + e1->op == TOKdottd) + { + DotVarExp *dve; + DotTemplateExp *dte; + AggregateDeclaration *ad; + UnaExp *ue = (UnaExp *)(e1); + + if (e1->op == TOKdotvar) + { // Do overload resolution + dve = (DotVarExp *)(e1); + + f = dve->var->isFuncDeclaration(); + assert(f); + f = f->overloadResolve(loc, ue->e1, arguments); + + ad = f->toParent()->isAggregateDeclaration(); + } + else + { dte = (DotTemplateExp *)(e1); + TemplateDeclaration *td = dte->td; + assert(td); + if (!arguments) + // Should fix deduceFunctionTemplate() so it works on NULL argument + arguments = new Expressions(); + f = td->deduceFunctionTemplate(sc, loc, targsi, ue->e1, arguments); + if (!f) + return new ErrorExp(); + ad = td->toParent()->isAggregateDeclaration(); + } + if (f->needThis()) + { + ue->e1 = getRightThis(loc, sc, ad, ue->e1, f); + ethis = ue->e1; + } + + /* Cannot call public functions from inside invariant + * (because then the invariant would have infinite recursion) + */ + if (sc->func && sc->func->isInvariantDeclaration() && + ue->e1->op == TOKthis && + f->addPostInvariant() + ) + { + error("cannot call public/export function %s from invariant", f->toChars()); + return new ErrorExp(); + } + + checkDeprecated(sc, f); +#if DMDV2 + checkPurity(sc, f); + checkSafety(sc, f); +#endif + accessCheck(loc, sc, ue->e1, f); + if (!f->needThis()) + { + VarExp *ve = new VarExp(loc, f); + if ((ue->e1)->op == TOKtype) // just a FQN + e1 = ve; + else // things like (new Foo).bar() + e1 = new CommaExp(loc, ue->e1, ve); + e1->type = f->type; + } + else + { + if (e1->op == TOKdotvar) + { + dve->var = f; + e1->type = f->type; + } + else + { + e1 = new DotVarExp(loc, dte->e1, f); + e1 = e1->semantic(sc); + } +#if 0 + printf("ue->e1 = %s\n", ue->e1->toChars()); + printf("f = %s\n", f->toChars()); + printf("t = %s\n", t->toChars()); + printf("e1 = %s\n", e1->toChars()); + printf("e1->type = %s\n", e1->type->toChars()); +#endif + // Const member function can take const/immutable/mutable/inout this + if (!(f->type->isConst())) + { + // Check for const/immutable compatibility + Type *tthis = ue->e1->type->toBasetype(); + if (tthis->ty == Tpointer) + tthis = tthis->nextOf()->toBasetype(); +#if 0 // this checking should have been already done + if (f->type->isImmutable()) + { + if (tthis->mod != MODimmutable) + error("%s can only be called with an immutable object", e1->toChars()); + } + else if (f->type->isShared()) + { + if (tthis->mod != MODimmutable && + tthis->mod != MODshared && + tthis->mod != (MODshared | MODconst)) + error("shared %s can only be called with a shared or immutable object", e1->toChars()); + } + else + { + if (tthis->mod != 0) + { //printf("mod = %x\n", tthis->mod); + error("%s can only be called with a mutable object, not %s", e1->toChars(), tthis->toChars()); + } + } +#endif + /* Cannot call mutable method on a final struct + */ + if (tthis->ty == Tstruct && + ue->e1->op == TOKvar) + { VarExp *v = (VarExp *)ue->e1; + if (v->var->storage_class & STCfinal) + error("cannot call mutable method on final struct"); + } + } + + // See if we need to adjust the 'this' pointer + AggregateDeclaration *ad = f->isThis(); + ClassDeclaration *cd = ue->e1->type->isClassHandle(); + if (ad && cd && ad->isClassDeclaration() && ad != cd && + ue->e1->op != TOKsuper) + { + ue->e1 = ue->e1->castTo(sc, ad->type); //new CastExp(loc, ue->e1, ad->type); + ue->e1 = ue->e1->semantic(sc); + } + } + t1 = e1->type; + } + else if (e1->op == TOKsuper) + { + // Base class constructor call + ClassDeclaration *cd = NULL; + + if (sc->func) + cd = sc->func->toParent()->isClassDeclaration(); + if (!cd || !cd->baseClass || !sc->func->isCtorDeclaration()) + { + error("super class constructor call must be in a constructor"); + return new ErrorExp(); + } + else + { + if (!cd->baseClass->ctor) + { error("no super class constructor for %s", cd->baseClass->toChars()); + return new ErrorExp(); + } + else + { + if (!sc->intypeof) + { +#if 0 + if (sc->callSuper & (CSXthis | CSXsuper)) + error("reference to this before super()"); +#endif + if (sc->noctor || sc->callSuper & CSXlabel) + error("constructor calls not allowed in loops or after labels"); + if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) + error("multiple constructor calls"); + sc->callSuper |= CSXany_ctor | CSXsuper_ctor; + } + + f = resolveFuncCall(sc, loc, cd->baseClass->ctor, NULL, NULL, arguments, 0); + accessCheck(loc, sc, NULL, f); + checkDeprecated(sc, f); +#if DMDV2 + checkPurity(sc, f); + checkSafety(sc, f); +#endif + e1 = new DotVarExp(e1->loc, e1, f); + e1 = e1->semantic(sc); + t1 = e1->type; + } + } + } + else if (e1->op == TOKthis) + { + // same class constructor call + AggregateDeclaration *cd = NULL; + + if (sc->func) + cd = sc->func->toParent()->isAggregateDeclaration(); + if (!cd || !sc->func->isCtorDeclaration()) + { + error("constructor call must be in a constructor"); + return new ErrorExp(); + } + else + { + if (!sc->intypeof) + { +#if 0 + if (sc->callSuper & (CSXthis | CSXsuper)) + error("reference to this before super()"); +#endif + if (sc->noctor || sc->callSuper & CSXlabel) + error("constructor calls not allowed in loops or after labels"); + if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) + error("multiple constructor calls"); + sc->callSuper |= CSXany_ctor | CSXthis_ctor; + } + + f = resolveFuncCall(sc, loc, cd->ctor, NULL, NULL, arguments, 0); + checkDeprecated(sc, f); +#if DMDV2 + checkPurity(sc, f); + checkSafety(sc, f); +#endif + e1 = new DotVarExp(e1->loc, e1, f); + e1 = e1->semantic(sc); + t1 = e1->type; + + // BUG: this should really be done by checking the static + // call graph + if (f == sc->func) + { error("cyclic constructor call"); + return new ErrorExp(); + } + } + } + else if (e1->op == TOKoverloadset) + { + OverExp *eo = (OverExp *)e1; + FuncDeclaration *f = NULL; + Dsymbol *s = NULL; + for (size_t i = 0; i < eo->vars->a.dim; i++) + { s = eo->vars->a.tdata()[i]; + FuncDeclaration *f2 = s->isFuncDeclaration(); + if (f2) + { + f2 = f2->overloadResolve(loc, ethis, arguments, 1); + } + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + assert(td); + f2 = td->deduceFunctionTemplate(sc, loc, targsi, ethis, arguments, 1); + } + if (f2) + { if (f) + /* Error if match in more than one overload set, + * even if one is a 'better' match than the other. + */ + ScopeDsymbol::multiplyDefined(loc, f, f2); + else + f = f2; + } + } + if (!f) + { /* No overload matches + */ + error("no overload matches for %s", s->toChars()); + return new ErrorExp(); + } + if (ethis) + e1 = new DotVarExp(loc, ethis, f); + else + e1 = new VarExp(loc, f); + goto Lagain; + } + else if (!t1) + { + error("function expected before (), not '%s'", e1->toChars()); + return new ErrorExp(); + } + else if (t1->ty != Tfunction) + { + if (t1->ty == Tdelegate) + { TypeDelegate *td = (TypeDelegate *)t1; + assert(td->next->ty == Tfunction); + tf = (TypeFunction *)(td->next); + if (sc->func && !tf->purity && !(sc->flags & SCOPEdebug)) + { + if (sc->func->setImpure()) + error("pure function '%s' cannot call impure delegate '%s'", sc->func->toChars(), e1->toChars()); + } + if (sc->func && tf->trust <= TRUSTsystem) + { + if (sc->func->setUnsafe()) + error("safe function '%s' cannot call system delegate '%s'", sc->func->toChars(), e1->toChars()); + } + goto Lcheckargs; + } + else if (t1->ty == Tpointer && ((TypePointer *)t1)->next->ty == Tfunction) + { + Expression *e = new PtrExp(loc, e1); + t1 = ((TypePointer *)t1)->next; + if (sc->func && !((TypeFunction *)t1)->purity && !(sc->flags & SCOPEdebug)) + { + if (sc->func->setImpure()) + error("pure function '%s' cannot call impure function pointer '%s'", sc->func->toChars(), e1->toChars()); + } + if (sc->func && ((TypeFunction *)t1)->trust <= TRUSTsystem) + { + if (sc->func->setUnsafe()) + error("safe function '%s' cannot call system function pointer '%s'", sc->func->toChars(), e1->toChars()); + } + e->type = t1; + e1 = e; + } + else if (e1->op == TOKtemplate) + { + TemplateExp *te = (TemplateExp *)e1; + f = te->td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); + if (!f) + { if (tierror) + tierror->error("errors instantiating template"); // give better error message + return new ErrorExp(); + } + if (f->needThis() && hasThis(sc)) + { + // Supply an implicit 'this', as in + // this.ident + + e1 = new DotTemplateExp(loc, (new ThisExp(loc))->semantic(sc), te->td); + goto Lagain; + } + + e1 = new VarExp(loc, f); + goto Lagain; + } + else + { error("function expected before (), not %s of type %s", e1->toChars(), e1->type->toChars()); + return new ErrorExp(); + } + } + else if (e1->op == TOKvar) + { + // Do overload resolution + VarExp *ve = (VarExp *)e1; + + f = ve->var->isFuncDeclaration(); + assert(f); + + if (ve->hasOverloads) + f = f->overloadResolve(loc, NULL, arguments); + checkDeprecated(sc, f); +#if DMDV2 + checkPurity(sc, f); + checkSafety(sc, f); +#endif + f->checkNestedReference(sc, loc); + + if (f->needThis() && hasThis(sc)) + { + // Supply an implicit 'this', as in + // this.ident + + e1 = new DotVarExp(loc, new ThisExp(loc), f); + goto Lagain; + } + + accessCheck(loc, sc, NULL, f); + + ethis = NULL; + + ve->var = f; +// ve->hasOverloads = 0; + ve->type = f->type; + t1 = f->type; + } + assert(t1->ty == Tfunction); + tf = (TypeFunction *)(t1); + +Lcheckargs: + assert(tf->ty == Tfunction); + + if (!arguments) + arguments = new Expressions(); + int olderrors = global.errors; + type = functionParameters(loc, sc, tf, ethis, arguments, f); + if (olderrors != global.errors) + return new ErrorExp(); + + if (!type) + { + error("forward reference to inferred return type of function call %s", toChars()); + return new ErrorExp(); + } + + if (f && f->tintro) + { + Type *t = type; + int offset = 0; + TypeFunction *tf = (TypeFunction *)f->tintro; + + if (tf->next->isBaseOf(t, &offset) && offset) + { + type = tf->next; + return castTo(sc, t); + } + } + + return this; +} + + +#if DMDV2 +int CallExp::isLvalue() +{ +// if (type->toBasetype()->ty == Tstruct) +// return 1; + Type *tb = e1->type->toBasetype(); + if (tb->ty == Tfunction && ((TypeFunction *)tb)->isref) + return 1; // function returns a reference + return 0; +} +#endif + +Expression *CallExp::toLvalue(Scope *sc, Expression *e) +{ + if (isLvalue()) + return this; + return Expression::toLvalue(sc, e); +} + +Expression *CallExp::addDtorHook(Scope *sc) +{ + /* Only need to add dtor hook if it's a type that needs destruction. + * Use same logic as VarDeclaration::callScopeDtor() + */ + + if (e1->type && e1->type->ty == Tfunction) + { + TypeFunction *tf = (TypeFunction *)e1->type; + if (tf->isref) + return this; + } + + Type *tv = type->toBasetype(); + while (tv->ty == Tsarray) + { TypeSArray *ta = (TypeSArray *)tv; + tv = tv->nextOf()->toBasetype(); + } + if (tv->ty == Tstruct) + { TypeStruct *ts = (TypeStruct *)tv; + StructDeclaration *sd = ts->sym; + if (sd->dtor) + { /* Type needs destruction, so declare a tmp + * which the back end will recognize and call dtor on + */ + Identifier *idtmp = Lexer::uniqueId("__tmpfordtor"); + VarDeclaration *tmp = new VarDeclaration(loc, type, idtmp, new ExpInitializer(loc, this)); + tmp->storage_class |= STCctfe; + Expression *ae = new DeclarationExp(loc, tmp); + Expression *e = new CommaExp(loc, ae, new VarExp(loc, tmp)); + e = e->semantic(sc); + return e; + } + } +Lnone: + return this; +} + +void CallExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (e1->op == TOKtype) + /* Avoid parens around type to prevent forbidden cast syntax: + * (sometype)(arg1) + * This is ok since types in constructor calls + * can never depend on parens anyway + */ + e1->toCBuffer(buf, hgs); + else + expToCBuffer(buf, hgs, e1, precedence[op]); + buf->writeByte('('); + argsToCBuffer(buf, arguments, hgs); + buf->writeByte(')'); +} + + +/************************************************************/ + +AddrExp::AddrExp(Loc loc, Expression *e) + : UnaExp(loc, TOKaddress, sizeof(AddrExp), e) +{ +} + +Expression *AddrExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("AddrExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + UnaExp::semantic(sc); + if (e1->type == Type::terror) + return new ErrorExp(); + e1 = e1->toLvalue(sc, NULL); + if (e1->op == TOKerror) + return e1; + if (!e1->type) + { + error("cannot take address of %s", e1->toChars()); + return new ErrorExp(); + } + if (!e1->type->deco) + { + /* No deco means semantic() was not run on the type. + * We have to run semantic() on the symbol to get the right type: + * auto x = &bar; + * pure: int bar() { return 1;} + * otherwise the 'pure' is missing from the type assigned to x. + */ + + error("forward reference to %s", e1->toChars()); + return new ErrorExp(); + } + + type = e1->type->pointerTo(); + + // See if this should really be a delegate + if (e1->op == TOKdotvar) + { + DotVarExp *dve = (DotVarExp *)e1; + FuncDeclaration *f = dve->var->isFuncDeclaration(); + + if (f) + { + if (!dve->hasOverloads) + f->tookAddressOf++; + Expression *e = new DelegateExp(loc, dve->e1, f, dve->hasOverloads); + e = e->semantic(sc); + return e; + } + } + else if (e1->op == TOKvar) + { + VarExp *ve = (VarExp *)e1; + + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v) + { + if (!v->canTakeAddressOf()) + { error("cannot take address of %s", e1->toChars()); + return new ErrorExp(); + } + + if (sc->func && !sc->intypeof && !v->isDataseg()) + { + if (sc->func->setUnsafe()) + { + error("cannot take address of %s %s in @safe function %s", + v->isParameter() ? "parameter" : "local", + v->toChars(), + sc->func->toChars()); + } + } + } + + FuncDeclaration *f = ve->var->isFuncDeclaration(); + + if (f) + { + if (!ve->hasOverloads || + /* Because nested functions cannot be overloaded, + * mark here that we took its address because castTo() + * may not be called with an exact match. + */ + f->toParent2()->isFuncDeclaration()) + f->tookAddressOf++; + if (f->isNested()) + { + Expression *e = new DelegateExp(loc, e1, f, ve->hasOverloads); + e = e->semantic(sc); + return e; + } + if (f->needThis() && hasThis(sc)) + { + /* Should probably supply 'this' after overload resolution, + * not before. + */ + Expression *ethis = new ThisExp(loc); + Expression *e = new DelegateExp(loc, ethis, f, ve->hasOverloads); + e = e->semantic(sc); + return e; + } + } + } + return optimize(WANTvalue); + } + return this; +} + +void AddrExp::checkEscape() +{ + e1->checkEscapeRef(); +} + +/************************************************************/ + +PtrExp::PtrExp(Loc loc, Expression *e) + : UnaExp(loc, TOKstar, sizeof(PtrExp), e) +{ +// if (e->type) +// type = ((TypePointer *)e->type)->next; +} + +PtrExp::PtrExp(Loc loc, Expression *e, Type *t) + : UnaExp(loc, TOKstar, sizeof(PtrExp), e) +{ + type = t; +} + +Expression *PtrExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("PtrExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + Expression *e = op_overload(sc); + if (e) + return e; + Type *tb = e1->type->toBasetype(); + switch (tb->ty) + { + case Tpointer: + type = ((TypePointer *)tb)->next; + break; + + case Tsarray: + case Tarray: + if (!global.params.useDeprecated) + error("using * on an array is deprecated; use *(%s).ptr instead", e1->toChars()); + type = ((TypeArray *)tb)->next; + e1 = e1->castTo(sc, type->pointerTo()); + break; + + default: + error("can only * a pointer, not a '%s'", e1->type->toChars()); + case Terror: + return new ErrorExp(); + } + if (!rvalue()) + return new ErrorExp(); + } + return this; +} + +#if DMDV2 +int PtrExp::isLvalue() +{ + return 1; +} +#endif + +void PtrExp::checkEscapeRef() +{ + e1->checkEscape(); +} + +Expression *PtrExp::toLvalue(Scope *sc, Expression *e) +{ +#if 0 + tym = tybasic(e1->ET->Tty); + if (!(tyscalar(tym) || + tym == TYstruct || + tym == TYarray && e->Eoper == TOKaddr)) + synerr(EM_lvalue); // lvalue expected +#endif + return this; +} + +#if DMDV2 +Expression *PtrExp::modifiableLvalue(Scope *sc, Expression *e) +{ + //printf("PtrExp::modifiableLvalue() %s, type %s\n", toChars(), type->toChars()); + + if (e1->op == TOKsymoff) + { SymOffExp *se = (SymOffExp *)e1; + se->var->checkModify(loc, sc, type); + //return toLvalue(sc, e); + } + + return Expression::modifiableLvalue(sc, e); +} +#endif + +void PtrExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('*'); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + +/************************************************************/ + +NegExp::NegExp(Loc loc, Expression *e) + : UnaExp(loc, TOKneg, sizeof(NegExp), e) +{ +} + +Expression *NegExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("NegExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + e = op_overload(sc); + if (e) + return e; + + e1->checkNoBool(); + if (!e1->isArrayOperand()) + e1->checkArithmetic(); + type = e1->type; + } + return this; +} + +/************************************************************/ + +UAddExp::UAddExp(Loc loc, Expression *e) + : UnaExp(loc, TOKuadd, sizeof(UAddExp), e) +{ +} + +Expression *UAddExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("UAddExp::semantic('%s')\n", toChars()); +#endif + assert(!type); + e = op_overload(sc); + if (e) + return e; + e1->checkNoBool(); + e1->checkArithmetic(); + return e1; +} + +/************************************************************/ + +ComExp::ComExp(Loc loc, Expression *e) + : UnaExp(loc, TOKtilde, sizeof(ComExp), e) +{ +} + +Expression *ComExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { + e = op_overload(sc); + if (e) + return e; + + e1->checkNoBool(); + if (!e1->isArrayOperand()) + e1 = e1->checkIntegral(); + type = e1->type; + } + return this; +} + +/************************************************************/ + +NotExp::NotExp(Loc loc, Expression *e) + : UnaExp(loc, TOKnot, sizeof(NotExp), e) +{ +} + +Expression *NotExp::semantic(Scope *sc) +{ + if (!type) + { // Note there is no operator overload + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->checkToBoolean(sc); + type = Type::tboolean; + } + return this; +} + +int NotExp::isBit() +{ + return TRUE; +} + + + +/************************************************************/ + +BoolExp::BoolExp(Loc loc, Expression *e, Type *t) + : UnaExp(loc, TOKtobool, sizeof(BoolExp), e) +{ + type = t; +} + +Expression *BoolExp::semantic(Scope *sc) +{ + if (!type) + { // Note there is no operator overload + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->checkToBoolean(sc); + type = Type::tboolean; + } + return this; +} + +int BoolExp::isBit() +{ + return TRUE; +} + +/************************************************************/ + +DeleteExp::DeleteExp(Loc loc, Expression *e) + : UnaExp(loc, TOKdelete, sizeof(DeleteExp), e) +{ +} + +Expression *DeleteExp::semantic(Scope *sc) +{ + Type *tb; + + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->modifiableLvalue(sc, NULL); + if (e1->op == TOKerror) + return e1; + type = Type::tvoid; + + tb = e1->type->toBasetype(); + switch (tb->ty) + { case Tclass: + { TypeClass *tc = (TypeClass *)tb; + ClassDeclaration *cd = tc->sym; + + if (cd->isCOMinterface()) + { /* Because COM classes are deleted by IUnknown.Release() + */ + error("cannot delete instance of COM interface %s", cd->toChars()); + } + break; + } + case Tpointer: + tb = ((TypePointer *)tb)->next->toBasetype(); + if (tb->ty == Tstruct) + { + TypeStruct *ts = (TypeStruct *)tb; + StructDeclaration *sd = ts->sym; + FuncDeclaration *f = sd->aggDelete; + FuncDeclaration *fd = sd->dtor; + + if (!f && !fd) + break; + + /* Construct: + * ea = copy e1 to a tmp to do side effects only once + * eb = call destructor + * ec = call deallocator + */ + Expression *ea = NULL; + Expression *eb = NULL; + Expression *ec = NULL; + VarDeclaration *v; + + if (fd && f) + { Identifier *id = Lexer::idPool("__tmp"); + v = new VarDeclaration(loc, e1->type, id, new ExpInitializer(loc, e1)); + v->semantic(sc); + v->parent = sc->parent; + ea = new DeclarationExp(loc, v); + ea->type = v->type; + } + + if (fd) + { Expression *e = ea ? new VarExp(loc, v) : e1; + e = new DotVarExp(0, e, fd, 0); + eb = new CallExp(loc, e); + eb = eb->semantic(sc); + } + + if (f) + { + Type *tpv = Type::tvoid->pointerTo(); + Expression *e = ea ? new VarExp(loc, v) : e1->castTo(sc, tpv); + e = new CallExp(loc, new VarExp(loc, f), e); + ec = e->semantic(sc); + } + ea = combine(ea, eb); + ea = combine(ea, ec); + assert(ea); + return ea; + } + break; + + case Tarray: + /* BUG: look for deleting arrays of structs with dtors. + */ + break; + + default: + if (e1->op == TOKindex) + { + IndexExp *ae = (IndexExp *)(e1); + Type *tb1 = ae->e1->type->toBasetype(); + if (tb1->ty == Taarray) + break; + } + error("cannot delete type %s", e1->type->toChars()); + return new ErrorExp(); + } + + if (e1->op == TOKindex) + { + IndexExp *ae = (IndexExp *)(e1); + Type *tb1 = ae->e1->type->toBasetype(); + if (tb1->ty == Taarray) + { if (!global.params.useDeprecated) + error("delete aa[key] deprecated, use aa.remove(key)"); + } + } + + return this; +} + + +Expression *DeleteExp::checkToBoolean(Scope *sc) +{ + error("delete does not give a boolean result"); + return new ErrorExp(); +} + +void DeleteExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("delete "); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + +/************************************************************/ + +CastExp::CastExp(Loc loc, Expression *e, Type *t) + : UnaExp(loc, TOKcast, sizeof(CastExp), e) +{ + to = t; + this->mod = ~0; +} + +#if DMDV2 +/* For cast(const) and cast(immutable) + */ +CastExp::CastExp(Loc loc, Expression *e, unsigned mod) + : UnaExp(loc, TOKcast, sizeof(CastExp), e) +{ + to = NULL; + this->mod = mod; +} +#endif + +Expression *CastExp::syntaxCopy() +{ + return to ? new CastExp(loc, e1->syntaxCopy(), to->syntaxCopy()) + : new CastExp(loc, e1->syntaxCopy(), mod); +} + + +Expression *CastExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("CastExp::semantic('%s')\n", toChars()); +#endif + +//static int x; assert(++x < 10); + + if (type) + return this; + UnaExp::semantic(sc); + if (e1->type) // if not a tuple + { + e1 = resolveProperties(sc, e1); + + if (!to) + { + /* Handle cast(const) and cast(immutable), etc. + */ + to = e1->type->castMod(mod); + } + else + to = to->semantic(loc, sc); + + if (!to->equals(e1->type)) + { +#if 0 // attempt at fixing 6720 + if (e1->type->ty == Tvoid) + { + error("cannot cast from void to %s", to->toChars()); + return new ErrorExp(); + } +#endif + Expression *e = op_overload(sc); + if (e) + { + return e->implicitCastTo(sc, to); + } + } + + if (e1->op == TOKtemplate) + { + error("cannot cast template %s to type %s", e1->toChars(), to->toChars()); + return new ErrorExp(); + } + + Type *t1b = e1->type->toBasetype(); + Type *tob = to->toBasetype(); + + if (e1->op == TOKfunction && + (tob->ty == Tdelegate || tob->ty == Tpointer && tob->nextOf()->ty == Tfunction)) + { + FuncExp *fe = (FuncExp *)e1; + Expression *e = NULL; + if (e1->type == Type::tvoid) + { + e = fe->inferType(sc, tob); + } + else if (e1->type->ty == Tpointer && e1->type->nextOf()->ty == Tfunction && + fe->tok == TOKreserved && + tob->ty == Tdelegate) + { + if (fe->implicitConvTo(tob)) + e = fe->castTo(sc, tob); + } + if (e) + e1 = e->semantic(sc); + } + + if (tob->ty == Tstruct && + !tob->equals(t1b) + ) + { + /* Look to replace: + * cast(S)t + * with: + * S(t) + */ + + // Rewrite as to.call(e1) + Expression *e = new TypeExp(loc, to); + e = new CallExp(loc, e, e1); + e = e->trySemantic(sc); + if (e) + return e; + } + + // Struct casts are possible only when the sizes match + // Same with static array -> static array + if (tob->ty == Tstruct || t1b->ty == Tstruct || + (tob->ty == Tsarray && t1b->ty == Tsarray)) + { + size_t fromsize = t1b->size(loc); + size_t tosize = tob->size(loc); + if (fromsize != tosize) + { + error("cannot cast from %s to %s", e1->type->toChars(), to->toChars()); + return new ErrorExp(); + } + } + + // Look for casting to a vector type + if (tob->ty == Tvector && t1b->ty != Tvector) + { + return new VectorExp(loc, e1, to); + } + } + else if (!to) + { error("cannot cast tuple"); + return new ErrorExp(); + } + + if (!e1->type) + { error("cannot cast %s", e1->toChars()); + return new ErrorExp(); + } + + // Check for unsafe casts + if (sc->func && !sc->intypeof) + { // Disallow unsafe casts + Type *tob = to->toBasetype(); + Type *t1b = e1->type->toBasetype(); + + // Implicit conversions are always safe + if (t1b->implicitConvTo(tob)) + goto Lsafe; + + if (!t1b->isMutable() && tob->isMutable()) + goto Lunsafe; + + if (t1b->isShared() && !tob->isShared()) + // Cast away shared + goto Lunsafe; + + if (!tob->hasPointers()) + goto Lsafe; + + if (tob->ty == Tclass && t1b->ty == Tclass) + { + ClassDeclaration *cdfrom = t1b->isClassHandle(); + ClassDeclaration *cdto = tob->isClassHandle(); + + int offset; + if (!cdfrom->isBaseOf(cdto, &offset)) + goto Lunsafe; + + if (cdfrom->isCPPinterface() || + cdto->isCPPinterface()) + goto Lunsafe; + + goto Lsafe; + } + + if (tob->ty == Tarray && t1b->ty == Tarray) + { + Type* tobn = tob->nextOf()->toBasetype(); + Type* t1bn = t1b->nextOf()->toBasetype(); + if (!tobn->hasPointers() && MODimplicitConv(t1bn->mod, tobn->mod)) + goto Lsafe; + } + if (tob->ty == Tpointer && t1b->ty == Tpointer) + { + Type* tobn = tob->nextOf()->toBasetype(); + Type* t1bn = t1b->nextOf()->toBasetype(); + if (!tobn->hasPointers() && + tobn->ty != Tfunction && t1bn->ty != Tfunction && + tobn->size() <= t1bn->size() && + MODimplicitConv(t1bn->mod, tobn->mod)) + goto Lsafe; + } + + Lunsafe: + if (sc->func->setUnsafe()) + { error("cast from %s to %s not allowed in safe code", e1->type->toChars(), to->toChars()); + return new ErrorExp(); + } + } + +Lsafe: + Expression *e = e1->castTo(sc, to); + return e; +} + + +void CastExp::checkEscape() +{ Type *tb = type->toBasetype(); + if (tb->ty == Tarray && e1->op == TOKvar && + e1->type->toBasetype()->ty == Tsarray) + { VarExp *ve = (VarExp *)e1; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v) + { + if (!v->isDataseg() && !v->isParameter()) + error("escaping reference to local %s", v->toChars()); + } + } +} + +void CastExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("cast("); +#if DMDV1 + to->toCBuffer(buf, NULL, hgs); +#else + if (to) + to->toCBuffer(buf, NULL, hgs); + else + { + MODtoBuffer(buf, mod); + } +#endif + buf->writeByte(')'); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + + +/************************************************************/ + +VectorExp::VectorExp(Loc loc, Expression *e, Type *t) + : UnaExp(loc, TOKvector, sizeof(VectorExp), e) +{ + assert(t->ty == Tvector); + to = t; + dim = ~0; +} + +Expression *VectorExp::syntaxCopy() +{ + return new VectorExp(loc, e1->syntaxCopy(), to->syntaxCopy()); +} + +Expression *VectorExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("VectorExp::semantic('%s')\n", toChars()); +#endif + + if (type) + return this; + e1 = e1->semantic(sc); + type = to->semantic(loc, sc); + if (e1->op == TOKerror || type->ty == Terror) + return e1; + Type *tb = type->toBasetype(); + assert(tb->ty == Tvector); + TypeVector *tv = (TypeVector *)tb; + Type *te = tv->elementType(); + dim = tv->size(loc) / te->size(loc); + return this; +} + +void VectorExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("cast("); + to->toCBuffer(buf, NULL, hgs); + buf->writeByte(')'); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + +/************************************************************/ + +SliceExp::SliceExp(Loc loc, Expression *e1, Expression *lwr, Expression *upr) + : UnaExp(loc, TOKslice, sizeof(SliceExp), e1) +{ + this->upr = upr; + this->lwr = lwr; + lengthVar = NULL; +} + +Expression *SliceExp::syntaxCopy() +{ + Expression *lwr = NULL; + if (this->lwr) + lwr = this->lwr->syntaxCopy(); + + Expression *upr = NULL; + if (this->upr) + upr = this->upr->syntaxCopy(); + + return new SliceExp(loc, e1->syntaxCopy(), lwr, upr); +} + +Expression *SliceExp::semantic(Scope *sc) +{ Expression *e; + AggregateDeclaration *ad; + //FuncDeclaration *fd; + ScopeDsymbol *sym; + +#if LOGSEMANTIC + printf("SliceExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + +Lagain: + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + + e = this; + + Type *t = e1->type->toBasetype(); + if (t->ty == Tpointer) + { + if (!lwr || !upr) + { error("need upper and lower bound to slice pointer"); + return new ErrorExp(); + } + } + else if (t->ty == Tarray) + { + } + else if (t->ty == Tsarray) + { + } + else if (t->ty == Tclass) + { + ad = ((TypeClass *)t)->sym; + goto L1; + } + else if (t->ty == Tstruct) + { + ad = ((TypeStruct *)t)->sym; + + L1: + if (search_function(ad, Id::slice)) + { + // Rewrite as e1.slice(lwr, upr) + e = new DotIdExp(loc, e1, Id::slice); + + if (lwr) + { + assert(upr); + e = new CallExp(loc, e, lwr, upr); + } + else + { assert(!upr); + e = new CallExp(loc, e); + } + e = e->semantic(sc); + return e; + } + if (ad->aliasthis) + { + e1 = new DotIdExp(e1->loc, e1, ad->aliasthis->ident); + goto Lagain; + } + goto Lerror; + } + else if (t->ty == Ttuple) + { + if (!lwr && !upr) + return e1; + if (!lwr || !upr) + { error("need upper and lower bound to slice tuple"); + goto Lerror; + } + } + else if (t == Type::terror) + goto Lerr; + else + goto Lerror; + + { + Scope *sc2 = sc; + if (t->ty == Tsarray || t->ty == Tarray || t->ty == Ttuple) + { + sym = new ArrayScopeSymbol(sc, this); + sym->loc = loc; + sym->parent = sc->scopesym; + sc2 = sc->push(sym); + } + + if (lwr) + { lwr = lwr->semantic(sc2); + lwr = resolveProperties(sc2, lwr); + lwr = lwr->implicitCastTo(sc2, Type::tsize_t); + if (lwr->type == Type::terror) + goto Lerr; + } + if (upr) + { upr = upr->semantic(sc2); + upr = resolveProperties(sc2, upr); + upr = upr->implicitCastTo(sc2, Type::tsize_t); + if (upr->type == Type::terror) + goto Lerr; + } + + if (sc2 != sc) + sc2->pop(); + } + + if (t->ty == Ttuple) + { + lwr = lwr->optimize(WANTvalue | WANTinterpret); + upr = upr->optimize(WANTvalue | WANTinterpret); + uinteger_t i1 = lwr->toUInteger(); + uinteger_t i2 = upr->toUInteger(); + + size_t length; + TupleExp *te; + TypeTuple *tup; + + if (e1->op == TOKtuple) // slicing an expression tuple + { te = (TupleExp *)e1; + length = te->exps->dim; + } + else if (e1->op == TOKtype) // slicing a type tuple + { tup = (TypeTuple *)t; + length = Parameter::dim(tup->arguments); + } + else + assert(0); + + if (i1 <= i2 && i2 <= length) + { size_t j1 = (size_t) i1; + size_t j2 = (size_t) i2; + + if (e1->op == TOKtuple) + { Expressions *exps = new Expressions; + exps->setDim(j2 - j1); + for (size_t i = 0; i < j2 - j1; i++) + { Expression *e = (*te->exps)[j1 + i]; + (*exps)[i] = e; + } + if (j1 > 0 && j2 - j1 > 0 && sc->func && (*te->exps)[0]->op == TOKdotvar) + { + Expression *einit = ((DotVarExp *)(*te->exps)[0])->e1->isTemp(); + if (einit) + ((DotVarExp *)(*exps)[0])->e1 = einit; + } + e = new TupleExp(loc, exps); + } + else + { Parameters *args = new Parameters; + args->reserve(j2 - j1); + for (size_t i = j1; i < j2; i++) + { Parameter *arg = Parameter::getNth(tup->arguments, i); + args->push(arg); + } + e = new TypeExp(e1->loc, new TypeTuple(args)); + } + e = e->semantic(sc); + } + else + { + error("string slice [%ju .. %ju] is out of bounds", i1, i2); + goto Lerr; + } + return e; + } + + type = t->nextOf()->arrayOf(); + // Allow typedef[] -> typedef[] + if (type->equals(t)) + type = e1->type; + + return e; + +Lerror: + if (e1->op == TOKerror) + return e1; + char *s; + if (t->ty == Tvoid) + s = e1->toChars(); + else + s = t->toChars(); + error("%s cannot be sliced with []", s); +Lerr: + e = new ErrorExp(); + return e; +} + +void SliceExp::checkEscape() +{ + e1->checkEscape(); +} + +void SliceExp::checkEscapeRef() +{ + e1->checkEscapeRef(); +} + +#if DMDV2 +int SliceExp::isLvalue() +{ + return 1; +} +#endif + +Expression *SliceExp::toLvalue(Scope *sc, Expression *e) +{ + return this; +} + +Expression *SliceExp::modifiableLvalue(Scope *sc, Expression *e) +{ + error("slice expression %s is not a modifiable lvalue", toChars()); + return this; +} + +int SliceExp::isBool(int result) +{ + return e1->isBool(result); +} + +void SliceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, precedence[op]); + buf->writeByte('['); + if (upr || lwr) + { + if (lwr) + expToCBuffer(buf, hgs, lwr, PREC_assign); + else + buf->writeByte('0'); + buf->writestring(".."); + if (upr) + expToCBuffer(buf, hgs, upr, PREC_assign); + else + buf->writestring("length"); // BUG: should be array.length + } + buf->writeByte(']'); +} + +/********************** ArrayLength **************************************/ + +ArrayLengthExp::ArrayLengthExp(Loc loc, Expression *e1) + : UnaExp(loc, TOKarraylength, sizeof(ArrayLengthExp), e1) +{ +} + +Expression *ArrayLengthExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("ArrayLengthExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + + type = Type::tsize_t; + } + return this; +} + +Expression *opAssignToOp(Loc loc, enum TOK op, Expression *e1, Expression *e2) +{ Expression *e; + + switch (op) + { + case TOKaddass: e = new AddExp(loc, e1, e2); break; + case TOKminass: e = new MinExp(loc, e1, e2); break; + case TOKmulass: e = new MulExp(loc, e1, e2); break; + case TOKdivass: e = new DivExp(loc, e1, e2); break; + case TOKmodass: e = new ModExp(loc, e1, e2); break; + case TOKandass: e = new AndExp(loc, e1, e2); break; + case TOKorass: e = new OrExp (loc, e1, e2); break; + case TOKxorass: e = new XorExp(loc, e1, e2); break; + case TOKshlass: e = new ShlExp(loc, e1, e2); break; + case TOKshrass: e = new ShrExp(loc, e1, e2); break; + case TOKushrass: e = new UshrExp(loc, e1, e2); break; + default: assert(0); + } + return e; +} + +/********************* + * Rewrite: + * array.length op= e2 + * as: + * array.length = array.length op e2 + * or: + * auto tmp = &array; + * (*tmp).length = (*tmp).length op e2 + */ + +Expression *ArrayLengthExp::rewriteOpAssign(BinExp *exp) +{ Expression *e; + + assert(exp->e1->op == TOKarraylength); + ArrayLengthExp *ale = (ArrayLengthExp *)exp->e1; + if (ale->e1->op == TOKvar) + { e = opAssignToOp(exp->loc, exp->op, ale, exp->e2); + e = new AssignExp(exp->loc, ale->syntaxCopy(), e); + } + else + { + /* auto tmp = &array; + * (*tmp).length = (*tmp).length op e2 + */ + Identifier *id = Lexer::uniqueId("__arraylength"); + ExpInitializer *ei = new ExpInitializer(ale->loc, new AddrExp(ale->loc, ale->e1)); + VarDeclaration *tmp = new VarDeclaration(ale->loc, ale->e1->type->pointerTo(), id, ei); + + Expression *e1 = new ArrayLengthExp(ale->loc, new PtrExp(ale->loc, new VarExp(ale->loc, tmp))); + Expression *elvalue = e1->syntaxCopy(); + e = opAssignToOp(exp->loc, exp->op, e1, exp->e2); + e = new AssignExp(exp->loc, elvalue, e); + e = new CommaExp(exp->loc, new DeclarationExp(ale->loc, tmp), e); + } + return e; +} + +void ArrayLengthExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writestring(".length"); +} + +/*********************** ArrayExp *************************************/ + +// e1 [ i1, i2, i3, ... ] + +ArrayExp::ArrayExp(Loc loc, Expression *e1, Expressions *args) + : UnaExp(loc, TOKarray, sizeof(ArrayExp), e1) +{ + arguments = args; + lengthVar = NULL; + currentDimension = 0; +} + +Expression *ArrayExp::syntaxCopy() +{ + return new ArrayExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); +} + +Expression *ArrayExp::semantic(Scope *sc) +{ Expression *e; + Type *t1; + +#if LOGSEMANTIC + printf("ArrayExp::semantic('%s')\n", toChars()); +#endif + UnaExp::semantic(sc); + e1 = resolveProperties(sc, e1); + + t1 = e1->type->toBasetype(); + if (t1->ty != Tclass && t1->ty != Tstruct) + { // Convert to IndexExp + if (arguments->dim != 1) + { error("only one index allowed to index %s", t1->toChars()); + goto Lerr; + } + e = new IndexExp(loc, e1, arguments->tdata()[0]); + return e->semantic(sc); + } + + e = op_overload(sc); + if (!e) + { error("no [] operator overload for type %s", e1->type->toChars()); + goto Lerr; + } + return e; + +Lerr: + return new ErrorExp(); +} + +#if DMDV2 +int ArrayExp::isLvalue() +{ + if (type && type->toBasetype()->ty == Tvoid) + return 0; + return 1; +} +#endif + +Expression *ArrayExp::toLvalue(Scope *sc, Expression *e) +{ + if (type && type->toBasetype()->ty == Tvoid) + error("voids have no value"); + return this; +} + + +void ArrayExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('['); + argsToCBuffer(buf, arguments, hgs); + buf->writeByte(']'); +} + +/************************* DotExp ***********************************/ + +DotExp::DotExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKdotexp, sizeof(DotExp), e1, e2) +{ +} + +Expression *DotExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("DotExp::semantic('%s')\n", toChars()); + if (type) printf("\ttype = %s\n", type->toChars()); +#endif + e1 = e1->semantic(sc); + e2 = e2->semantic(sc); + if (e2->op == TOKimport) + { + ScopeExp *se = (ScopeExp *)e2; + TemplateDeclaration *td = se->sds->isTemplateDeclaration(); + if (td) + { Expression *e = new DotTemplateExp(loc, e1, td); + e = e->semantic(sc); + return e; + } + } + if (!type) + type = e2->type; + return this; +} + +void DotExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('.'); + expToCBuffer(buf, hgs, e2, PREC_primary); +} + +/************************* CommaExp ***********************************/ + +CommaExp::CommaExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKcomma, sizeof(CommaExp), e1, e2) +{ +} + +Expression *CommaExp::semantic(Scope *sc) +{ + if (!type) + { BinExp::semanticp(sc); + e1 = e1->addDtorHook(sc); + type = e2->type; + } + return this; +} + +void CommaExp::checkEscape() +{ + e2->checkEscape(); +} + +void CommaExp::checkEscapeRef() +{ + e2->checkEscapeRef(); +} + +#if DMDV2 +int CommaExp::isLvalue() +{ + return e2->isLvalue(); +} +#endif + +Expression *CommaExp::toLvalue(Scope *sc, Expression *e) +{ + e2 = e2->toLvalue(sc, NULL); + return this; +} + +Expression *CommaExp::modifiableLvalue(Scope *sc, Expression *e) +{ + e2 = e2->modifiableLvalue(sc, e); + return this; +} + +int CommaExp::isBool(int result) +{ + return e2->isBool(result); +} + + +Expression *CommaExp::addDtorHook(Scope *sc) +{ + e2 = e2->addDtorHook(sc); + return this; +} + +/************************** IndexExp **********************************/ + +// e1 [ e2 ] + +IndexExp::IndexExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKindex, sizeof(IndexExp), e1, e2) +{ + //printf("IndexExp::IndexExp('%s')\n", toChars()); + lengthVar = NULL; + modifiable = 0; // assume it is an rvalue +} + +Expression *IndexExp::semantic(Scope *sc) +{ Expression *e; + Type *t1; + ScopeDsymbol *sym; + +#if LOGSEMANTIC + printf("IndexExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + if (!e1->type) + e1 = e1->semantic(sc); + assert(e1->type); // semantic() should already be run on it + if (e1->op == TOKerror) + goto Lerr; + e = this; + + // Note that unlike C we do not implement the int[ptr] + + t1 = e1->type->toBasetype(); + + if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) + { // Create scope for 'length' variable + sym = new ArrayScopeSymbol(sc, this); + sym->loc = loc; + sym->parent = sc->scopesym; + sc = sc->push(sym); + } + + e2 = e2->semantic(sc); + e2 = resolveProperties(sc, e2); + if (e2->type == Type::terror) + goto Lerr; + if (e2->type->ty == Ttuple && ((TupleExp *)e2)->exps->dim == 1) // bug 4444 fix + e2 = ((TupleExp *)e2)->exps->tdata()[0]; + + if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) + sc = sc->pop(); + + switch (t1->ty) + { + case Tpointer: + case Tarray: + e2 = e2->implicitCastTo(sc, Type::tsize_t); + e->type = ((TypeNext *)t1)->next; + break; + + case Tsarray: + { + e2 = e2->implicitCastTo(sc, Type::tsize_t); + + TypeSArray *tsa = (TypeSArray *)t1; + +#if 0 // Don't do now, because it might be short-circuit evaluated + // Do compile time array bounds checking if possible + e2 = e2->optimize(WANTvalue); + if (e2->op == TOKint64) + { + dinteger_t index = e2->toInteger(); + dinteger_t length = tsa->dim->toInteger(); + if (index < 0 || index >= length) + error("array index [%lld] is outside array bounds [0 .. %lld]", + index, length); + } +#endif + e->type = t1->nextOf(); + break; + } + + case Taarray: + { TypeAArray *taa = (TypeAArray *)t1; + /* We can skip the implicit conversion if they differ only by + * constness (Bugzilla 2684, see also bug 2954b) + */ + if (!arrayTypeCompatibleWithoutCasting(e2->loc, e2->type, taa->index)) + { + e2 = e2->implicitCastTo(sc, taa->index); // type checking + } + type = taa->next; + break; + } + + case Ttuple: + { + e2 = e2->implicitCastTo(sc, Type::tsize_t); + e2 = e2->optimize(WANTvalue | WANTinterpret); + uinteger_t index = e2->toUInteger(); + size_t length; + TupleExp *te; + TypeTuple *tup; + + if (e1->op == TOKtuple) + { te = (TupleExp *)e1; + length = te->exps->dim; + } + else if (e1->op == TOKtype) + { + tup = (TypeTuple *)t1; + length = Parameter::dim(tup->arguments); + } + else + assert(0); + + if (index < length) + { + + if (e1->op == TOKtuple) + { + e = (*te->exps)[(size_t)index]; + if (sc->func && (*te->exps)[0]->op == TOKdotvar) + { + Expression *einit = ((DotVarExp *)(*te->exps)[0])->e1->isTemp(); + if (einit) + ((DotVarExp *)e)->e1 = einit; + } + } + else + e = new TypeExp(e1->loc, Parameter::getNth(tup->arguments, (size_t)index)->type); + } + else + { + error("array index [%ju] is outside array bounds [0 .. %zu]", + index, length); + e = e1; + } + break; + } + + default: + if (e1->op == TOKerror) + goto Lerr; + error("%s must be an array or pointer type, not %s", + e1->toChars(), e1->type->toChars()); + case Terror: + goto Lerr; + } + return e; + +Lerr: + return new ErrorExp(); +} + +#if DMDV2 +int IndexExp::isLvalue() +{ + return 1; +} +#endif + +Expression *IndexExp::toLvalue(Scope *sc, Expression *e) +{ +// if (type && type->toBasetype()->ty == Tvoid) +// error("voids have no value"); + return this; +} + +Expression *IndexExp::modifiableLvalue(Scope *sc, Expression *e) +{ + //printf("IndexExp::modifiableLvalue(%s)\n", toChars()); + modifiable = 1; + if (e1->op == TOKstring) + error("string literals are immutable"); + if (type && (!type->isMutable() || !type->isAssignable())) + error("%s isn't mutable", e->toChars()); + Type *t1 = e1->type->toBasetype(); + if (t1->ty == Taarray) + { TypeAArray *taa = (TypeAArray *)t1; + Type *t2b = e2->type->toBasetype(); + if (t2b->ty == Tarray && t2b->nextOf()->isMutable()) + error("associative arrays can only be assigned values with immutable keys, not %s", e2->type->toChars()); + e1 = e1->modifiableLvalue(sc, e1); + } + return toLvalue(sc, e); +} + +void IndexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writeByte('['); + expToCBuffer(buf, hgs, e2, PREC_assign); + buf->writeByte(']'); +} + + +/************************* PostExp ***********************************/ + +PostExp::PostExp(enum TOK op, Loc loc, Expression *e) + : BinExp(loc, op, sizeof(PostExp), e, + new IntegerExp(loc, 1, Type::tint32)) +{ +} + +Expression *PostExp::semantic(Scope *sc) +{ Expression *e = this; + + if (!type) + { + BinExp::semantic(sc); + e1 = resolveProperties(sc, e1); + + e = op_overload(sc); + if (e) + return e; + + e1 = e1->modifiableLvalue(sc, e1); + + Type *t1 = e1->type->toBasetype(); + if (t1->ty == Tclass || t1->ty == Tstruct) + { /* Check for operator overloading, + * but rewrite in terms of ++e instead of e++ + */ + + /* If e1 is not trivial, take a reference to it + */ + Expression *de = NULL; + if (e1->op != TOKvar) + { + // ref v = e1; + Identifier *id = Lexer::uniqueId("__postref"); + ExpInitializer *ei = new ExpInitializer(loc, e1); + VarDeclaration *v = new VarDeclaration(loc, e1->type, id, ei); + v->storage_class |= STCref | STCforeach; + de = new DeclarationExp(loc, v); + e1 = new VarExp(e1->loc, v); + } + + /* Rewrite as: + * auto tmp = e1; ++e1; tmp + */ + Identifier *id = Lexer::uniqueId("__pitmp"); + ExpInitializer *ei = new ExpInitializer(loc, e1); + VarDeclaration *tmp = new VarDeclaration(loc, e1->type, id, ei); + Expression *ea = new DeclarationExp(loc, tmp); + + Expression *eb = e1->syntaxCopy(); + eb = new PreExp(op == TOKplusplus ? TOKpreplusplus : TOKpreminusminus, loc, eb); + + Expression *ec = new VarExp(loc, tmp); + + // Combine de,ea,eb,ec + if (de) + ea = new CommaExp(loc, de, ea); + e = new CommaExp(loc, ea, eb); + e = new CommaExp(loc, e, ec); + e = e->semantic(sc); + return e; + } + + e = this; + e1->checkScalar(); + e1->checkNoBool(); + if (e1->type->ty == Tpointer) + e = scaleFactor(sc); + else + e2 = e2->castTo(sc, e1->type); + e->type = e1->type; + } + return e; +} + +void PostExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, precedence[op]); + buf->writestring(Token::toChars(op)); +} + +/************************* PreExp ***********************************/ + +PreExp::PreExp(enum TOK op, Loc loc, Expression *e) + : UnaExp(loc, op, sizeof(PreExp), e) +{ +} + +Expression *PreExp::semantic(Scope *sc) +{ + Expression *e; + + e = op_overload(sc); + if (e) + return e; + + // Rewrite as e1+=1 or e1-=1 + if (op == TOKpreplusplus) + e = new AddAssignExp(loc, e1, new IntegerExp(loc, 1, Type::tint32)); + else + e = new MinAssignExp(loc, e1, new IntegerExp(loc, 1, Type::tint32)); + return e->semantic(sc); +} + +void PreExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(op)); + expToCBuffer(buf, hgs, e1, precedence[op]); +} + +/************************************************************/ + +/* op can be TOKassign, TOKconstruct, or TOKblit */ + +AssignExp::AssignExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKassign, sizeof(AssignExp), e1, e2) +{ + ismemset = 0; +} + +Expression *AssignExp::semantic(Scope *sc) +{ + Expression *e1old = e1; + +#if LOGSEMANTIC + printf("AssignExp::semantic('%s')\n", toChars()); +#endif + //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); + //printf("e2->op = %d, '%s'\n", e2->op, Token::toChars(e2->op)); + + if (type) + return this; + + if (e2->op == TOKcomma) + { /* Rewrite to get rid of the comma from rvalue + */ + AssignExp *ea = new AssignExp(loc, e1, ((CommaExp *)e2)->e2); + ea->op = op; + Expression *e = new CommaExp(loc, ((CommaExp *)e2)->e1, ea); + return e->semantic(sc); + } + + /* Look for operator overloading of a[i]=value. + * Do it before semantic() otherwise the a[i] will have been + * converted to a.opIndex() already. + */ + if (e1->op == TOKarray) + { + ArrayExp *ae = (ArrayExp *)e1; + AggregateDeclaration *ad = NULL; + Identifier *id = Id::index; + + ae->e1 = ae->e1->semantic(sc); + Type *t1 = ae->e1->type->toBasetype(); + if (t1->ty == Tstruct) + { + ad = ((TypeStruct *)t1)->sym; + goto L1; + } + else if (t1->ty == Tclass) + { + ad = ((TypeClass *)t1)->sym; + L1: + // Rewrite (a[i] = value) to (a.opIndexAssign(value, i)) + if (search_function(ad, Id::indexass)) + { Expression *e = new DotIdExp(loc, ae->e1, Id::indexass); + // Deal with $ + for (size_t i = 0; i < ae->arguments->dim; i++) + { Expression *x = ae->arguments->tdata()[i]; + // Create scope for '$' variable for this dimension + ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae); + sym->loc = loc; + sym->parent = sc->scopesym; + sc = sc->push(sym); + ae->lengthVar = NULL; // Create it only if required + ae->currentDimension = i; // Dimension for $, if required + + x = x->semantic(sc); + if (!x->type) + ae->error("%s has no value", x->toChars()); + if (ae->lengthVar) + { // If $ was used, declare it now + Expression *av = new DeclarationExp(ae->loc, ae->lengthVar); + x = new CommaExp(0, av, x); + x->semantic(sc); + } + ae->arguments->tdata()[i] = x; + sc = sc->pop(); + } + Expressions *a = (Expressions *)ae->arguments->copy(); + + a->insert(0, e2); + e = new CallExp(loc, e, a); + e = e->semantic(sc); + return e; + } +#if 0 // Turned off to allow rewriting (a[i]=value) to (a.opIndex(i)=value) + else + { + // Rewrite (a[i] = value) to (a.opIndex(i, value)) + if (search_function(ad, id)) + { Expression *e = new DotIdExp(loc, ae->e1, id); + + if (1 || !global.params.useDeprecated) + { error("operator [] assignment overload with opIndex(i, value) illegal, use opIndexAssign(value, i)"); + return new ErrorExp(); + } + + e = new CallExp(loc, e, ae->arguments->tdata()[0], e2); + e = e->semantic(sc); + return e; + } + } +#endif + } + + // No opIndexAssign found yet, but there might be an alias this to try. + if (ad && ad->aliasthis) + { Expression *at = new DotIdExp(loc, ae->e1, ad->aliasthis->ident); + at = at->semantic(sc); + Type *attype = at->type->toBasetype(); + + if (attype->ty == Tstruct) + { + ad = ((TypeStruct *)attype)->sym; + goto L1; + } + else if (attype->ty == Tclass) + { + ad = ((TypeClass *)attype)->sym; + goto L1; + } + } + } + /* Look for operator overloading of a[i..j]=value. + * Do it before semantic() otherwise the a[i..j] will have been + * converted to a.opSlice() already. + */ + if (e1->op == TOKslice) + { Type *t1; + SliceExp *ae = (SliceExp *)e1; + AggregateDeclaration *ad = NULL; + Identifier *id = Id::index; + + ae->e1 = ae->e1->semantic(sc); + ae->e1 = resolveProperties(sc, ae->e1); + t1 = ae->e1->type->toBasetype(); + if (t1->ty == Tstruct) + { + ad = ((TypeStruct *)t1)->sym; + goto L2; + } + else if (t1->ty == Tclass) + { + ad = ((TypeClass *)t1)->sym; + L2: + // Rewrite (a[i..j] = value) to (a.opSliceAssign(value, i, j)) + if (search_function(ad, Id::sliceass)) + { Expression *e = new DotIdExp(loc, ae->e1, Id::sliceass); + Expressions *a = new Expressions(); + + a->push(e2); + if (ae->lwr) + { a->push(ae->lwr); + assert(ae->upr); + a->push(ae->upr); + } + else + assert(!ae->upr); + e = new CallExp(loc, e, a); + e = e->semantic(sc); + return e; + } + } + + // No opSliceAssign found yet, but there might be an alias this to try. + if (ad && ad->aliasthis) + { Expression *at = new DotIdExp(loc, ae->e1, ad->aliasthis->ident); + at = at->semantic(sc); + Type *attype = at->type->toBasetype(); + + if (attype->ty == Tstruct) + { + ad = ((TypeStruct *)attype)->sym; + goto L2; + } + else if (attype->ty == Tclass) + { + ad = ((TypeClass *)attype)->sym; + goto L2; + } + } + } + + { + Expression *e = BinExp::semantic(sc); + if (e->op == TOKerror) + return e; + } + + e2 = resolveProperties(sc, e2); + + /* We have f = value. + * Could mean: + * f(value) + * or: + * f() = value + */ + TemplateDeclaration *td; + Objects *targsi; + FuncDeclaration *fd; + Expression *ethis; + if (e1->op == TOKdotti) + { + DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1; + td = dti->getTempdecl(sc); + dti->ti->semanticTiargs(sc); + targsi = dti->ti->tiargs; + ethis = dti->e1; + goto L3; + } + else if (e1->op == TOKdottd) + { + DotTemplateExp *dte = (DotTemplateExp *)e1; + td = dte->td; + targsi = NULL; + ethis = dte->e1; + goto L3; + } + else if (e1->op == TOKtemplate) + { + td = ((TemplateExp *)e1)->td; + targsi = NULL; + ethis = NULL; + L3: + { + assert(td); + Expressions a; + a.push(e2); + + fd = td->deduceFunctionTemplate(sc, loc, targsi, ethis, &a, 1); + if (fd && fd->type) + goto Lsetter; + + fd = td->deduceFunctionTemplate(sc, loc, targsi, ethis, NULL, 1); + if (fd && fd->type) + goto Lgetter; + } + goto Leprop; + } + else if (e1->op == TOKdotvar && e1->type->toBasetype()->ty == Tfunction) + { + DotVarExp *dve = (DotVarExp *)e1; + fd = dve->var->isFuncDeclaration(); + ethis = dve->e1; + goto L4; + } + else if (e1->op == TOKvar && e1->type->toBasetype()->ty == Tfunction) + { + fd = ((VarExp *)e1)->var->isFuncDeclaration(); + ethis = NULL; + L4: + { + assert(fd); + FuncDeclaration *f = fd; + Expressions a; + a.push(e2); + + fd = f->overloadResolve(loc, ethis, &a, 1); + if (fd && fd->type) + goto Lsetter; + + fd = f->overloadResolve(loc, ethis, NULL, 1); + if (fd && fd->type) + goto Lgetter; + + goto Leprop; + } + + Expression *e; + TypeFunction *tf; + + Lsetter: + assert(fd->type->ty == Tfunction); + tf = (TypeFunction *)fd->type; + if (!tf->isproperty && global.params.enforcePropertySyntax) + goto Leprop; + e = new CallExp(loc, e1, e2); + return e->semantic(sc); + + Lgetter: + assert(fd->type->ty == Tfunction); + tf = (TypeFunction *)fd->type; + if (!tf->isref) + goto Leprop; + if (!tf->isproperty && global.params.enforcePropertySyntax) + goto Leprop; + e = new CallExp(loc, e1); + e = new AssignExp(loc, e, e2); + return e->semantic(sc); + + Leprop: + ::error(e1->loc, "not a property %s", e1->toChars()); + return new ErrorExp(); + } + + assert(e1->type); + + /* Rewrite tuple assignment as a tuple of assignments. + */ +Ltupleassign: + if (e1->op == TOKtuple && e2->op == TOKtuple) + { TupleExp *tup1 = (TupleExp *)e1; + TupleExp *tup2 = (TupleExp *)e2; + size_t dim = tup1->exps->dim; + if (dim != tup2->exps->dim) + { + error("mismatched tuple lengths, %d and %d", (int)dim, (int)tup2->exps->dim); + return new ErrorExp(); + } + else + { Expressions *exps = new Expressions; + exps->setDim(dim); + + for (size_t i = 0; i < dim; i++) + { Expression *ex1 = (*tup1->exps)[i]; + Expression *ex2 = (*tup2->exps)[i]; + (*exps)[i] = new AssignExp(loc, ex1, ex2); + } + Expression *e = new TupleExp(loc, exps); + e = e->semantic(sc); + return e; + } + } + + if (e1->op == TOKtuple) + { + if (TupleDeclaration *td = isAliasThisTuple(e2)) + { + assert(e1->type->ty == Ttuple); + TypeTuple *tt = (TypeTuple *)e1->type; + + Identifier *id = Lexer::uniqueId("__tup"); + VarDeclaration *v = new VarDeclaration(e2->loc, NULL, id, new ExpInitializer(e2->loc, e2)); + v->storage_class = STCctfe | STCref | STCforeach; + Expression *ve = new VarExp(e2->loc, v); + ve->type = e2->type; + + Expressions *iexps = new Expressions(); + iexps->push(ve); + + for (size_t u = 0; u < iexps->dim ; u++) + { + Lexpand: + Expression *e = iexps->tdata()[u]; + + Parameter *arg = Parameter::getNth(tt->arguments, u); + //printf("[%d] iexps->dim = %d, ", u, iexps->dim); + //printf("e = (%s %s, %s), ", Token::tochars[e->op], e->toChars(), e->type->toChars()); + //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); + + if (!e->type->implicitConvTo(arg->type)) + { + // expand initializer to tuple + if (expandAliasThisTuples(iexps, u) != -1) + goto Lexpand; + + goto Lnomatch; + } + } + iexps->tdata()[0] = new CommaExp(loc, new DeclarationExp(e2->loc, v), iexps->tdata()[0]); + e2 = new TupleExp(e2->loc, iexps); + e2 = e2->semantic(sc); + goto Ltupleassign; + + Lnomatch: + ; + } + } + + // Determine if this is an initialization of a reference + int refinit = 0; + if (op == TOKconstruct && e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v->storage_class & (STCout | STCref)) + refinit = 1; + } + + Type *t1 = e1->type->toBasetype(); + + if (t1->ty == Tdelegate || (t1->ty == Tpointer && t1->nextOf()->ty == Tfunction) + && e2->op == TOKfunction) + { + FuncExp *fe = (FuncExp *)e2; + if (e2->type == Type::tvoid) + { + e2 = fe->inferType(sc, t1); + } + else if (e2->type->ty == Tpointer && e2->type->nextOf()->ty == Tfunction && + fe->tok == TOKreserved && + t1->ty == Tdelegate) + { + if (fe->implicitConvTo(t1)) + e2 = fe->castTo(sc, t1); + } + if (!e2) + { error("cannot infer function literal type from %s", t1->toChars()); + e2 = new ErrorExp(); + } + } + + /* If it is an assignment from a 'foreign' type, + * check for operator overloading. + */ + if (t1->ty == Tstruct) + { + StructDeclaration *sd = ((TypeStruct *)t1)->sym; + if (op == TOKassign) + { + /* See if we need to set ctorinit, i.e. track + * assignments to fields. An assignment to a field counts even + * if done through an opAssign overload. + */ + if (e1->op == TOKdotvar) + { DotVarExp *dve = (DotVarExp *)e1; + VarDeclaration *v = dve->var->isVarDeclaration(); + if (v && v->storage_class & STCnodefaultctor) + modifyFieldVar(loc, sc, v, dve->e1); + } + + Expression *e = op_overload(sc); + if (e && e1->op == TOKindex && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + // Deal with AAs (Bugzilla 2451) + // Rewrite as: + // e1 = (typeof(aa.value) tmp = void, tmp = e2, tmp); + Type * aaValueType = ((TypeAArray *)((IndexExp*)e1)->e1->type->toBasetype())->next; + Identifier *id = Lexer::uniqueId("__aatmp"); + VarDeclaration *v = new VarDeclaration(loc, aaValueType, + id, new VoidInitializer(0)); + v->storage_class |= STCctfe; + v->semantic(sc); + v->parent = sc->parent; + + Expression *de = new DeclarationExp(loc, v); + VarExp *ve = new VarExp(loc, v); + + AssignExp *ae = new AssignExp(loc, ve, e2); + e = ae->op_overload(sc); + e2 = new CommaExp(loc, new CommaExp(loc, de, e), ve); + e2 = e2->semantic(sc); + } + else if (e) + return e; + } + else if (op == TOKconstruct && !refinit) + { Type *t2 = e2->type->toBasetype(); + if (t2->ty == Tstruct && + sd == ((TypeStruct *)t2)->sym && + sd->cpctor) + { /* We have a copy constructor for this + */ + // Scan past commma's + Expression *ec = NULL; + while (e2->op == TOKcomma) + { CommaExp *ecomma = (CommaExp *)e2; + e2 = ecomma->e2; + if (ec) + ec = new CommaExp(ecomma->loc, ec, ecomma->e1); + else + ec = ecomma->e1; + } + if (e2->op == TOKquestion) + { /* Write as: + * a ? e1 = b : e1 = c; + */ + CondExp *econd = (CondExp *)e2; + AssignExp *ea1 = new AssignExp(econd->e1->loc, e1, econd->e1); + ea1->op = op; + AssignExp *ea2 = new AssignExp(econd->e1->loc, e1, econd->e2); + ea2->op = op; + Expression *e = new CondExp(loc, econd->econd, ea1, ea2); + if (ec) + e = new CommaExp(loc, ec, e); + return e->semantic(sc); + } + else if (e2->op == TOKvar || + e2->op == TOKdotvar || + e2->op == TOKstar || + e2->op == TOKthis || + e2->op == TOKindex) + { /* Write as: + * e1.cpctor(e2); + */ + if (!e2->type->implicitConvTo(e1->type)) + error("conversion error from %s to %s", e2->type->toChars(), e1->type->toChars()); + + Expression *e = new DotVarExp(loc, e1, sd->cpctor, 0); + e = new CallExp(loc, e, e2); + if (ec) + e = new CommaExp(loc, ec, e); + return e->semantic(sc); + } + else if (e2->op == TOKcall) + { + /* The struct value returned from the function is transferred + * so should not call the destructor on it. + */ + valueNoDtor(e2); + } + } + } + } + else if (t1->ty == Tclass) + { // Disallow assignment operator overloads for same type + if (!e2->implicitConvTo(e1->type)) + { + Expression *e = op_overload(sc); + if (e) + return e; + } + } + + if (t1->ty == Tsarray && !refinit) + { + if (e1->op == TOKindex && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + // Assignment to an AA of fixed-length arrays. + // Convert T[n][U] = T[] into T[n][U] = T[n] + e2 = e2->implicitCastTo(sc, e1->type); + if (e2->type == Type::terror) + return e2; + } + else + { + Type *t2 = e2->type->toBasetype(); + // Convert e2 to e2[], unless e2-> e1[0] + if (t2->ty == Tsarray && !t2->implicitConvTo(t1->nextOf())) + { + e2 = new SliceExp(e2->loc, e2, NULL, NULL); + e2 = e2->semantic(sc); + } + + // Convert e1 to e1[] + Expression *e = new SliceExp(e1->loc, e1, NULL, NULL); + e1 = e->semantic(sc); + t1 = e1->type->toBasetype(); + } + } + + if (!e2->rvalue()) + return new ErrorExp(); + + if (e1->op == TOKarraylength) + { + // e1 is not an lvalue, but we let code generator handle it + ArrayLengthExp *ale = (ArrayLengthExp *)e1; + + ale->e1 = ale->e1->modifiableLvalue(sc, e1); + } + else if (e1->op == TOKslice) + { + Type *tn = e1->type->nextOf(); + if (op == TOKassign && tn && (!tn->isMutable() || !tn->isAssignable())) + { error("slice %s is not mutable", e1->toChars()); + return new ErrorExp(); + } + } + else + { // Try to do a decent error message with the expression + // before it got constant folded + if (e1->op != TOKvar) + e1 = e1->optimize(WANTvalue); + + if (op != TOKconstruct) + e1 = e1->modifiableLvalue(sc, e1old); + } + + Type *t2 = e2->type->toBasetype(); +#if 0 + if (t1->ty == Tvector && t2->ty != Tvector && + e2->implicitConvTo(((TypeVector *)t1)->basetype->nextOf()) + ) + { // memset + ismemset = 1; // make it easy for back end to tell what this is + e2 = e2->implicitCastTo(sc, ((TypeVector *)t1)->basetype->nextOf()); + } + else +#endif + if (e1->op == TOKslice && + t1->nextOf() && + e2->implicitConvTo(t1->nextOf()) + ) + { // memset + ismemset = 1; // make it easy for back end to tell what this is + e2 = e2->implicitCastTo(sc, t1->nextOf()); + } + else if (t1->ty == Tsarray) + { + /* Should have already converted e1 => e1[] + * unless it is an AA + */ + if (!(e1->op == TOKindex && t2->ty == Tsarray && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray)) + { + assert(op == TOKconstruct); + } + //error("cannot assign to static array %s", e1->toChars()); + } + else if (e1->op == TOKslice && t2->ty == Tarray && + t2->nextOf()->implicitConvTo(t1->nextOf())) + { + e2 = e2->implicitCastTo(sc, e1->type->constOf()); + } + else + { + e2 = e2->implicitCastTo(sc, e1->type); + } + + /* Look for array operations + */ + if (e1->op == TOKslice && !ismemset && + (e2->op == TOKadd || e2->op == TOKmin || + e2->op == TOKmul || e2->op == TOKdiv || + e2->op == TOKmod || e2->op == TOKxor || + e2->op == TOKand || e2->op == TOKor || +#if DMDV2 + e2->op == TOKpow || +#endif + e2->op == TOKtilde || e2->op == TOKneg)) + { + type = e1->type; + return arrayOp(sc); + } + + if (e1->op == TOKvar && + (((VarExp *)e1)->var->storage_class & STCscope) && + op == TOKassign) + { + error("cannot rebind scope variables"); + } + + type = e1->type; + assert(type); + return this; +} + +Expression *AssignExp::checkToBoolean(Scope *sc) +{ + // Things like: + // if (a = b) ... + // are usually mistakes. + + error("assignment cannot be used as a condition, perhaps == was meant?"); + return new ErrorExp(); +} + +/************************************************************/ + +ConstructExp::ConstructExp(Loc loc, Expression *e1, Expression *e2) + : AssignExp(loc, e1, e2) +{ + op = TOKconstruct; +} + +/************************************************************/ + +AddAssignExp::AddAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKaddass, sizeof(AddAssignExp), e1, e2) +{ +} + +Expression *AddAssignExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + e = op_overload(sc); + if (e) + return e; + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + if (e1->op == TOKslice) + { + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + type = e1->type; + return arrayOp(sc); + } + else + { + e1 = e1->modifiableLvalue(sc, e1); + } + + if ((tb1->ty == Tarray || tb1->ty == Tsarray) && + (tb2->ty == Tarray || tb2->ty == Tsarray) && + tb1->nextOf()->equals(tb2->nextOf()) + ) + { + type = e1->type; + typeCombine(sc); + e = this; + } + else + { + e1->checkScalar(); + e1->checkNoBool(); + if (tb1->ty == Tpointer && tb2->isintegral()) + e = scaleFactor(sc); + else if (tb1->ty == Tbool) + { +#if 0 + // Need to rethink this + if (e1->op != TOKvar) + { // Rewrite e1+=e2 to (v=&e1),*v=*v+e2 + VarDeclaration *v; + Expression *ea; + Expression *ex; + + Identifier *id = Lexer::uniqueId("__name"); + + v = new VarDeclaration(loc, tb1->pointerTo(), id, NULL); + v->semantic(sc); + if (!sc->insert(v)) + assert(0); + v->parent = sc->func; + + ea = new AddrExp(loc, e1); + ea = new AssignExp(loc, new VarExp(loc, v), ea); + + ex = new VarExp(loc, v); + ex = new PtrExp(loc, ex); + e = new AddExp(loc, ex, e2); + e = new CastExp(loc, e, e1->type); + e = new AssignExp(loc, ex->syntaxCopy(), e); + + e = new CommaExp(loc, ea, e); + } + else +#endif + { // Rewrite e1+=e2 to e1=e1+e2 + // BUG: doesn't account for side effects in e1 + // BUG: other assignment operators for bits aren't handled at all + e = new AddExp(loc, e1, e2); + e = new CastExp(loc, e, e1->type); + e = new AssignExp(loc, e1->syntaxCopy(), e); + } + e = e->semantic(sc); + } + else + { + type = e1->type; + typeCombine(sc); + e1->checkArithmetic(); + e2->checkArithmetic(); + checkComplexAddAssign(); + if (type->isreal() || type->isimaginary()) + { + assert(global.errors || e2->type->isfloating()); + e2 = e2->castTo(sc, e1->type); + } + e = this; + } + } + return e; +} + +/************************************************************/ + +MinAssignExp::MinAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKminass, sizeof(MinAssignExp), e1, e2) +{ +} + +Expression *MinAssignExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + if (e1->op == TOKslice) + { // T[] -= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + type = e1->type; + return arrayOp(sc); + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + if (e1->type->ty == Tpointer && e2->type->isintegral()) + e = scaleFactor(sc); + else + { + e1 = e1->checkArithmetic(); + e2 = e2->checkArithmetic(); + checkComplexAddAssign(); + type = e1->type; + typeCombine(sc); + if (type->isreal() || type->isimaginary()) + { + assert(e2->type->isfloating()); + e2 = e2->castTo(sc, e1->type); + } + e = this; + } + return e; +} + +/************************************************************/ + +CatAssignExp::CatAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKcatass, sizeof(CatAssignExp), e1, e2) +{ +} + +Expression *CatAssignExp::semantic(Scope *sc) +{ Expression *e; + + //printf("CatAssignExp::semantic() %s\n", toChars()); + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKslice) + { SliceExp *se = (SliceExp *)e1; + + if (se->e1->type->toBasetype()->ty == Tsarray) + { error("cannot append to static array %s", se->e1->type->toChars()); + return new ErrorExp(); + } + } + + e1 = e1->modifiableLvalue(sc, e1); + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + if (!e2->rvalue()) + return new ErrorExp(); + + Type *tb1next = tb1->nextOf(); + + if ((tb1->ty == Tarray) && + (tb2->ty == Tarray || tb2->ty == Tsarray) && + (e2->implicitConvTo(e1->type) +#if DMDV2 + || tb2->nextOf()->implicitConvTo(tb1next) +#endif + ) + ) + { // Append array + e2 = e2->castTo(sc, e1->type); + type = e1->type; + e = this; + } + else if ((tb1->ty == Tarray) && + e2->implicitConvTo(tb1next) + ) + { // Append element + e2 = e2->castTo(sc, tb1next); + type = e1->type; + e = this; + } + else if (tb1->ty == Tarray && + (tb1next->ty == Tchar || tb1next->ty == Twchar) && + e2->type->ty != tb1next->ty && + e2->implicitConvTo(Type::tdchar) + ) + { // Append dchar to char[] or wchar[] + e2 = e2->castTo(sc, Type::tdchar); + type = e1->type; + e = this; + + /* Do not allow appending wchar to char[] because if wchar happens + * to be a surrogate pair, nothing good can result. + */ + } + else + { + if (tb1 != Type::terror && tb2 != Type::terror) + error("cannot append type %s to type %s", tb2->toChars(), tb1->toChars()); + e = new ErrorExp(); + } + return e; +} + +/************************************************************/ + +MulAssignExp::MulAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKmulass, sizeof(MulAssignExp), e1, e2) +{ +} + +Expression *MulAssignExp::semantic(Scope *sc) +{ Expression *e; + + e = op_overload(sc); + if (e) + return e; + +#if DMDV2 + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } +#endif + + if (e1->op == TOKslice) + { // T[] *= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + return arrayOp(sc); + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + type = e1->type; + typeCombine(sc); + e1->checkArithmetic(); + e2->checkArithmetic(); + checkComplexMulAssign(); + if (e2->type->isfloating()) + { + Type *t1 = e1->type; + Type *t2 = e2->type; + if (t1->isreal()) + { + if (t2->isimaginary() || t2->iscomplex()) + { + e2 = e2->castTo(sc, t1); + } + } + else if (t1->isimaginary()) + { + if (t2->isimaginary() || t2->iscomplex()) + { + switch (t1->ty) + { + case Timaginary32: t2 = Type::tfloat32; break; + case Timaginary64: t2 = Type::tfloat64; break; + case Timaginary80: t2 = Type::tfloat80; break; + default: + assert(0); + } + e2 = e2->castTo(sc, t2); + } + } + } + else if (type->toBasetype()->ty == Tvector && + ((TypeVector *)type->toBasetype())->elementType()->size(loc) != 2) + { // Only short[8] and ushort[8] work with multiply + return incompatibleTypes(); + } + return this; +} + +/************************************************************/ + +DivAssignExp::DivAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKdivass, sizeof(DivAssignExp), e1, e2) +{ +} + +Expression *DivAssignExp::semantic(Scope *sc) +{ Expression *e; + + e = op_overload(sc); + if (e) + return e; + +#if DMDV2 + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } +#endif + + if (e1->op == TOKslice) + { // T[] /= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + type = e1->type; + return arrayOp(sc); + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + type = e1->type; + typeCombine(sc); + e1->checkArithmetic(); + e2->checkArithmetic(); + checkComplexMulAssign(); + if (e2->type->isimaginary()) + { + Type *t1 = e1->type; + if (t1->isreal()) + { // x/iv = i(-x/v) + // Therefore, the result is 0 + e2 = new CommaExp(loc, e2, new RealExp(loc, 0, t1)); + e2->type = t1; + e = new AssignExp(loc, e1, e2); + e->type = t1; + return e; + } + else if (t1->isimaginary()) + { Type *t2; + + switch (t1->ty) + { + case Timaginary32: t2 = Type::tfloat32; break; + case Timaginary64: t2 = Type::tfloat64; break; + case Timaginary80: t2 = Type::tfloat80; break; + default: + assert(0); + } + e2 = e2->castTo(sc, t2); + Expression *e = new AssignExp(loc, e1, e2); + e->type = t1; + return e; + } + } + else if (type->toBasetype()->ty == Tvector && !e1->type->isfloating()) + return incompatibleTypes(); + return this; +} + +/************************************************************/ + +ModAssignExp::ModAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKmodass, sizeof(ModAssignExp), e1, e2) +{ +} + +Expression *ModAssignExp::semantic(Scope *sc) +{ + if (!type) + { + Expression *e = op_overload(sc); + if (e) + return e; + + checkComplexMulAssign(); + return commonSemanticAssign(sc); + } + return this; +} + +/************************************************************/ + +ShlAssignExp::ShlAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKshlass, sizeof(ShlAssignExp), e1, e2) +{ +} + +Expression *ShlAssignExp::semantic(Scope *sc) +{ Expression *e; + + //printf("ShlAssignExp::semantic()\n"); + + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + type = e1->type; + if (e1->type->toBasetype()->ty == Tvector || e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + typeCombine(sc); + e1->checkIntegral(); + e2 = e2->checkIntegral(); + e2 = e2->castTo(sc, Type::tshiftcnt); + return this; +} + +/************************************************************/ + +ShrAssignExp::ShrAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKshrass, sizeof(ShrAssignExp), e1, e2) +{ +} + +Expression *ShrAssignExp::semantic(Scope *sc) +{ Expression *e; + + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + type = e1->type; + if (e1->type->toBasetype()->ty == Tvector || e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + typeCombine(sc); + e1->checkIntegral(); + e2 = e2->checkIntegral(); + e2 = e2->castTo(sc, Type::tshiftcnt); + return this; +} + +/************************************************************/ + +UshrAssignExp::UshrAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKushrass, sizeof(UshrAssignExp), e1, e2) +{ +} + +Expression *UshrAssignExp::semantic(Scope *sc) +{ Expression *e; + + e = op_overload(sc); + if (e) + return e; + + if (e1->op == TOKarraylength) + { + e = ArrayLengthExp::rewriteOpAssign(this); + e = e->semantic(sc); + return e; + } + + e1 = e1->modifiableLvalue(sc, e1); + e1->checkScalar(); + e1->checkNoBool(); + type = e1->type; + if (e1->type->toBasetype()->ty == Tvector || e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + typeCombine(sc); + e1->checkIntegral(); + e2 = e2->checkIntegral(); + e2 = e2->castTo(sc, Type::tshiftcnt); + return this; +} + +/************************************************************/ + +AndAssignExp::AndAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKandass, sizeof(AndAssignExp), e1, e2) +{ +} + +Expression *AndAssignExp::semantic(Scope *sc) +{ + return commonSemanticAssignIntegral(sc); +} + +/************************************************************/ + +OrAssignExp::OrAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKorass, sizeof(OrAssignExp), e1, e2) +{ +} + +Expression *OrAssignExp::semantic(Scope *sc) +{ + return commonSemanticAssignIntegral(sc); +} + +/************************************************************/ + +XorAssignExp::XorAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKxorass, sizeof(XorAssignExp), e1, e2) +{ +} + +Expression *XorAssignExp::semantic(Scope *sc) +{ + return commonSemanticAssignIntegral(sc); +} + +/***************** PowAssignExp *******************************************/ + +PowAssignExp::PowAssignExp(Loc loc, Expression *e1, Expression *e2) + : BinAssignExp(loc, TOKpowass, sizeof(PowAssignExp), e1, e2) +{ +} + +Expression *PowAssignExp::semantic(Scope *sc) +{ + Expression *e; + + if (type) + return this; + + e = op_overload(sc); + if (e) + return e; + + assert(e1->type && e2->type); + if (e1->op == TOKslice) + { // T[] ^^= ... + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + + // Check element types are arithmetic + Type *tb1 = e1->type->nextOf()->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + if (tb2->ty == Tarray || tb2->ty == Tsarray) + tb2 = tb2->nextOf()->toBasetype(); + + if ( (tb1->isintegral() || tb1->isfloating()) && + (tb2->isintegral() || tb2->isfloating())) + { + type = e1->type; + return arrayOp(sc); + } + } + else + { + e1 = e1->modifiableLvalue(sc, e1); + } + + if ( (e1->type->isintegral() || e1->type->isfloating()) && + (e2->type->isintegral() || e2->type->isfloating())) + { + if (e1->op == TOKvar) + { // Rewrite: e1 = e1 ^^ e2 + e = new PowExp(loc, e1->syntaxCopy(), e2); + e = new AssignExp(loc, e1, e); + } + else + { // Rewrite: ref tmp = e1; tmp = tmp ^^ e2 + Identifier *id = Lexer::uniqueId("__powtmp"); + VarDeclaration *v = new VarDeclaration(e1->loc, e1->type, id, new ExpInitializer(loc, e1)); + v->storage_class |= STCref | STCforeach; + Expression *de = new DeclarationExp(e1->loc, v); + VarExp *ve = new VarExp(e1->loc, v); + e = new PowExp(loc, ve, e2); + e = new AssignExp(loc, new VarExp(e1->loc, v), e); + e = new CommaExp(loc, de, e); + } + e = e->semantic(sc); + if (e->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + return e; + } + return incompatibleTypes(); +} + + +/************************* AddExp *****************************/ + +AddExp::AddExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKadd, sizeof(AddExp), e1, e2) +{ +} + +Expression *AddExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("AddExp::semantic('%s')\n", toChars()); +#endif + if (!type) + { + BinExp::semanticp(sc); + + e = op_overload(sc); + if (e) + return e; + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + if ((tb1->ty == Tarray || tb1->ty == Tsarray) && + (tb2->ty == Tarray || tb2->ty == Tsarray) && + tb1->nextOf()->equals(tb2->nextOf()) + ) + { + type = e1->type; + e = this; + } + else if (tb1->ty == Tpointer && e2->type->isintegral() || + tb2->ty == Tpointer && e1->type->isintegral()) + e = scaleFactor(sc); + else if (tb1->ty == Tpointer && tb2->ty == Tpointer) + { + return incompatibleTypes(); + } + else + { + typeCombine(sc); + Type *tb1 = e1->type->toBasetype(); + if (tb1->ty == Tvector && !tb1->isscalar()) + { + return incompatibleTypes(); + } + if ((tb1->isreal() && e2->type->isimaginary()) || + (tb1->isimaginary() && e2->type->isreal())) + { + switch (type->toBasetype()->ty) + { + case Tfloat32: + case Timaginary32: + type = Type::tcomplex32; + break; + + case Tfloat64: + case Timaginary64: + type = Type::tcomplex64; + break; + + case Tfloat80: + case Timaginary80: + type = Type::tcomplex80; + break; + + default: + assert(0); + } + } + e = this; + } + return e; + } + return this; +} + +/************************************************************/ + +MinExp::MinExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKmin, sizeof(MinExp), e1, e2) +{ +} + +Expression *MinExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("MinExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + BinExp::semanticp(sc); + + e = op_overload(sc); + if (e) + return e; + + e = this; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + if (t1->ty == Tpointer) + { + if (t2->ty == Tpointer) + { // Need to divide the result by the stride + // Replace (ptr - ptr) with (ptr - ptr) / stride + d_int64 stride; + Expression *e; + + typeCombine(sc); // make sure pointer types are compatible + type = Type::tptrdiff_t; + stride = t2->nextOf()->size(); + if (stride == 0) + { + e = new IntegerExp(loc, 0, Type::tptrdiff_t); + } + else + { + e = new DivExp(loc, this, new IntegerExp(0, stride, Type::tptrdiff_t)); + e->type = Type::tptrdiff_t; + } + return e; + } + else if (t2->isintegral()) + e = scaleFactor(sc); + else + { error("can't subtract %s from pointer", t2->toChars()); + return new ErrorExp(); + } + } + else if (t2->ty == Tpointer) + { + type = e2->type; + error("can't subtract pointer from %s", e1->type->toChars()); + return new ErrorExp(); + } + else + { + typeCombine(sc); + t1 = e1->type->toBasetype(); + t2 = e2->type->toBasetype(); + if (t1->ty == Tvector && !t1->isscalar()) + { + return incompatibleTypes(); + } + if ((t1->isreal() && t2->isimaginary()) || + (t1->isimaginary() && t2->isreal())) + { + switch (type->ty) + { + case Tfloat32: + case Timaginary32: + type = Type::tcomplex32; + break; + + case Tfloat64: + case Timaginary64: + type = Type::tcomplex64; + break; + + case Tfloat80: + case Timaginary80: + type = Type::tcomplex80; + break; + + default: + assert(0); + } + } + } + return e; +} + +/************************* CatExp *****************************/ + +CatExp::CatExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKcat, sizeof(CatExp), e1, e2) +{ +} + +Expression *CatExp::semantic(Scope *sc) +{ Expression *e; + + //printf("CatExp::semantic() %s\n", toChars()); + if (!type) + { + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + Type *tb1 = e1->type->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + + + /* BUG: Should handle things like: + * char c; + * c ~ ' ' + * ' ' ~ c; + */ + +#if 0 + e1->type->print(); + e2->type->print(); +#endif + Type *tb1next = tb1->nextOf(); + Type *tb2next = tb2->nextOf(); + + if ((tb1->ty == Tsarray || tb1->ty == Tarray) && + e2->implicitConvTo(tb1next) >= MATCHconvert) + { + e2 = e2->implicitCastTo(sc, tb1next); + type = tb1next->arrayOf(); + if (tb2->ty == Tarray) + { // Make e2 into [e2] + e2 = new ArrayLiteralExp(e2->loc, e2); + e2->type = type; + } + return this; + } + else if ((tb2->ty == Tsarray || tb2->ty == Tarray) && + e1->implicitConvTo(tb2next) >= MATCHconvert) + { + e1 = e1->implicitCastTo(sc, tb2next); + type = tb2next->arrayOf(); + if (tb1->ty == Tarray) + { // Make e1 into [e1] + e1 = new ArrayLiteralExp(e1->loc, e1); + e1->type = type; + } + return this; + } + + if ((tb1->ty == Tsarray || tb1->ty == Tarray) && + (tb2->ty == Tsarray || tb2->ty == Tarray) && + (tb1next->mod || tb2next->mod) && + (tb1next->mod != tb2next->mod) + ) + { + Type *t1 = tb1next->mutableOf()->constOf()->arrayOf(); + Type *t2 = tb2next->mutableOf()->constOf()->arrayOf(); + if (e1->op == TOKstring && !((StringExp *)e1)->committed) + e1->type = t1; + else + e1 = e1->castTo(sc, t1); + if (e2->op == TOKstring && !((StringExp *)e2)->committed) + e2->type = t2; + else + e2 = e2->castTo(sc, t2); + } + + typeCombine(sc); + type = type->toHeadMutable(); + + Type *tb = type->toBasetype(); + if (tb->ty == Tsarray) + type = tb->nextOf()->arrayOf(); + if (type->ty == Tarray && tb1next && tb2next && + tb1next->mod != tb2next->mod) + { + type = type->nextOf()->toHeadMutable()->arrayOf(); + } +#if 0 + e1->type->print(); + e2->type->print(); + type->print(); + print(); +#endif + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + if (e1->op == TOKstring && e2->op == TOKstring) + e = optimize(WANTvalue); + else if ((t1->ty == Tarray || t1->ty == Tsarray) && + (t2->ty == Tarray || t2->ty == Tsarray)) + { + e = this; + } + else + { + //printf("(%s) ~ (%s)\n", e1->toChars(), e2->toChars()); + incompatibleTypes(); + return new ErrorExp(); + } + e->type = e->type->semantic(loc, sc); + return e; + } + return this; +} + +/************************************************************/ + +MulExp::MulExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKmul, sizeof(MulExp), e1, e2) +{ +} + +Expression *MulExp::semantic(Scope *sc) +{ Expression *e; + +#if 0 + printf("MulExp::semantic() %s\n", toChars()); +#endif + if (type) + { + return this; + } + + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkArithmetic(); + if (!e2->isArrayOperand()) + e2->checkArithmetic(); + if (type->isfloating()) + { Type *t1 = e1->type; + Type *t2 = e2->type; + + if (t1->isreal()) + { + type = t2; + } + else if (t2->isreal()) + { + type = t1; + } + else if (t1->isimaginary()) + { + if (t2->isimaginary()) + { Expression *e; + + switch (t1->toBasetype()->ty) + { + case Timaginary32: type = Type::tfloat32; break; + case Timaginary64: type = Type::tfloat64; break; + case Timaginary80: type = Type::tfloat80; break; + default: assert(0); + } + + // iy * iv = -yv + e1->type = type; + e2->type = type; + e = new NegExp(loc, this); + e = e->semantic(sc); + return e; + } + else + type = t2; // t2 is complex + } + else if (t2->isimaginary()) + { + type = t1; // t1 is complex + } + } + else if (type->toBasetype()->ty == Tvector && + ((TypeVector *)type->toBasetype())->elementType()->size(loc) != 2) + { // Only short[8] and ushort[8] work with multiply + return incompatibleTypes(); + } + return this; +} + +/************************************************************/ + +DivExp::DivExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKdiv, sizeof(DivExp), e1, e2) +{ +} + +Expression *DivExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkArithmetic(); + if (!e2->isArrayOperand()) + e2->checkArithmetic(); + if (type->isfloating()) + { Type *t1 = e1->type; + Type *t2 = e2->type; + + if (t1->isreal()) + { + type = t2; + if (t2->isimaginary()) + { Expression *e; + + // x/iv = i(-x/v) + e2->type = t1; + e = new NegExp(loc, this); + e = e->semantic(sc); + return e; + } + } + else if (t2->isreal()) + { + type = t1; + } + else if (t1->isimaginary()) + { + if (t2->isimaginary()) + { + switch (t1->toBasetype()->ty) + { + case Timaginary32: type = Type::tfloat32; break; + case Timaginary64: type = Type::tfloat64; break; + case Timaginary80: type = Type::tfloat80; break; + default: assert(0); + } + } + else + type = t2; // t2 is complex + } + else if (t2->isimaginary()) + { + type = t1; // t1 is complex + } + } + else if (type->toBasetype()->ty == Tvector) + { incompatibleTypes(); + return new ErrorExp(); + } + return this; +} + +/************************************************************/ + +ModExp::ModExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKmod, sizeof(ModExp), e1, e2) +{ +} + +Expression *ModExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkArithmetic(); + if (!e2->isArrayOperand()) + e2->checkArithmetic(); + if (type->toBasetype()->ty == Tvector) + { incompatibleTypes(); + return new ErrorExp(); + } + if (type->isfloating()) + { type = e1->type; + if (e2->type->iscomplex()) + { error("cannot perform modulo complex arithmetic"); + return new ErrorExp(); + } + } + return this; +} + +/************************************************************/ + +PowExp::PowExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKpow, sizeof(PowExp), e1, e2) +{ +} + +Expression *PowExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + //printf("PowExp::semantic() %s\n", toChars()); + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + assert(e1->type && e2->type); + typeCombine(sc); + + if (e1->op == TOKslice) + { + // Check element types are arithmetic + Type *tb1 = e1->type->nextOf()->toBasetype(); + Type *tb2 = e2->type->toBasetype(); + if (tb2->ty == Tarray || tb2->ty == Tsarray) + tb2 = tb2->nextOf()->toBasetype(); + + if ( (tb1->isintegral() || tb1->isfloating()) && + (tb2->isintegral() || tb2->isfloating())) + { + type = e1->type; + return this; + } + } + + if ( (e1->type->isintegral() || e1->type->isfloating()) && + (e2->type->isintegral() || e2->type->isfloating())) + { + // For built-in numeric types, there are several cases. + // TODO: backend support, especially for e1 ^^ 2. + + bool wantSqrt = false; + + // First, attempt to fold the expression. + e = optimize(WANTvalue); + if (e->op != TOKpow) + { + e = e->semantic(sc); + return e; + } + + // Determine if we're raising to an integer power. + sinteger_t intpow = 0; + if (e2->op == TOKint64 && ((sinteger_t)e2->toInteger() == 2 || (sinteger_t)e2->toInteger() == 3)) + intpow = e2->toInteger(); + else if (e2->op == TOKfloat64 && (e2->toReal() == (sinteger_t)(e2->toReal()))) + intpow = (sinteger_t)(e2->toReal()); + + // Deal with x^^2, x^^3 immediately, since they are of practical importance. + if (intpow == 2 || intpow == 3) + { + // Replace x^^2 with (tmp = x, tmp*tmp) + // Replace x^^3 with (tmp = x, tmp*tmp*tmp) + Identifier *idtmp = Lexer::uniqueId("__powtmp"); + VarDeclaration *tmp = new VarDeclaration(loc, e1->type->toBasetype(), idtmp, new ExpInitializer(0, e1)); + tmp->storage_class = STCctfe; + Expression *ve = new VarExp(loc, tmp); + Expression *ae = new DeclarationExp(loc, tmp); + /* Note that we're reusing ve. This should be ok. + */ + Expression *me = new MulExp(loc, ve, ve); + if (intpow == 3) + me = new MulExp(loc, me, ve); + e = new CommaExp(loc, ae, me); + e = e->semantic(sc); + return e; + } + + static int importMathChecked = 0; + if (!importMathChecked) + { + importMathChecked = 1; + for (size_t i = 0; i < Module::amodules.dim; i++) + { Module *mi = Module::amodules.tdata()[i]; + //printf("\t[%d] %s\n", i, mi->toChars()); + if (mi->ident == Id::math && + mi->parent->ident == Id::std && + !mi->parent->parent) + goto L1; + } + error("must import std.math to use ^^ operator"); + return new ErrorExp(); + + L1: ; + } + + e = new IdentifierExp(loc, Id::empty); + e = new DotIdExp(loc, e, Id::std); + e = new DotIdExp(loc, e, Id::math); + if (e2->op == TOKfloat64 && e2->toReal() == 0.5) + { // Replace e1 ^^ 0.5 with .std.math.sqrt(x) + e = new CallExp(loc, new DotIdExp(loc, e, Id::_sqrt), e1); + } + else + { + // Replace e1 ^^ e2 with .std.math.pow(e1, e2) + e = new CallExp(loc, new DotIdExp(loc, e, Id::_pow), e1, e2); + } + e = e->semantic(sc); + return e; + } + return incompatibleTypes(); +} + +/************************************************************/ + +ShlExp::ShlExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKshl, sizeof(ShlExp), e1, e2) +{ +} + +Expression *ShlExp::semantic(Scope *sc) +{ Expression *e; + + //printf("ShlExp::semantic(), type = %p\n", type); + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + e1 = e1->checkIntegral(); + e2 = e2->checkIntegral(); + if (e1->type->toBasetype()->ty == Tvector || + e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + e1 = e1->integralPromotions(sc); + e2 = e2->castTo(sc, Type::tshiftcnt); + type = e1->type; + } + return this; +} + +/************************************************************/ + +ShrExp::ShrExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKshr, sizeof(ShrExp), e1, e2) +{ +} + +Expression *ShrExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + e1 = e1->checkIntegral(); + e2 = e2->checkIntegral(); + if (e1->type->toBasetype()->ty == Tvector || + e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + e1 = e1->integralPromotions(sc); + e2 = e2->castTo(sc, Type::tshiftcnt); + type = e1->type; + } + return this; +} + +/************************************************************/ + +UshrExp::UshrExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKushr, sizeof(UshrExp), e1, e2) +{ +} + +Expression *UshrExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + e1 = e1->checkIntegral(); + e2 = e2->checkIntegral(); + if (e1->type->toBasetype()->ty == Tvector || + e2->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + e1 = e1->integralPromotions(sc); + e2 = e2->castTo(sc, Type::tshiftcnt); + type = e1->type; + } + return this; +} + +/************************************************************/ + +AndExp::AndExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKand, sizeof(AndExp), e1, e2) +{ +} + +Expression *AndExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + if (e1->type->toBasetype()->ty == Tbool && + e2->type->toBasetype()->ty == Tbool) + { + type = e1->type; + e = this; + } + else + { + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkIntegral(); + if (!e2->isArrayOperand()) + e2->checkIntegral(); + } + } + return this; +} + +/************************************************************/ + +OrExp::OrExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKor, sizeof(OrExp), e1, e2) +{ +} + +Expression *OrExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + if (e1->type->toBasetype()->ty == Tbool && + e2->type->toBasetype()->ty == Tbool) + { + type = e1->type; + e = this; + } + else + { + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkIntegral(); + if (!e2->isArrayOperand()) + e2->checkIntegral(); + } + } + return this; +} + +/************************************************************/ + +XorExp::XorExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKxor, sizeof(XorExp), e1, e2) +{ +} + +Expression *XorExp::semantic(Scope *sc) +{ Expression *e; + + if (!type) + { BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + if (e1->type->toBasetype()->ty == Tbool && + e2->type->toBasetype()->ty == Tbool) + { + type = e1->type; + e = this; + } + else + { + typeCombine(sc); + if (!e1->isArrayOperand()) + e1->checkIntegral(); + if (!e2->isArrayOperand()) + e2->checkIntegral(); + } + } + return this; +} + + +/************************************************************/ + +OrOrExp::OrOrExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKoror, sizeof(OrOrExp), e1, e2) +{ +} + +Expression *OrOrExp::semantic(Scope *sc) +{ + unsigned cs1; + + // same as for AndAnd + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->checkToPointer(); + e1 = e1->checkToBoolean(sc); + cs1 = sc->callSuper; + + if (sc->flags & SCOPEstaticif) + { + /* If in static if, don't evaluate e2 if we don't have to. + */ + e1 = e1->optimize(WANTflags); + if (e1->isBool(TRUE)) + { + return new IntegerExp(loc, 1, Type::tboolean); + } + } + + e2 = e2->semantic(sc); + sc->mergeCallSuper(loc, cs1); + e2 = resolveProperties(sc, e2); + e2 = e2->checkToPointer(); + + if (e2->type->ty == Tvoid) + type = Type::tvoid; + else + { + e2 = e2->checkToBoolean(sc); + type = Type::tboolean; + } + if (e2->op == TOKtype || e2->op == TOKimport) + { error("%s is not an expression", e2->toChars()); + return new ErrorExp(); + } + if (e1->op == TOKerror) + return e1; + if (e2->op == TOKerror) + return e2; + return this; +} + +Expression *OrOrExp::checkToBoolean(Scope *sc) +{ + e2 = e2->checkToBoolean(sc); + return this; +} + +int OrOrExp::isBit() +{ + return TRUE; +} + + +/************************************************************/ + +AndAndExp::AndAndExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKandand, sizeof(AndAndExp), e1, e2) +{ +} + +Expression *AndAndExp::semantic(Scope *sc) +{ + unsigned cs1; + + // same as for OrOr + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + e1 = e1->checkToPointer(); + e1 = e1->checkToBoolean(sc); + cs1 = sc->callSuper; + + if (sc->flags & SCOPEstaticif) + { + /* If in static if, don't evaluate e2 if we don't have to. + */ + e1 = e1->optimize(WANTflags); + if (e1->isBool(FALSE)) + { + return new IntegerExp(loc, 0, Type::tboolean); + } + } + + e2 = e2->semantic(sc); + sc->mergeCallSuper(loc, cs1); + e2 = resolveProperties(sc, e2); + e2 = e2->checkToPointer(); + + if (e2->type->ty == Tvoid) + type = Type::tvoid; + else + { + e2 = e2->checkToBoolean(sc); + type = Type::tboolean; + } + if (e2->op == TOKtype || e2->op == TOKimport) + { error("%s is not an expression", e2->toChars()); + return new ErrorExp(); + } + if (e1->op == TOKerror) + return e1; + if (e2->op == TOKerror) + return e2; + return this; +} + +Expression *AndAndExp::checkToBoolean(Scope *sc) +{ + e2 = e2->checkToBoolean(sc); + return this; +} + +int AndAndExp::isBit() +{ + return TRUE; +} + + +/************************************************************/ + +InExp::InExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKin, sizeof(InExp), e1, e2) +{ +} + +Expression *InExp::semantic(Scope *sc) +{ Expression *e; + + if (type) + return this; + + BinExp::semanticp(sc); + e = op_overload(sc); + if (e) + return e; + + //type = Type::tboolean; + Type *t2b = e2->type->toBasetype(); + switch (t2b->ty) + { + case Taarray: + { + TypeAArray *ta = (TypeAArray *)t2b; + +#if DMDV2 + // Special handling for array keys + if (!arrayTypeCompatible(e1->loc, e1->type, ta->index)) +#endif + { + // Convert key to type of key + e1 = e1->implicitCastTo(sc, ta->index); + } + + // Return type is pointer to value + type = ta->nextOf()->pointerTo(); + break; + } + + default: + error("rvalue of in expression must be an associative array, not %s", e2->type->toChars()); + case Terror: + return new ErrorExp(); + } + return this; +} + +int InExp::isBit() +{ + return FALSE; +} + + +/************************************************************/ + +/* This deletes the key e1 from the associative array e2 + */ + +RemoveExp::RemoveExp(Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, TOKremove, sizeof(RemoveExp), e1, e2) +{ + type = Type::tboolean; +} + +void RemoveExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, e1, PREC_primary); + buf->writestring(".remove("); + expToCBuffer(buf, hgs, e2, PREC_assign); + buf->writestring(")"); +} + +/************************************************************/ + +CmpExp::CmpExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, op, sizeof(CmpExp), e1, e2) +{ +} + +Expression *CmpExp::semantic(Scope *sc) +{ Expression *e; + +#if LOGSEMANTIC + printf("CmpExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + BinExp::semanticp(sc); + + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + if (t1->ty == Tclass && e2->op == TOKnull || + t2->ty == Tclass && e1->op == TOKnull) + { + error("do not use null when comparing class types"); + return new ErrorExp(); + } + + e = op_overload(sc); + if (e) + { + if (!e->type->isscalar() && e->type->equals(e1->type)) + { + error("recursive opCmp expansion"); + e = new ErrorExp(); + } + else if (e->op == TOKcall) + { e = new CmpExp(op, loc, e, new IntegerExp(loc, 0, Type::tint32)); + e = e->semantic(sc); + } + return e; + } + + /* Disallow comparing T[]==T and T==T[] + */ + if (e1->op == TOKslice && t1->ty == Tarray && e2->implicitConvTo(t1->nextOf()) || + e2->op == TOKslice && t2->ty == Tarray && e1->implicitConvTo(t2->nextOf())) + { + incompatibleTypes(); + return new ErrorExp(); + } + + Expression *eb1 = e1; + Expression *eb2 = e2; + + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + +#if 0 + // For integer comparisons, ensure the combined type can hold both arguments. + if (type && type->isintegral() && (op == TOKlt || op == TOKle || + op == TOKgt || op == TOKge)) + { + IntRange trange = IntRange::fromType(type); + + Expression *errorexp = 0; + if (!trange.contains(eb1->getIntRange())) + errorexp = eb1; + if (!trange.contains(eb2->getIntRange())) + errorexp = eb2; + + if (errorexp) + { + error("implicit conversion of '%s' to '%s' is unsafe in '(%s) %s (%s)'", + errorexp->toChars(), type->toChars(), eb1->toChars(), Token::toChars(op), eb2->toChars()); + return new ErrorExp(); + } + } +#endif + + type = Type::tboolean; + + // Special handling for array comparisons + t1 = e1->type->toBasetype(); + t2 = e2->type->toBasetype(); + if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && + (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer)) + { + if (t1->nextOf()->implicitConvTo(t2->nextOf()) < MATCHconst && + t2->nextOf()->implicitConvTo(t1->nextOf()) < MATCHconst && + (t1->nextOf()->ty != Tvoid && t2->nextOf()->ty != Tvoid)) + error("array comparison type mismatch, %s vs %s", t1->nextOf()->toChars(), t2->nextOf()->toChars()); + e = this; + } + else if (t1->ty == Tstruct || t2->ty == Tstruct || + (t1->ty == Tclass && t2->ty == Tclass)) + { + if (t2->ty == Tstruct) + error("need member function opCmp() for %s %s to compare", t2->toDsymbol(sc)->kind(), t2->toChars()); + else + error("need member function opCmp() for %s %s to compare", t1->toDsymbol(sc)->kind(), t1->toChars()); + e = new ErrorExp(); + } +#if 1 + else if (t1->iscomplex() || t2->iscomplex()) + { + error("compare not defined for complex operands"); + e = new ErrorExp(); + } +#endif + else if (t1->ty == Tvector) + return incompatibleTypes(); + else + { if (!e1->rvalue() || !e2->rvalue()) + return new ErrorExp(); + e = this; + } + //printf("CmpExp: %s, type = %s\n", e->toChars(), e->type->toChars()); + return e; +} + +int CmpExp::isBit() +{ + return TRUE; +} + + +/************************************************************/ + +EqualExp::EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, op, sizeof(EqualExp), e1, e2) +{ + assert(op == TOKequal || op == TOKnotequal); +} + +int needDirectEq(Type *t1, Type *t2) +{ + assert(t1->ty == Tarray || t1->ty == Tsarray); + assert(t2->ty == Tarray || t2->ty == Tsarray); + + Type *t1n = t1->nextOf()->toBasetype(); + Type *t2n = t2->nextOf()->toBasetype(); + + if (((t1n->ty == Tchar || t1n->ty == Twchar || t1n->ty == Tdchar) && + (t2n->ty == Tchar || t2n->ty == Twchar || t2n->ty == Tdchar)) || + (t1n->ty == Tvoid || t2n->ty == Tvoid)) + { + return FALSE; + } + + if (t1n->constOf() != t2n->constOf()) + return TRUE; + + Type *t = t1n; + while (t->toBasetype()->nextOf()) + t = t->nextOf()->toBasetype(); + if (t->ty != Tstruct) + return FALSE; + + return ((TypeStruct *)t)->sym->xeq == StructDeclaration::xerreq; +} + +Expression *EqualExp::semantic(Scope *sc) +{ Expression *e; + + //printf("EqualExp::semantic('%s')\n", toChars()); + if (type) + return this; + + BinExp::semanticp(sc); + + /* Before checking for operator overloading, check to see if we're + * comparing the addresses of two statics. If so, we can just see + * if they are the same symbol. + */ + if (e1->op == TOKaddress && e2->op == TOKaddress) + { AddrExp *ae1 = (AddrExp *)e1; + AddrExp *ae2 = (AddrExp *)e2; + + if (ae1->e1->op == TOKvar && ae2->e1->op == TOKvar) + { VarExp *ve1 = (VarExp *)ae1->e1; + VarExp *ve2 = (VarExp *)ae2->e1; + + if (ve1->var == ve2->var /*|| ve1->var->toSymbol() == ve2->var->toSymbol()*/) + { + // They are the same, result is 'true' for ==, 'false' for != + e = new IntegerExp(loc, (op == TOKequal), Type::tboolean); + return e; + } + } + } + + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + if (t1->ty == Tclass && e2->op == TOKnull || + t2->ty == Tclass && e1->op == TOKnull) + { + error("use '%s' instead of '%s' when comparing with null", + Token::toChars(op == TOKequal ? TOKidentity : TOKnotidentity), + Token::toChars(op)); + return new ErrorExp(); + } + + if ((t1->ty == Tarray || t1->ty == Tsarray) && + (t2->ty == Tarray || t2->ty == Tsarray)) + { + if (needDirectEq(t1, t2)) + { /* Rewrite as: + * _ArrayEq(e1, e2) + */ + Expression *eq = new IdentifierExp(loc, Id::_ArrayEq); + Expressions *args = new Expressions(); + args->push(e1); + args->push(e2); + e = new CallExp(loc, eq, args); + if (op == TOKnotequal) + e = new NotExp(loc, e); + e = e->trySemantic(sc); // for better error message + if (!e) + { error("cannot compare %s and %s", t1->toChars(), t2->toChars()); + return new ErrorExp(); + } + return e; + } + } + + //if (e2->op != TOKnull) + { + e = op_overload(sc); + if (e) + { + if (e->op == TOKcall && op == TOKnotequal) + { + e = new NotExp(e->loc, e); + e = e->semantic(sc); + } + return e; + } + } + + /* Disallow comparing T[]==T and T==T[] + */ + if (e1->op == TOKslice && t1->ty == Tarray && e2->implicitConvTo(t1->nextOf()) || + e2->op == TOKslice && t2->ty == Tarray && e1->implicitConvTo(t2->nextOf())) + { + incompatibleTypes(); + return new ErrorExp(); + } + + e = typeCombine(sc); + if (e->op == TOKerror) + return e; + + type = Type::tboolean; + + // Special handling for array comparisons + if (!arrayTypeCompatible(loc, e1->type, e2->type)) + { + if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) + { + // Cast both to complex + e1 = e1->castTo(sc, Type::tcomplex80); + e2 = e2->castTo(sc, Type::tcomplex80); + } + } + + if (e1->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + + return e; +} + +int EqualExp::isBit() +{ + return TRUE; +} + + + +/************************************************************/ + +IdentityExp::IdentityExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) + : BinExp(loc, op, sizeof(IdentityExp), e1, e2) +{ +} + +Expression *IdentityExp::semantic(Scope *sc) +{ + if (type) + return this; + + BinExp::semanticp(sc); + type = Type::tboolean; + + Expression *e = typeCombine(sc); + if (e->op == TOKerror) + return e; + + if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) + { + // Cast both to complex + e1 = e1->castTo(sc, Type::tcomplex80); + e2 = e2->castTo(sc, Type::tcomplex80); + } + + if (e1->type->toBasetype()->ty == Tvector) + return incompatibleTypes(); + + return this; +} + +int IdentityExp::isBit() +{ + return TRUE; +} + + +/****************************************************************/ + +CondExp::CondExp(Loc loc, Expression *econd, Expression *e1, Expression *e2) + : BinExp(loc, TOKquestion, sizeof(CondExp), e1, e2) +{ + this->econd = econd; +} + +Expression *CondExp::syntaxCopy() +{ + return new CondExp(loc, econd->syntaxCopy(), e1->syntaxCopy(), e2->syntaxCopy()); +} + + +Expression *CondExp::semantic(Scope *sc) +{ Type *t1; + Type *t2; + unsigned cs0; + unsigned cs1; + +#if LOGSEMANTIC + printf("CondExp::semantic('%s')\n", toChars()); +#endif + if (type) + return this; + + econd = econd->semantic(sc); + econd = resolveProperties(sc, econd); + econd = econd->checkToPointer(); + econd = econd->checkToBoolean(sc); + +#if 0 /* this cannot work right because the types of e1 and e2 + * both contribute to the type of the result. + */ + if (sc->flags & SCOPEstaticif) + { + /* If in static if, don't evaluate what we don't have to. + */ + econd = econd->optimize(WANTflags); + if (econd->isBool(TRUE)) + { + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + return e1; + } + else if (econd->isBool(FALSE)) + { + e2 = e2->semantic(sc); + e2 = resolveProperties(sc, e2); + return e2; + } + } +#endif + + + cs0 = sc->callSuper; + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + cs1 = sc->callSuper; + sc->callSuper = cs0; + e2 = e2->semantic(sc); + e2 = resolveProperties(sc, e2); + sc->mergeCallSuper(loc, cs1); + + + // If either operand is void, the result is void + t1 = e1->type; + t2 = e2->type; + if (t1->ty == Tvoid || t2->ty == Tvoid) + type = Type::tvoid; + else if (t1 == t2) + type = t1; + else + { + typeCombine(sc); + switch (e1->type->toBasetype()->ty) + { + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: + e2 = e2->castTo(sc, e1->type); + break; + } + switch (e2->type->toBasetype()->ty) + { + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: + e1 = e1->castTo(sc, e2->type); + break; + } + if (type->toBasetype()->ty == Tarray) + { + e1 = e1->castTo(sc, type); + e2 = e2->castTo(sc, type); + } + } +#if 0 + printf("res: %s\n", type->toChars()); + printf("e1 : %s\n", e1->type->toChars()); + printf("e2 : %s\n", e2->type->toChars()); +#endif + return this; +} + +#if DMDV2 +int CondExp::isLvalue() +{ + return e1->isLvalue() && e2->isLvalue(); +} +#endif + +Expression *CondExp::toLvalue(Scope *sc, Expression *ex) +{ + PtrExp *e; + + // convert (econd ? e1 : e2) to *(econd ? &e1 : &e2) + e = new PtrExp(loc, this, type); + + e1 = e1->addressOf(sc); + e2 = e2->addressOf(sc); + + typeCombine(sc); + + type = e2->type; + return e; +} + +Expression *CondExp::modifiableLvalue(Scope *sc, Expression *e) +{ + //error("conditional expression %s is not a modifiable lvalue", toChars()); + e1 = e1->modifiableLvalue(sc, e1); + e2 = e2->modifiableLvalue(sc, e1); + return toLvalue(sc, this); +} + +void CondExp::checkEscape() +{ + e1->checkEscape(); + e2->checkEscape(); +} + +void CondExp::checkEscapeRef() +{ + e1->checkEscapeRef(); + e2->checkEscapeRef(); +} + + +Expression *CondExp::checkToBoolean(Scope *sc) +{ + e1 = e1->checkToBoolean(sc); + e2 = e2->checkToBoolean(sc); + return this; +} + + +void CondExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + expToCBuffer(buf, hgs, econd, PREC_oror); + buf->writestring(" ? "); + expToCBuffer(buf, hgs, e1, PREC_expr); + buf->writestring(" : "); + expToCBuffer(buf, hgs, e2, PREC_cond); +} + + +/****************************************************************/ + +DefaultInitExp::DefaultInitExp(Loc loc, enum TOK subop, int size) + : Expression(loc, TOKdefault, size) +{ + this->subop = subop; +} + +void DefaultInitExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(subop)); +} + +/****************************************************************/ + +FileInitExp::FileInitExp(Loc loc) + : DefaultInitExp(loc, TOKfile, sizeof(FileInitExp)) +{ +} + +Expression *FileInitExp::semantic(Scope *sc) +{ + //printf("FileInitExp::semantic()\n"); + type = Type::tchar->invariantOf()->arrayOf(); + return this; +} + +Expression *FileInitExp::resolveLoc(Loc loc, Scope *sc) +{ + //printf("FileInitExp::resolve() %s\n", toChars()); + const char *s = loc.filename ? loc.filename : sc->module->ident->toChars(); + Expression *e = new StringExp(loc, (char *)s); + e = e->semantic(sc); + e = e->castTo(sc, type); + return e; +} + +/****************************************************************/ + +LineInitExp::LineInitExp(Loc loc) + : DefaultInitExp(loc, TOKline, sizeof(LineInitExp)) +{ +} + +Expression *LineInitExp::semantic(Scope *sc) +{ + type = Type::tint32; + return this; +} + +Expression *LineInitExp::resolveLoc(Loc loc, Scope *sc) +{ + Expression *e = new IntegerExp(loc, loc.linnum, Type::tint32); + e = e->castTo(sc, type); + return e; +} + + diff --git a/expression.h b/expression.h new file mode 100644 index 00000000..5febe4c9 --- /dev/null +++ b/expression.h @@ -0,0 +1,1697 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_EXPRESSION_H +#define DMD_EXPRESSION_H + +#include "mars.h" +#include "identifier.h" +#include "lexer.h" +#include "arraytypes.h" +#include "intrange.h" + +struct Type; +struct Scope; +struct TupleDeclaration; +struct VarDeclaration; +struct FuncDeclaration; +struct FuncLiteralDeclaration; +struct Declaration; +struct CtorDeclaration; +struct NewDeclaration; +struct Dsymbol; +struct Import; +struct Module; +struct ScopeDsymbol; +struct InlineCostState; +struct InlineDoState; +struct InlineScanState; +struct Expression; +struct Declaration; +struct AggregateDeclaration; +struct StructDeclaration; +struct TemplateInstance; +struct TemplateDeclaration; +struct ClassDeclaration; +struct HdrGenState; +struct BinExp; +struct InterState; +struct Symbol; // back end symbol +struct OverloadSet; +struct Initializer; +struct StringExp; + +enum TOK; + +// Back end +struct IRState; +struct dt_t; + +#ifdef IN_GCC +union tree_node; typedef union tree_node elem; +#else +struct elem; +#endif + +void initPrecedence(); + +typedef int (*apply_fp_t)(Expression *, void *); + +Expression *resolveProperties(Scope *sc, Expression *e); +void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d); +Expression *build_overload(Loc loc, Scope *sc, Expression *ethis, Expression *earg, Dsymbol *d); +Dsymbol *search_function(ScopeDsymbol *ad, Identifier *funcid); +void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); +void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); +void expandTuples(Expressions *exps); +TupleDeclaration *isAliasThisTuple(Expression *e); +int expandAliasThisTuples(Expressions *exps, int starti = 0); +FuncDeclaration *hasThis(Scope *sc); +Expression *fromConstInitializer(int result, Expression *e); +int arrayExpressionCanThrow(Expressions *exps, bool mustNotThrow); +TemplateDeclaration *getFuncTemplateDecl(Dsymbol *s); +void valueNoDtor(Expression *e); +void modifyFieldVar(Loc loc, Scope *sc, VarDeclaration *var, Expression *e1); + + +/* Interpreter: what form of return value expression is required? + */ +enum CtfeGoal +{ ctfeNeedRvalue, // Must return an Rvalue + ctfeNeedLvalue, // Must return an Lvalue + ctfeNeedAnyValue, // Can return either an Rvalue or an Lvalue + ctfeNeedLvalueRef,// Must return a reference to an Lvalue (for ref types) + ctfeNeedNothing // The return value is not required +}; + +struct Expression : Object +{ + Loc loc; // file location + enum TOK op; // handy to minimize use of dynamic_cast + Type *type; // !=NULL means that semantic() has been run + unsigned char size; // # of bytes in Expression so we can copy() it + unsigned char parens; // if this is a parenthesized expression + + Expression(Loc loc, enum TOK op, int size); + Expression *copy(); + virtual Expression *syntaxCopy(); + virtual int apply(apply_fp_t fp, void *param); + virtual Expression *semantic(Scope *sc); + Expression *trySemantic(Scope *sc); + + int dyncast() { return DYNCAST_EXPRESSION; } // kludge for template.isExpression() + + void print(); + char *toChars(); + virtual void dump(int indent); + void error(const char *format, ...); + void warning(const char *format, ...); + virtual int rvalue(); + + static Expression *combine(Expression *e1, Expression *e2); + static Expressions *arraySyntaxCopy(Expressions *exps); + + virtual dinteger_t toInteger(); + virtual uinteger_t toUInteger(); + virtual real_t toReal(); + virtual real_t toImaginary(); + virtual complex_t toComplex(); + virtual StringExp *toString(); + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + virtual void toMangleBuffer(OutBuffer *buf); + virtual int isLvalue(); + virtual Expression *toLvalue(Scope *sc, Expression *e); + virtual Expression *modifiableLvalue(Scope *sc, Expression *e); + virtual Expression *implicitCastTo(Scope *sc, Type *t); + virtual MATCH implicitConvTo(Type *t); + virtual IntRange getIntRange(); + virtual Expression *castTo(Scope *sc, Type *t); + virtual void checkEscape(); + virtual void checkEscapeRef(); + virtual Expression *resolveLoc(Loc loc, Scope *sc); + void checkScalar(); + void checkNoBool(); + Expression *checkIntegral(); + Expression *checkArithmetic(); + void checkDeprecated(Scope *sc, Dsymbol *s); + void checkPurity(Scope *sc, FuncDeclaration *f); + void checkPurity(Scope *sc, VarDeclaration *v, Expression *e1); + void checkSafety(Scope *sc, FuncDeclaration *f); + virtual Expression *checkToBoolean(Scope *sc); + virtual Expression *addDtorHook(Scope *sc); + Expression *checkToPointer(); + Expression *addressOf(Scope *sc); + Expression *deref(); + Expression *integralPromotions(Scope *sc); + Expression *isTemp(); + + Expression *toDelegate(Scope *sc, Type *t); + + virtual Expression *optimize(int result); + #define WANTflags 1 + #define WANTvalue 2 + // A compile-time result is required. Give an error if not possible + #define WANTinterpret 4 + // Same as WANTvalue, but also expand variables as far as possible + #define WANTexpand 8 + + virtual Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + + virtual int isConst(); + virtual int isBool(int result); + virtual int isBit(); + bool hasSideEffect(); + void discardValue(); + void useValue(); + int canThrow(bool mustNotThrow); + + virtual int inlineCost3(InlineCostState *ics); + virtual Expression *doInline(InlineDoState *ids); + virtual Expression *inlineScan(InlineScanState *iss); + Expression *inlineCopy(Scope *sc); + + // For operator overloading + virtual int isCommutative(); + virtual Identifier *opId(); + virtual Identifier *opId_r(); + + // For array ops + virtual void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + virtual Expression *buildArrayLoop(Parameters *fparams); + int isArrayOperand(); + + // Back end + virtual elem *toElem(IRState *irs); + elem *toElemDtor(IRState *irs); + virtual dt_t **toDt(dt_t **pdt); +}; + +struct IntegerExp : Expression +{ + dinteger_t value; + + IntegerExp(Loc loc, dinteger_t value, Type *type); + IntegerExp(dinteger_t value); + int equals(Object *o); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + char *toChars(); + void dump(int indent); + IntRange getIntRange(); + dinteger_t toInteger(); + real_t toReal(); + real_t toImaginary(); + complex_t toComplex(); + int isConst(); + int isBool(int result); + MATCH implicitConvTo(Type *t); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + Expression *toLvalue(Scope *sc, Expression *e); + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); +}; + +struct ErrorExp : IntegerExp +{ + ErrorExp(); + + Expression *implicitCastTo(Scope *sc, Type *t); + Expression *castTo(Scope *sc, Type *t); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *toLvalue(Scope *sc, Expression *e); +}; + +struct RealExp : Expression +{ + real_t value; + + RealExp(Loc loc, real_t value, Type *type); + int equals(Object *o); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + char *toChars(); + dinteger_t toInteger(); + uinteger_t toUInteger(); + real_t toReal(); + real_t toImaginary(); + complex_t toComplex(); + Expression *castTo(Scope *sc, Type *t); + int isConst(); + int isBool(int result); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); +}; + +struct ComplexExp : Expression +{ + complex_t value; + + ComplexExp(Loc loc, complex_t value, Type *type); + int equals(Object *o); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + char *toChars(); + dinteger_t toInteger(); + uinteger_t toUInteger(); + real_t toReal(); + real_t toImaginary(); + complex_t toComplex(); + Expression *castTo(Scope *sc, Type *t); + int isConst(); + int isBool(int result); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + OutBuffer hexp; + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); +}; + +struct IdentifierExp : Expression +{ + Identifier *ident; + Declaration *var; + + IdentifierExp(Loc loc, Identifier *ident); + IdentifierExp(Loc loc, Declaration *var); + Expression *semantic(Scope *sc); + char *toChars(); + void dump(int indent); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); +}; + +struct DollarExp : IdentifierExp +{ + DollarExp(Loc loc); +}; + +struct DsymbolExp : Expression +{ + Dsymbol *s; + int hasOverloads; + + DsymbolExp(Loc loc, Dsymbol *s, int hasOverloads = 0); + Expression *semantic(Scope *sc); + char *toChars(); + void dump(int indent); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); +}; + +struct ThisExp : Expression +{ + Declaration *var; + + ThisExp(Loc loc); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBool(int result); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + + int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + //Expression *inlineScan(InlineScanState *iss); + + elem *toElem(IRState *irs); +}; + +struct SuperExp : ThisExp +{ + SuperExp(Loc loc); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Expression *doInline(InlineDoState *ids); + //Expression *inlineScan(InlineScanState *iss); +}; + +struct NullExp : Expression +{ + unsigned char committed; // !=0 if type is committed + + NullExp(Loc loc, Type *t = NULL); + int equals(Object *o); + Expression *semantic(Scope *sc); + int isBool(int result); + int isConst(); + StringExp *toString(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); +}; + +struct StringExp : Expression +{ + void *string; // char, wchar, or dchar data + size_t len; // number of chars, wchars, or dchars + unsigned char sz; // 1: char, 2: wchar, 4: dchar + unsigned char committed; // !=0 if type is committed + unsigned char postfix; // 'c', 'w', 'd' + bool ownedByCtfe; // true = created in CTFE + + StringExp(Loc loc, char *s); + StringExp(Loc loc, void *s, size_t len); + StringExp(Loc loc, void *s, size_t len, unsigned char postfix); + //Expression *syntaxCopy(); + int equals(Object *o); + char *toChars(); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + size_t length(); + StringExp *toString(); + StringExp *toUTF8(Scope *sc); + Expression *implicitCastTo(Scope *sc, Type *t); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + int compare(Object *obj); + int isBool(int result); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + unsigned charAt(size_t i); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); +}; + +// Tuple + +struct TupleExp : Expression +{ + Expressions *exps; + + TupleExp(Loc loc, Expressions *exps); + TupleExp(Loc loc, TupleDeclaration *tup); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + int equals(Object *o); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void checkEscape(); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + Expression *castTo(Scope *sc, Type *t); + elem *toElem(IRState *irs); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct ArrayLiteralExp : Expression +{ + Expressions *elements; + bool ownedByCtfe; // true = created in CTFE + + ArrayLiteralExp(Loc loc, Expressions *elements); + ArrayLiteralExp(Loc loc, Expression *e); + + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + int isBool(int result); + elem *toElem(IRState *irs); + StringExp *toString(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + dt_t **toDt(dt_t **pdt); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct AssocArrayLiteralExp : Expression +{ + Expressions *keys; + Expressions *values; + bool ownedByCtfe; // true = created in CTFE + + AssocArrayLiteralExp(Loc loc, Expressions *keys, Expressions *values); + + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + int isBool(int result); + elem *toElem(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct StructLiteralExp : Expression +{ + StructDeclaration *sd; // which aggregate this is for + Expressions *elements; // parallels sd->fields[] with + // NULL entries for fields to skip + Type *stype; // final type of result (can be different from sd's type) + + Symbol *sym; // back end symbol to initialize with literal + size_t soffset; // offset from start of s + int fillHoles; // fill alignment 'holes' with zero + bool ownedByCtfe; // true = created in CTFE + + StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements, Type *stype = NULL); + + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + Expression *getField(Type *type, unsigned offset); + int getFieldIndex(Type *type, unsigned offset); + elem *toElem(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toMangleBuffer(OutBuffer *buf); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + dt_t **toDt(dt_t **pdt); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + MATCH implicitConvTo(Type *t); + + int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +Expression *typeDotIdExp(Loc loc, Type *type, Identifier *ident); + +struct TypeExp : Expression +{ + TypeExp(Loc loc, Type *type); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + int rvalue(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *optimize(int result); + elem *toElem(IRState *irs); +}; + +struct ScopeExp : Expression +{ + ScopeDsymbol *sds; + + ScopeExp(Loc loc, ScopeDsymbol *sds); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + elem *toElem(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct TemplateExp : Expression +{ + TemplateDeclaration *td; + + TemplateExp(Loc loc, TemplateDeclaration *td); + int rvalue(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct NewExp : Expression +{ + /* thisexp.new(newargs) newtype(arguments) + */ + Expression *thisexp; // if !NULL, 'this' for class being allocated + Expressions *newargs; // Array of Expression's to call new operator + Type *newtype; + Expressions *arguments; // Array of Expression's + + CtorDeclaration *member; // constructor function + NewDeclaration *allocator; // allocator function + int onstack; // allocate on stack + + NewExp(Loc loc, Expression *thisexp, Expressions *newargs, + Type *newtype, Expressions *arguments); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + Expression *optimize(int result); + elem *toElem(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + //int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + //Expression *inlineScan(InlineScanState *iss); +}; + +struct NewAnonClassExp : Expression +{ + /* thisexp.new(newargs) class baseclasses { } (arguments) + */ + Expression *thisexp; // if !NULL, 'this' for class being allocated + Expressions *newargs; // Array of Expression's to call new operator + ClassDeclaration *cd; // class being instantiated + Expressions *arguments; // Array of Expression's to call class constructor + + NewAnonClassExp(Loc loc, Expression *thisexp, Expressions *newargs, + ClassDeclaration *cd, Expressions *arguments); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +#if DMDV2 +struct SymbolExp : Expression +{ + Declaration *var; + int hasOverloads; + + SymbolExp(Loc loc, enum TOK op, int size, Declaration *var, int hasOverloads); + + elem *toElem(IRState *irs); +}; +#endif + +// Offset from symbol + +struct SymOffExp : SymbolExp +{ + unsigned offset; + + SymOffExp(Loc loc, Declaration *var, unsigned offset, int hasOverloads = 0); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void checkEscape(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int isConst(); + int isBool(int result); + Expression *doInline(InlineDoState *ids); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + + dt_t **toDt(dt_t **pdt); +}; + +// Variable + +struct VarExp : SymbolExp +{ + VarExp(Loc loc, Declaration *var, int hasOverloads = 0); + int equals(Object *o); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void dump(int indent); + char *toChars(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void checkEscape(); + void checkEscapeRef(); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + dt_t **toDt(dt_t **pdt); + + int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + //Expression *inlineScan(InlineScanState *iss); +}; + +#if DMDV2 +// Overload Set + +struct OverExp : Expression +{ + OverloadSet *vars; + + OverExp(OverloadSet *s); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); +}; +#endif + +// Function/Delegate literal + +struct FuncExp : Expression +{ + FuncLiteralDeclaration *fd; + TemplateDeclaration *td; + enum TOK tok; + Type *tded; + Scope *scope; + + FuncExp(Loc loc, FuncLiteralDeclaration *fd, TemplateDeclaration *td = NULL); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + Expression *semantic(Scope *sc, Expressions *arguments); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + Expression *inferType(Scope *sc, Type *t); + void setType(Type *t); + char *toChars(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); + dt_t **toDt(dt_t **pdt); + + int inlineCost3(InlineCostState *ics); + //Expression *doInline(InlineDoState *ids); + //Expression *inlineScan(InlineScanState *iss); +}; + +// Declaration of a symbol + +struct DeclarationExp : Expression +{ + Dsymbol *declaration; + + DeclarationExp(Loc loc, Dsymbol *declaration); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); + + int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct TypeidExp : Expression +{ + Object *obj; + + TypeidExp(Loc loc, Object *obj); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +#if DMDV2 +struct TraitsExp : Expression +{ + Identifier *ident; + Objects *args; + + TraitsExp(Loc loc, Identifier *ident, Objects *args); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; +#endif + +struct HaltExp : Expression +{ + HaltExp(Loc loc); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + elem *toElem(IRState *irs); +}; + +struct IsExp : Expression +{ + /* is(targ id tok tspec) + * is(targ id == tok2) + */ + Type *targ; + Identifier *id; // can be NULL + enum TOK tok; // ':' or '==' + Type *tspec; // can be NULL + enum TOK tok2; // 'struct', 'union', 'typedef', etc. + TemplateParameters *parameters; + + IsExp(Loc loc, Type *targ, Identifier *id, enum TOK tok, Type *tspec, + enum TOK tok2, TemplateParameters *parameters); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +/****************************************************************/ + +struct UnaExp : Expression +{ + Expression *e1; + + UnaExp(Loc loc, enum TOK op, int size, Expression *e1); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *optimize(int result); + void dump(int indent); + Expression *interpretCommon(InterState *istate, CtfeGoal goal, + Expression *(*fp)(Type *, Expression *)); + Expression *resolveLoc(Loc loc, Scope *sc); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); + + virtual Expression *op_overload(Scope *sc); +}; + +struct BinExp : Expression +{ + Expression *e1; + Expression *e2; + + BinExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + Expression *semanticp(Scope *sc); + void checkComplexMulAssign(); + void checkComplexAddAssign(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *scaleFactor(Scope *sc); + Expression *typeCombine(Scope *sc); + Expression *optimize(int result); + int isunsigned(); + Expression *incompatibleTypes(); + void dump(int indent); + Expression *interpretCommon(InterState *istate, CtfeGoal goal, + Expression *(*fp)(Type *, Expression *, Expression *)); + Expression *interpretCommon2(InterState *istate, CtfeGoal goal, + Expression *(*fp)(TOK, Type *, Expression *, Expression *)); + Expression *interpretAssignCommon(InterState *istate, CtfeGoal goal, + Expression *(*fp)(Type *, Expression *, Expression *), int post = 0); + Expression *arrayOp(Scope *sc); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); + + Expression *op_overload(Scope *sc); + Expression *compare_overload(Scope *sc, Identifier *id); + + elem *toElemBin(IRState *irs, int op); +}; + +struct BinAssignExp : BinExp +{ + BinAssignExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2) + : BinExp(loc, op, size, e1, e2) + { + } + + Expression *commonSemanticAssign(Scope *sc); + Expression *commonSemanticAssignIntegral(Scope *sc); + + Expression *op_overload(Scope *sc); + + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *ex); + Expression *modifiableLvalue(Scope *sc, Expression *e); +}; + +/****************************************************************/ + +struct CompileExp : UnaExp +{ + CompileExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct FileExp : UnaExp +{ + FileExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct AssertExp : UnaExp +{ + Expression *msg; + + AssertExp(Loc loc, Expression *e, Expression *msg = NULL); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); + + elem *toElem(IRState *irs); +}; + +struct DotIdExp : UnaExp +{ + Identifier *ident; + + DotIdExp(Loc loc, Expression *e, Identifier *ident); + Expression *semantic(Scope *sc); + Expression *semantic(Scope *sc, int flag); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void dump(int i); +}; + +struct DotTemplateExp : UnaExp +{ + TemplateDeclaration *td; + + DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct DotVarExp : UnaExp +{ + Declaration *var; + int hasOverloads; + + DotVarExp(Loc loc, Expression *e, Declaration *var, int hasOverloads = 0); + Expression *semantic(Scope *sc); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void dump(int indent); + elem *toElem(IRState *irs); +}; + +struct DotTemplateInstanceExp : UnaExp +{ + TemplateInstance *ti; + + DotTemplateInstanceExp(Loc loc, Expression *e, Identifier *name, Objects *tiargs); + Expression *syntaxCopy(); + TemplateDeclaration *getTempdecl(Scope *sc); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void dump(int indent); +}; + +struct DelegateExp : UnaExp +{ + FuncDeclaration *func; + int hasOverloads; + + DelegateExp(Loc loc, Expression *e, FuncDeclaration *func, int hasOverloads = 0); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void dump(int indent); + + int inlineCost3(InlineCostState *ics); + elem *toElem(IRState *irs); +}; + +struct DotTypeExp : UnaExp +{ + Dsymbol *sym; // symbol that represents a type + + DotTypeExp(Loc loc, Expression *e, Dsymbol *sym); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); +}; + +struct CallExp : UnaExp +{ + Expressions *arguments; // function arguments + FuncDeclaration *f; // symbol to call + + CallExp(Loc loc, Expression *e, Expressions *exps); + CallExp(Loc loc, Expression *e); + CallExp(Loc loc, Expression *e, Expression *earg1); + CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2); + + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *resolveUFCS(Scope *sc); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void dump(int indent); + elem *toElem(IRState *irs); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *addDtorHook(Scope *sc); + MATCH implicitConvTo(Type *t); + + int inlineCost3(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct AddrExp : UnaExp +{ + AddrExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + void checkEscape(); + elem *toElem(IRState *irs); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); +}; + +struct PtrExp : UnaExp +{ + PtrExp(Loc loc, Expression *e); + PtrExp(Loc loc, Expression *e, Type *t); + Expression *semantic(Scope *sc); + int isLvalue(); + void checkEscapeRef(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + + // For operator overloading + Identifier *opId(); +}; + +struct NegExp : UnaExp +{ + NegExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + + elem *toElem(IRState *irs); +}; + +struct UAddExp : UnaExp +{ + UAddExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + + // For operator overloading + Identifier *opId(); +}; + +struct ComExp : UnaExp +{ + ComExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + + elem *toElem(IRState *irs); +}; + +struct NotExp : UnaExp +{ + NotExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBit(); + elem *toElem(IRState *irs); +}; + +struct BoolExp : UnaExp +{ + BoolExp(Loc loc, Expression *e, Type *type); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBit(); + elem *toElem(IRState *irs); +}; + +struct DeleteExp : UnaExp +{ + DeleteExp(Loc loc, Expression *e); + Expression *semantic(Scope *sc); + Expression *checkToBoolean(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); +}; + +struct CastExp : UnaExp +{ + // Possible to cast to one type while painting to another type + Type *to; // type to cast to + unsigned mod; // MODxxxxx + + CastExp(Loc loc, Expression *e, Type *t); + CastExp(Loc loc, Expression *e, unsigned mod); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + MATCH implicitConvTo(Type *t); + IntRange getIntRange(); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void checkEscape(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + elem *toElem(IRState *irs); + + // For operator overloading + Identifier *opId(); + Expression *op_overload(Scope *sc); +}; + +struct VectorExp : UnaExp +{ + Type *to; + unsigned dim; // number of elements in the vector + + VectorExp(Loc loc, Expression *e, Type *t); + Expression *syntaxCopy(); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); +}; + +struct SliceExp : UnaExp +{ + Expression *upr; // NULL if implicit 0 + Expression *lwr; // NULL if implicit [length - 1] + VarDeclaration *lengthVar; + + SliceExp(Loc loc, Expression *e1, Expression *lwr, Expression *upr); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + void checkEscape(); + void checkEscapeRef(); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + int isBool(int result); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void dump(int indent); + elem *toElem(IRState *irs); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +struct ArrayLengthExp : UnaExp +{ + ArrayLengthExp(Loc loc, Expression *e1); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); + + static Expression *rewriteOpAssign(BinExp *exp); +}; + +// e1[a0,a1,a2,a3,...] + +struct ArrayExp : UnaExp +{ + Expressions *arguments; // Array of Expression's + size_t currentDimension; // for opDollar + VarDeclaration *lengthVar; + + ArrayExp(Loc loc, Expression *e1, Expressions *arguments); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + // For operator overloading + Identifier *opId(); + Expression *op_overload(Scope *sc); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); +}; + +/****************************************************************/ + +struct DotExp : BinExp +{ + DotExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct CommaExp : BinExp +{ + CommaExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + void checkEscape(); + void checkEscapeRef(); + IntRange getIntRange(); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + int isBool(int result); + MATCH implicitConvTo(Type *t); + Expression *addDtorHook(Scope *sc); + Expression *castTo(Scope *sc, Type *t); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + elem *toElem(IRState *irs); +}; + +struct IndexExp : BinExp +{ + VarDeclaration *lengthVar; + int modifiable; + + IndexExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + Expression *doInline(InlineDoState *ids); + + elem *toElem(IRState *irs); +}; + +/* For both i++ and i-- + */ +struct PostExp : BinExp +{ + PostExp(enum TOK op, Loc loc, Expression *e); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Identifier *opId(); // For operator overloading + elem *toElem(IRState *irs); +}; + +/* For both ++i and --i + */ +struct PreExp : UnaExp +{ + PreExp(enum TOK op, Loc loc, Expression *e); + Expression *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct AssignExp : BinExp +{ int ismemset; // !=0 if setting the contents of an array + + AssignExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *checkToBoolean(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + Identifier *opId(); // For operator overloading + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + elem *toElem(IRState *irs); +}; + +struct ConstructExp : AssignExp +{ + ConstructExp(Loc loc, Expression *e1, Expression *e2); +}; + +#define ASSIGNEXP(op) \ +struct op##AssignExp : BinAssignExp \ +{ \ + op##AssignExp(Loc loc, Expression *e1, Expression *e2); \ + Expression *semantic(Scope *sc); \ + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); \ + X(void buildArrayIdent(OutBuffer *buf, Expressions *arguments);) \ + X(Expression *buildArrayLoop(Parameters *fparams);) \ + \ + Identifier *opId(); /* For operator overloading */ \ + \ + elem *toElem(IRState *irs); \ +}; + +#define X(a) a +ASSIGNEXP(Add) +ASSIGNEXP(Min) +ASSIGNEXP(Mul) +ASSIGNEXP(Div) +ASSIGNEXP(Mod) +ASSIGNEXP(And) +ASSIGNEXP(Or) +ASSIGNEXP(Xor) +#if DMDV2 +ASSIGNEXP(Pow) +#endif +#undef X + +#define X(a) + +ASSIGNEXP(Shl) +ASSIGNEXP(Shr) +ASSIGNEXP(Ushr) +ASSIGNEXP(Cat) + +#undef X +#undef ASSIGNEXP + +struct AddExp : BinExp +{ + AddExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct MinExp : BinExp +{ + MinExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct CatExp : BinExp +{ + CatExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct MulExp : BinExp +{ + MulExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct DivExp : BinExp +{ + DivExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct ModExp : BinExp +{ + ModExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +#if DMDV2 +struct PowExp : BinExp +{ + PowExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; +#endif + +struct ShlExp : BinExp +{ + ShlExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct ShrExp : BinExp +{ + ShrExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct UshrExp : BinExp +{ + UshrExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + IntRange getIntRange(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct AndExp : BinExp +{ + AndExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + IntRange getIntRange(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct OrExp : BinExp +{ + OrExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + MATCH implicitConvTo(Type *t); + IntRange getIntRange(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct XorExp : BinExp +{ + XorExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void buildArrayIdent(OutBuffer *buf, Expressions *arguments); + Expression *buildArrayLoop(Parameters *fparams); + MATCH implicitConvTo(Type *t); + IntRange getIntRange(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct OrOrExp : BinExp +{ + OrOrExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *checkToBoolean(Scope *sc); + int isBit(); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + elem *toElem(IRState *irs); +}; + +struct AndAndExp : BinExp +{ + AndAndExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *checkToBoolean(Scope *sc); + int isBit(); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + elem *toElem(IRState *irs); +}; + +struct CmpExp : BinExp +{ + CmpExp(enum TOK op, Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBit(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Expression *op_overload(Scope *sc); + + elem *toElem(IRState *irs); +}; + +struct InExp : BinExp +{ + InExp(Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBit(); + + // For operator overloading + Identifier *opId(); + Identifier *opId_r(); + + elem *toElem(IRState *irs); +}; + +struct RemoveExp : BinExp +{ + RemoveExp(Loc loc, Expression *e1, Expression *e2); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + elem *toElem(IRState *irs); +}; + +// == and != + +struct EqualExp : BinExp +{ + EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + int isBit(); + + // For operator overloading + int isCommutative(); + Identifier *opId(); + Expression *op_overload(Scope *sc); + + elem *toElem(IRState *irs); +}; + +// === and !=== + +struct IdentityExp : BinExp +{ + IdentityExp(enum TOK op, Loc loc, Expression *e1, Expression *e2); + Expression *semantic(Scope *sc); + int isBit(); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + elem *toElem(IRState *irs); +}; + +/****************************************************************/ + +struct CondExp : BinExp +{ + Expression *econd; + + CondExp(Loc loc, Expression *econd, Expression *e1, Expression *e2); + Expression *syntaxCopy(); + int apply(apply_fp_t fp, void *param); + Expression *semantic(Scope *sc); + Expression *optimize(int result); + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue); + void checkEscape(); + void checkEscapeRef(); + int isLvalue(); + Expression *toLvalue(Scope *sc, Expression *e); + Expression *modifiableLvalue(Scope *sc, Expression *e); + Expression *checkToBoolean(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + MATCH implicitConvTo(Type *t); + Expression *castTo(Scope *sc, Type *t); + + Expression *doInline(InlineDoState *ids); + Expression *inlineScan(InlineScanState *iss); + + elem *toElem(IRState *irs); +}; + +#if DMDV2 +/****************************************************************/ + +struct DefaultInitExp : Expression +{ + enum TOK subop; // which of the derived classes this is + + DefaultInitExp(Loc loc, enum TOK subop, int size); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct FileInitExp : DefaultInitExp +{ + FileInitExp(Loc loc); + Expression *semantic(Scope *sc); + Expression *resolveLoc(Loc loc, Scope *sc); +}; + +struct LineInitExp : DefaultInitExp +{ + LineInitExp(Loc loc); + Expression *semantic(Scope *sc); + Expression *resolveLoc(Loc loc, Scope *sc); +}; +#endif + +/****************************************************************/ + +/* Special values used by the interpreter + */ +#define EXP_CANT_INTERPRET ((Expression *)1) +#define EXP_CONTINUE_INTERPRET ((Expression *)2) +#define EXP_BREAK_INTERPRET ((Expression *)3) +#define EXP_GOTO_INTERPRET ((Expression *)4) +#define EXP_VOID_INTERPRET ((Expression *)5) + +Expression *expType(Type *type, Expression *e); + +Expression *Neg(Type *type, Expression *e1); +Expression *Com(Type *type, Expression *e1); +Expression *Not(Type *type, Expression *e1); +Expression *Bool(Type *type, Expression *e1); +Expression *Cast(Type *type, Type *to, Expression *e1); +Expression *ArrayLength(Type *type, Expression *e1); +Expression *Ptr(Type *type, Expression *e1); + +Expression *Add(Type *type, Expression *e1, Expression *e2); +Expression *Min(Type *type, Expression *e1, Expression *e2); +Expression *Mul(Type *type, Expression *e1, Expression *e2); +Expression *Div(Type *type, Expression *e1, Expression *e2); +Expression *Mod(Type *type, Expression *e1, Expression *e2); +Expression *Pow(Type *type, Expression *e1, Expression *e2); +Expression *Shl(Type *type, Expression *e1, Expression *e2); +Expression *Shr(Type *type, Expression *e1, Expression *e2); +Expression *Ushr(Type *type, Expression *e1, Expression *e2); +Expression *And(Type *type, Expression *e1, Expression *e2); +Expression *Or(Type *type, Expression *e1, Expression *e2); +Expression *Xor(Type *type, Expression *e1, Expression *e2); +Expression *Index(Type *type, Expression *e1, Expression *e2); +Expression *Cat(Type *type, Expression *e1, Expression *e2); + +Expression *Equal(enum TOK op, Type *type, Expression *e1, Expression *e2); +Expression *Cmp(enum TOK op, Type *type, Expression *e1, Expression *e2); +Expression *Identity(enum TOK op, Type *type, Expression *e1, Expression *e2); + +Expression *Slice(Type *type, Expression *e1, Expression *lwr, Expression *upr); + +// Const-folding functions used by CTFE + +void sliceAssignArrayLiteralFromString(ArrayLiteralExp *existingAE, StringExp *newval, int firstIndex); +void sliceAssignStringFromArrayLiteral(StringExp *existingSE, ArrayLiteralExp *newae, int firstIndex); +void sliceAssignStringFromString(StringExp *existingSE, StringExp *newstr, int firstIndex); + + +#endif /* DMD_EXPRESSION_H */ diff --git a/func.c b/func.c new file mode 100644 index 00000000..39ba3aba --- /dev/null +++ b/func.c @@ -0,0 +1,4069 @@ +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "init.h" +#include "declaration.h" +#include "attrib.h" +#include "expression.h" +#include "scope.h" +#include "mtype.h" +#include "aggregate.h" +#include "identifier.h" +#include "id.h" +#include "module.h" +#include "statement.h" +#include "template.h" +#include "hdrgen.h" + +#ifdef IN_GCC +#include "d-dmd-gcc.h" +#endif + +/********************************* FuncDeclaration ****************************/ + +FuncDeclaration::FuncDeclaration(Loc loc, Loc endloc, Identifier *id, StorageClass storage_class, Type *type) + : Declaration(id) +{ + //printf("FuncDeclaration(id = '%s', type = %p)\n", id->toChars(), type); + //printf("storage_class = x%x\n", storage_class); + this->storage_class = storage_class; + this->type = type; + if (type) + this->storage_class &= ~(STC_TYPECTOR | STC_FUNCATTR); + this->loc = loc; + this->endloc = endloc; + fthrows = NULL; + frequire = NULL; + fdrequire = NULL; + fdensure = NULL; + outId = NULL; + vresult = NULL; + returnLabel = NULL; + fensure = NULL; + fbody = NULL; + localsymtab = NULL; + vthis = NULL; + v_arguments = NULL; +#if IN_GCC + v_argptr = NULL; +#endif + v_argsave = NULL; + parameters = NULL; + labtab = NULL; + overnext = NULL; + vtblIndex = -1; + hasReturnExp = 0; + naked = 0; + inlineStatusExp = ILSuninitialized; + inlineStatusStmt = ILSuninitialized; + inlineNest = 0; + isArrayOp = 0; + semanticRun = PASSinit; + semantic3Errors = 0; +#if DMDV1 + nestedFrameRef = 0; +#endif + fes = NULL; + introducing = 0; + tintro = NULL; + /* The type given for "infer the return type" is a TypeFunction with + * NULL for the return type. + */ + inferRetType = (type && type->nextOf() == NULL); + storage_class2 = 0; + hasReturnExp = 0; + nrvo_can = 1; + nrvo_var = NULL; + shidden = NULL; +#if DMDV2 + builtin = BUILTINunknown; + tookAddressOf = 0; + flags = 0; +#endif +} + +Dsymbol *FuncDeclaration::syntaxCopy(Dsymbol *s) +{ + FuncDeclaration *f; + + //printf("FuncDeclaration::syntaxCopy('%s')\n", toChars()); + if (s) + f = (FuncDeclaration *)s; + else + f = new FuncDeclaration(loc, endloc, ident, storage_class, type->syntaxCopy()); + f->outId = outId; + f->frequire = frequire ? frequire->syntaxCopy() : NULL; + f->fensure = fensure ? fensure->syntaxCopy() : NULL; + f->fbody = fbody ? fbody->syntaxCopy() : NULL; + assert(!fthrows); // deprecated + return f; +} + + +// Do the semantic analysis on the external interface to the function. + +void FuncDeclaration::semantic(Scope *sc) +{ TypeFunction *f; + AggregateDeclaration *ad; + StructDeclaration *sd; + ClassDeclaration *cd; + InterfaceDeclaration *id; + Dsymbol *pd; + bool doesoverride; + +#if 0 + printf("FuncDeclaration::semantic(sc = %p, this = %p, '%s', linkage = %d)\n", sc, this, toPrettyChars(), sc->linkage); + if (isFuncLiteralDeclaration()) + printf("\tFuncLiteralDeclaration()\n"); + printf("sc->parent = %s, parent = %s\n", sc->parent->toChars(), parent ? parent->toChars() : ""); + printf("type: %p, %s\n", type, type->toChars()); +#endif + + if (semanticRun != PASSinit && isFuncLiteralDeclaration()) + { + /* Member functions that have return types that are + * forward references can have semantic() run more than + * once on them. + * See test\interface2.d, test20 + */ + return; + } + + parent = sc->parent; + Dsymbol *parent = toParent(); + + if (semanticRun >= PASSsemanticdone) + { + if (!parent->isClassDeclaration()) + { + return; + } + // need to re-run semantic() in order to set the class's vtbl[] + } + else + { + assert(semanticRun <= PASSsemantic); + semanticRun = PASSsemantic; + } + + unsigned dprogress_save = Module::dprogress; + + foverrides.setDim(0); // reset in case semantic() is being retried for this function + + storage_class |= sc->stc & ~STCref; + ad = isThis(); + if (ad) + storage_class |= ad->storage_class & (STC_TYPECTOR | STCsynchronized); + + //printf("function storage_class = x%llx, sc->stc = x%llx, %x\n", storage_class, sc->stc, Declaration::isFinal()); + + if (!originalType) + originalType = type; + if (!type->deco) + { + sc = sc->push(); + sc->stc |= storage_class & STCdisable; // forward to function type + TypeFunction *tf = (TypeFunction *)type; + if (tf->isref) sc->stc |= STCref; + if (tf->isnothrow) sc->stc |= STCnothrow; + if (tf->isproperty) sc->stc |= STCproperty; + if (tf->purity == PUREfwdref) sc->stc |= STCpure; + if (tf->trust == TRUSTsafe) sc->stc |= STCsafe; + if (tf->trust == TRUSTsystem) sc->stc |= STCsystem; + if (tf->trust == TRUSTtrusted) sc->stc |= STCtrusted; + + if (isCtorDeclaration()) + sc->flags |= SCOPEctor; + type = type->semantic(loc, sc); + sc = sc->pop(); + + /* Apply const, immutable and shared storage class + * to the function type + */ + StorageClass stc = storage_class; + if (type->isImmutable()) + stc |= STCimmutable; + if (type->isConst()) + stc |= STCconst; + if (type->isShared() || storage_class & STCsynchronized) + stc |= STCshared; + if (type->isWild()) + stc |= STCwild; + switch (stc & STC_TYPECTOR) + { + case STCimmutable: + case STCimmutable | STCconst: + case STCimmutable | STCconst | STCshared: + case STCimmutable | STCshared: + case STCimmutable | STCwild: + case STCimmutable | STCconst | STCwild: + case STCimmutable | STCconst | STCshared | STCwild: + case STCimmutable | STCshared | STCwild: + // Don't use toInvariant(), as that will do a merge() + type = type->makeInvariant(); + goto Lmerge; + + case STCconst: + case STCconst | STCwild: + type = type->makeConst(); + goto Lmerge; + + case STCshared | STCconst: + case STCshared | STCconst | STCwild: + type = type->makeSharedConst(); + goto Lmerge; + + case STCshared: + type = type->makeShared(); + goto Lmerge; + + case STCwild: + type = type->makeWild(); + goto Lmerge; + + case STCshared | STCwild: + type = type->makeSharedWild(); + goto Lmerge; + + Lmerge: + if (!(type->ty == Tfunction && !type->nextOf())) + /* Can't do merge if return type is not known yet + */ + type->deco = type->merge()->deco; + break; + + case 0: + break; + + default: + assert(0); + } + } + storage_class &= ~STCref; + if (type->ty != Tfunction) + { + error("%s must be a function instead of %s", toChars(), type->toChars()); + return; + } + f = (TypeFunction *)(type); + size_t nparams = Parameter::dim(f->parameters); + + linkage = sc->linkage; + protection = sc->protection; + + /* Purity and safety can be inferred for some functions by examining + * the function body. + */ + if (fbody && + (isFuncLiteralDeclaration() || parent->isTemplateInstance())) + { + if (f->purity == PUREimpure) // purity not specified + flags |= FUNCFLAGpurityInprocess; + + if (f->trust == TRUSTdefault) + flags |= FUNCFLAGsafetyInprocess; + + if (!f->isnothrow) + flags |= FUNCFLAGnothrowInprocess; + } + + if (storage_class & STCscope) + error("functions cannot be scope"); + + if (isAbstract() && !isVirtual()) + error("non-virtual functions cannot be abstract"); + + if (isOverride() && !isVirtual()) + error("cannot override a non-virtual function"); + + if ((f->isConst() || f->isImmutable()) && !isThis()) + error("without 'this' cannot be const/immutable"); + + if (isAbstract() && isFinal()) + error("cannot be both final and abstract"); +#if 0 + if (isAbstract() && fbody) + error("abstract functions cannot have bodies"); +#endif + +#if 0 + if (isStaticConstructor() || isStaticDestructor()) + { + if (!isStatic() || type->nextOf()->ty != Tvoid) + error("static constructors / destructors must be static void"); + if (f->arguments && f->arguments->dim) + error("static constructors / destructors must have empty parameter list"); + // BUG: check for invalid storage classes + } +#endif + +#ifdef IN_GCC + { + AggregateDeclaration *ad = parent->isAggregateDeclaration(); + if (ad) + ad->methods.push(this); + } +#endif + sd = parent->isStructDeclaration(); + if (sd) + { + if (isCtorDeclaration()) + { + goto Ldone; + } +#if 0 + // Verify no constructors, destructors, etc. + if (isCtorDeclaration() + //||isDtorDeclaration() + //|| isInvariantDeclaration() + //|| isUnitTestDeclaration() + ) + { + error("special member functions not allowed for %ss", sd->kind()); + } + + if (!sd->inv) + sd->inv = isInvariantDeclaration(); + + if (!sd->aggNew) + sd->aggNew = isNewDeclaration(); + + if (isDelete()) + { + if (sd->aggDelete) + error("multiple delete's for struct %s", sd->toChars()); + sd->aggDelete = (DeleteDeclaration *)(this); + } +#endif + } + + id = parent->isInterfaceDeclaration(); + if (id) + { + storage_class |= STCabstract; + + if (isCtorDeclaration() || +#if DMDV2 + isPostBlitDeclaration() || +#endif + isDtorDeclaration() || + isInvariantDeclaration() || + isUnitTestDeclaration() || isNewDeclaration() || isDelete()) + error("constructors, destructors, postblits, invariants, unittests, new and delete functions are not allowed in interface %s", id->toChars()); + if (fbody && isVirtual()) + error("function body is not abstract in interface %s", id->toChars()); + } + + /* Contracts can only appear without a body when they are virtual interface functions + */ + if (!fbody && (fensure || frequire) && !(id && isVirtual())) + error("in and out contracts require function body"); + + /* Template member functions aren't virtual: + * interface TestInterface { void tpl(T)(); } + * and so won't work in interfaces + */ + if ((pd = toParent()) != NULL && + pd->isTemplateInstance() && + (pd = toParent2()) != NULL && + (id = pd->isInterfaceDeclaration()) != NULL) + { + error("template member functions are not allowed in interface %s", id->toChars()); + } + + cd = parent->isClassDeclaration(); + if (cd) + { int vi; + CtorDeclaration *ctor; + DtorDeclaration *dtor; + InvariantDeclaration *inv; + + if (isCtorDeclaration()) + { +// ctor = (CtorDeclaration *)this; +// if (!cd->ctor) +// cd->ctor = ctor; + goto Ldone; + } + +#if 0 + dtor = isDtorDeclaration(); + if (dtor) + { + if (cd->dtor) + error("multiple destructors for class %s", cd->toChars()); + cd->dtor = dtor; + } + + inv = isInvariantDeclaration(); + if (inv) + { + cd->inv = inv; + } + + if (isNewDeclaration()) + { + if (!cd->aggNew) + cd->aggNew = (NewDeclaration *)(this); + } + + if (isDelete()) + { + if (cd->aggDelete) + error("multiple delete's for class %s", cd->toChars()); + cd->aggDelete = (DeleteDeclaration *)(this); + } +#endif + + if (storage_class & STCabstract) + cd->isabstract = 1; + + // if static function, do not put in vtbl[] + if (!isVirtual()) + { + //printf("\tnot virtual\n"); + goto Ldone; + } + + /* Find index of existing function in base class's vtbl[] to override + * (the index will be the same as in cd's current vtbl[]) + */ + vi = cd->baseClass ? findVtblIndex((Dsymbols*)&cd->baseClass->vtbl, cd->baseClass->vtbl.dim) + : -1; + + doesoverride = FALSE; + switch (vi) + { + case -1: + /* Didn't find one, so + * This is an 'introducing' function which gets a new + * slot in the vtbl[]. + */ + + // Verify this doesn't override previous final function + if (cd->baseClass) + { Dsymbol *s = cd->baseClass->search(loc, ident, 0); + if (s) + { + FuncDeclaration *f = s->isFuncDeclaration(); + f = f->overloadExactMatch(type); + if (f && f->isFinal() && f->prot() != PROTprivate) + error("cannot override final function %s", f->toPrettyChars()); + } + } + + if (isFinal()) + { + // Don't check here, as it may override an interface function + //if (isOverride()) + //error("is marked as override, but does not override any function"); + cd->vtblFinal.push(this); + } + else + { + // Append to end of vtbl[] + //printf("\tintroducing function\n"); + introducing = 1; + vi = cd->vtbl.dim; + cd->vtbl.push(this); + vtblIndex = vi; + } + break; + + case -2: // can't determine because of fwd refs + cd->sizeok = 2; // can't finish due to forward reference + Module::dprogress = dprogress_save; + return; + + default: + { FuncDeclaration *fdv = (FuncDeclaration *)cd->baseClass->vtbl[vi]; + // This function is covariant with fdv + if (fdv->isFinal()) + error("cannot override final function %s", fdv->toPrettyChars()); + + doesoverride = TRUE; +#if DMDV2 + if (!isOverride()) + warning(loc, "overrides base class function %s, but is not marked with 'override'", fdv->toPrettyChars()); +#endif + + FuncDeclaration *fdc = ((Dsymbol *)cd->vtbl.data[vi])->isFuncDeclaration(); + if (fdc->toParent() == parent) + { + // If both are mixins, then error. + // If either is not, the one that is not overrides the other. + + if (this->parent->isClassDeclaration() && fdc->parent->isClassDeclaration()) + error("multiple overrides of same function"); + + // if (this is mixin) && (fdc is not mixin) then fdc overrides + else if (!this->parent->isClassDeclaration() && fdc->parent->isClassDeclaration()) + break; + + else if (!this->parent->isClassDeclaration() // if both are mixins then error +#if !BREAKABI + && !isDtorDeclaration() +#endif +#if DMDV2 + && !isPostBlitDeclaration() +#endif + ) + error("multiple overrides of same function"); + } + cd->vtbl[vi] = this; + vtblIndex = vi; + + /* Remember which functions this overrides + */ + foverrides.push(fdv); + + /* This works by whenever this function is called, + * it actually returns tintro, which gets dynamically + * cast to type. But we know that tintro is a base + * of type, so we could optimize it by not doing a + * dynamic cast, but just subtracting the isBaseOf() + * offset if the value is != null. + */ + + if (fdv->tintro) + tintro = fdv->tintro; + else if (!type->equals(fdv->type)) + { + /* Only need to have a tintro if the vptr + * offsets differ + */ + int offset; + if (fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset)) + { + tintro = fdv->type; + } + } + break; + } + } + + /* Go through all the interface bases. + * If this function is covariant with any members of those interface + * functions, set the tintro. + */ + for (int i = 0; i < cd->interfaces_dim; i++) + { + BaseClass *b = cd->interfaces[i]; + vi = findVtblIndex((Dsymbols *)&b->base->vtbl, b->base->vtbl.dim); + switch (vi) + { + case -1: + break; + + case -2: + cd->sizeok = 2; // can't finish due to forward reference + Module::dprogress = dprogress_save; + return; + + default: + { FuncDeclaration *fdv = (FuncDeclaration *)b->base->vtbl.tdata()[vi]; + Type *ti = NULL; + + /* Remember which functions this overrides + */ + foverrides.push(fdv); + +#if DMDV2 + /* Should we really require 'override' when implementing + * an interface function? + */ + //if (!isOverride()) + //warning(loc, "overrides base class function %s, but is not marked with 'override'", fdv->toPrettyChars()); +#endif + + if (fdv->tintro) + ti = fdv->tintro; + else if (!type->equals(fdv->type)) + { + /* Only need to have a tintro if the vptr + * offsets differ + */ + unsigned errors = global.errors; + global.gag++; // suppress printing of error messages + int offset; + int baseOf = fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset); + global.gag--; // suppress printing of error messages + if (errors != global.errors) + { + // any error in isBaseOf() is a forward reference error, so we bail out + global.errors = errors; + cd->sizeok = 2; // can't finish due to forward reference + Module::dprogress = dprogress_save; + return; + } + if (baseOf) + { + ti = fdv->type; + } + } + if (ti) + { + if (tintro && !tintro->equals(ti)) + { + error("incompatible covariant types %s and %s", tintro->toChars(), ti->toChars()); + } + tintro = ti; + } + goto L2; + } + } + } + + if (!doesoverride && isOverride()) + { + error("does not override any function"); + } + + L2: ; + + /* Go through all the interface bases. + * Disallow overriding any final functions in the interface(s). + */ + for (int i = 0; i < cd->interfaces_dim; i++) + { + BaseClass *b = cd->interfaces[i]; + if (b->base) + { + Dsymbol *s = search_function(b->base, ident); + if (s) + { + FuncDeclaration *f = s->isFuncDeclaration(); + if (f) + { + f = f->overloadExactMatch(type); + if (f && f->isFinal() && f->prot() != PROTprivate) + error("cannot override final function %s.%s", b->base->toChars(), f->toPrettyChars()); + } + } + } + } + } + else if (isOverride() && !parent->isTemplateInstance()) + error("override only applies to class member functions"); + + /* Do not allow template instances to add virtual functions + * to a class. + */ + if (isVirtual()) + { + TemplateInstance *ti = parent->isTemplateInstance(); + if (ti) + { + // Take care of nested templates + while (1) + { + TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance(); + if (!ti2) + break; + ti = ti2; + } + + // If it's a member template + ClassDeclaration *cd = ti->tempdecl->isClassMember(); + if (cd) + { + error("cannot use template to add virtual function to class '%s'", cd->toChars()); + } + } + } + + if (isMain()) + { + // Check parameters to see if they are either () or (char[][] args) + switch (nparams) + { + case 0: + break; + + case 1: + { + Parameter *arg0 = Parameter::getNth(f->parameters, 0); + if (arg0->type->ty != Tarray || + arg0->type->nextOf()->ty != Tarray || + arg0->type->nextOf()->nextOf()->ty != Tchar || + arg0->storageClass & (STCout | STCref | STClazy)) + goto Lmainerr; + break; + } + + default: + goto Lmainerr; + } + + if (!f->nextOf()) + error("must return int or void"); + else if (f->nextOf()->ty != Tint32 && f->nextOf()->ty != Tvoid) + error("must return int or void, not %s", f->nextOf()->toChars()); + if (f->varargs) + { + Lmainerr: + error("parameters must be main() or main(string[] args)"); + } + } + + if (ident == Id::assign && (sd || cd)) + { // Disallow identity assignment operator. + + // opAssign(...) + if (nparams == 0) + { if (f->varargs == 1) + goto Lassignerr; + } + else + { + Parameter *arg0 = Parameter::getNth(f->parameters, 0); + Type *t0 = arg0->type->toBasetype(); + Type *tb = sd ? sd->type : cd->type; + if (arg0->type->implicitConvTo(tb) || + (sd && t0->ty == Tpointer && t0->nextOf()->implicitConvTo(tb)) + ) + { + if (nparams == 1) + goto Lassignerr; + Parameter *arg1 = Parameter::getNth(f->parameters, 1); + if (arg1->defaultArg) + goto Lassignerr; + } + } + } + + if (isVirtual() && semanticRun != PASSsemanticdone) + { + /* Rewrite contracts as nested functions, then call them. + * Doing it as nested functions means that overriding functions + * can call them. + */ + if (frequire) + { /* in { ... } + * becomes: + * void __require() { ... } + * __require(); + */ + Loc loc = frequire->loc; + TypeFunction *tf = new TypeFunction(NULL, Type::tvoid, 0, LINKd); + FuncDeclaration *fd = new FuncDeclaration(loc, loc, + Id::require, STCundefined, tf); + fd->fbody = frequire; + Statement *s1 = new ExpStatement(loc, fd); + Expression *e = new CallExp(loc, new VarExp(loc, fd, 0), (Expressions *)NULL); + Statement *s2 = new ExpStatement(loc, e); + frequire = new CompoundStatement(loc, s1, s2); + fdrequire = fd; + } + + if (!outId && f->nextOf() && f->nextOf()->toBasetype()->ty != Tvoid) + outId = Id::result; // provide a default + + if (fensure) + { /* out (result) { ... } + * becomes: + * tret __ensure(ref tret result) { ... } + * __ensure(result); + */ + Loc loc = fensure->loc; + Parameters *arguments = new Parameters(); + Parameter *a = NULL; + if (outId) + { a = new Parameter(STCref | STCconst, f->nextOf(), outId, NULL); + arguments->push(a); + } + TypeFunction *tf = new TypeFunction(arguments, Type::tvoid, 0, LINKd); + FuncDeclaration *fd = new FuncDeclaration(loc, loc, + Id::ensure, STCundefined, tf); + fd->fbody = fensure; + Statement *s1 = new ExpStatement(loc, fd); + Expression *eresult = NULL; + if (outId) + eresult = new IdentifierExp(loc, outId); + Expression *e = new CallExp(loc, new VarExp(loc, fd, 0), eresult); + Statement *s2 = new ExpStatement(loc, e); + fensure = new CompoundStatement(loc, s1, s2); + fdensure = fd; + } + } + +Ldone: + Module::dprogress++; + semanticRun = PASSsemanticdone; + + /* Save scope for possible later use (if we need the + * function internals) + */ + scope = new Scope(*sc); + scope->setNoFree(); + return; + +Lassignerr: + if (sd) + { + sd->hasIdentityAssign = 1; // don't need to generate it + goto Ldone; + } + error("identity assignment operator overload is illegal"); +} + +void FuncDeclaration::semantic2(Scope *sc) +{ +} + +// Do the semantic analysis on the internals of the function. + +void FuncDeclaration::semantic3(Scope *sc) +{ TypeFunction *f; + VarDeclaration *argptr = NULL; + VarDeclaration *_arguments = NULL; + int nerrors = global.errors; + + if (!parent) + { + if (global.errors) + return; + //printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", kind(), toChars(), sc); + assert(0); + } + //printf("FuncDeclaration::semantic3('%s.%s', sc = %p, loc = %s)\n", parent->toChars(), toChars(), sc, loc.toChars()); + //fflush(stdout); + //printf("storage class = x%x %x\n", sc->stc, storage_class); + //{ static int x; if (++x == 2) *(char*)0=0; } + //printf("\tlinkage = %d\n", sc->linkage); + + //printf(" sc->incontract = %d\n", sc->incontract); + if (semanticRun >= PASSsemantic3) + return; + semanticRun = PASSsemantic3; + semantic3Errors = 0; + + if (!type || type->ty != Tfunction) + return; + f = (TypeFunction *)(type); + +#if 0 + // Check the 'throws' clause + if (fthrows) + { + for (int i = 0; i < fthrows->dim; i++) + { + Type *t = fthrows->tdata()[i]; + + t = t->semantic(loc, sc); + if (!t->isClassHandle()) + error("can only throw classes, not %s", t->toChars()); + } + } +#endif + + if (frequire) + { + for (int i = 0; i < foverrides.dim; i++) + { + FuncDeclaration *fdv = foverrides.tdata()[i]; + + if (fdv->fbody && !fdv->frequire) + { + error("cannot have an in contract when overriden function %s does not have an in contract", fdv->toPrettyChars()); + break; + } + } + } + + frequire = mergeFrequire(frequire); + fensure = mergeFensure(fensure); + + if (fbody || frequire || fensure) + { + /* Symbol table into which we place parameters and nested functions, + * solely to diagnose name collisions. + */ + localsymtab = new DsymbolTable(); + + // Establish function scope + ScopeDsymbol *ss = new ScopeDsymbol(); + ss->parent = sc->scopesym; + Scope *sc2 = sc->push(ss); + sc2->func = this; + sc2->parent = this; + sc2->callSuper = 0; + sc2->sbreak = NULL; + sc2->scontinue = NULL; + sc2->sw = NULL; + sc2->fes = fes; + sc2->linkage = LINKd; + sc2->stc &= ~(STCauto | STCscope | STCstatic | STCabstract | + STCdeprecated | STCoverride | + STC_TYPECTOR | STCfinal | STCtls | STCgshared | STCref | + STCproperty | STCsafe | STCtrusted | STCsystem); + sc2->protection = PROTpublic; + sc2->explicitProtection = 0; + sc2->structalign = 8; + sc2->incontract = 0; + sc2->tf = NULL; + sc2->noctor = 0; + + // Declare 'this' + AggregateDeclaration *ad = isThis(); + if (ad) + { + if (isFuncLiteralDeclaration() && isNested() && !sc->intypeof) + { + error("function literals cannot be class members"); + return; + } + else + assert(!isNested() || sc->intypeof); // can't be both member and nested + } + vthis = declareThis(sc2, ad); + + // Declare hidden variable _arguments[] and _argptr + if (f->varargs == 1) + { +#if TARGET_NET + varArgs(sc2, f, argptr, _arguments); +#else + Type *t; + + if (global.params.is64bit) + { // Declare save area for varargs registers + Type *t = new TypeIdentifier(loc, Id::va_argsave_t); + t = t->semantic(loc, sc); + if (t == Type::terror) + { + error("must import core.vararg to use variadic functions"); + return; + } + else + { + v_argsave = new VarDeclaration(loc, t, Id::va_argsave, NULL); + v_argsave->semantic(sc2); + sc2->insert(v_argsave); + v_argsave->parent = this; + } + } + + if (f->linkage == LINKd) + { // Declare _arguments[] +#if BREAKABI + v_arguments = new VarDeclaration(0, Type::typeinfotypelist->type, Id::_arguments_typeinfo, NULL); + v_arguments->storage_class = STCparameter; + v_arguments->semantic(sc2); + sc2->insert(v_arguments); + v_arguments->parent = this; + + //t = Type::typeinfo->type->constOf()->arrayOf(); + t = Type::typeinfo->type->arrayOf(); + _arguments = new VarDeclaration(0, t, Id::_arguments, NULL); + _arguments->semantic(sc2); + sc2->insert(_arguments); + _arguments->parent = this; +#else + t = Type::typeinfo->type->arrayOf(); + v_arguments = new VarDeclaration(0, t, Id::_arguments, NULL); + v_arguments->storage_class = STCparameter | STCin; + v_arguments->semantic(sc2); + sc2->insert(v_arguments); + v_arguments->parent = this; +#endif + } + if (f->linkage == LINKd || (f->parameters && Parameter::dim(f->parameters))) + { // Declare _argptr +#if IN_GCC + t = d_gcc_builtin_va_list_d_type; +#else + t = Type::tvoid->pointerTo(); +#endif + argptr = new VarDeclaration(0, t, Id::_argptr, NULL); + argptr->semantic(sc2); + sc2->insert(argptr); + argptr->parent = this; + } +#endif + } + +#if 0 + // Propagate storage class from tuple parameters to their element-parameters. + if (f->parameters) + { + for (size_t i = 0; i < f->parameters->dim; i++) + { Parameter *arg = f->parameters->tdata()[i]; + + //printf("[%d] arg->type->ty = %d %s\n", i, arg->type->ty, arg->type->toChars()); + if (arg->type->ty == Ttuple) + { TypeTuple *t = (TypeTuple *)arg->type; + size_t dim = Parameter::dim(t->arguments); + for (size_t j = 0; j < dim; j++) + { Parameter *narg = Parameter::getNth(t->arguments, j); + narg->storageClass = arg->storageClass; + } + } + } + } +#endif + + /* Declare all the function parameters as variables + * and install them in parameters[] + */ + size_t nparams = Parameter::dim(f->parameters); + if (nparams) + { /* parameters[] has all the tuples removed, as the back end + * doesn't know about tuples + */ + parameters = new VarDeclarations(); + parameters->reserve(nparams); + for (size_t i = 0; i < nparams; i++) + { + Parameter *arg = Parameter::getNth(f->parameters, i); + Identifier *id = arg->ident; + if (!id) + { + /* Generate identifier for un-named parameter, + * because we need it later on. + */ + arg->ident = id = Identifier::generateId("_param_", i); + } + Type *vtype = arg->type; + //if (isPure()) + //vtype = vtype->addMod(MODconst); + VarDeclaration *v = new VarDeclaration(loc, vtype, id, NULL); + //printf("declaring parameter %s of type %s\n", v->toChars(), v->type->toChars()); + v->storage_class |= STCparameter; + if (f->varargs == 2 && i + 1 == nparams) + v->storage_class |= STCvariadic; + v->storage_class |= arg->storageClass & (STCin | STCout | STCref | STClazy | STCfinal | STC_TYPECTOR | STCnodtor); + v->semantic(sc2); + if (!sc2->insert(v)) + error("parameter %s.%s is already defined", toChars(), v->toChars()); + else + parameters->push(v); + localsymtab->insert(v); + v->parent = this; + } + } + + // Declare the tuple symbols and put them in the symbol table, + // but not in parameters[]. + if (f->parameters) + { + for (size_t i = 0; i < f->parameters->dim; i++) + { Parameter *arg = f->parameters->tdata()[i]; + + if (!arg->ident) + continue; // never used, so ignore + if (arg->type->ty == Ttuple) + { TypeTuple *t = (TypeTuple *)arg->type; + size_t dim = Parameter::dim(t->arguments); + Objects *exps = new Objects(); + exps->setDim(dim); + for (size_t j = 0; j < dim; j++) + { Parameter *narg = Parameter::getNth(t->arguments, j); + assert(narg->ident); + VarDeclaration *v = sc2->search(0, narg->ident, NULL)->isVarDeclaration(); + assert(v); + Expression *e = new VarExp(v->loc, v); + exps->tdata()[j] = e; + } + assert(arg->ident); + TupleDeclaration *v = new TupleDeclaration(loc, arg->ident, exps); + //printf("declaring tuple %s\n", v->toChars()); + v->isexp = 1; + if (!sc2->insert(v)) + error("parameter %s.%s is already defined", toChars(), v->toChars()); + localsymtab->insert(v); + v->parent = this; + } + } + } + + /* Do the semantic analysis on the [in] preconditions and + * [out] postconditions. + */ + sc2->incontract++; + + if (frequire) + { /* frequire is composed of the [in] contracts + */ + // BUG: need to error if accessing out parameters + // BUG: need to treat parameters as const + // BUG: need to disallow returns and throws + // BUG: verify that all in and ref parameters are read + frequire = frequire->semantic(sc2); + labtab = NULL; // so body can't refer to labels + } + + if (fensure || addPostInvariant()) + { /* fensure is composed of the [out] contracts + */ + if (!type->nextOf()) // if return type is inferred + { /* This case: + * auto fp = function() out { } body { }; + * Can fix by doing semantic() onf fbody first. + */ + error("post conditions are not supported if the return type is inferred"); + return; + } + + ScopeDsymbol *sym = new ScopeDsymbol(); + sym->parent = sc2->scopesym; + sc2 = sc2->push(sym); + + assert(type->nextOf()); + if (type->nextOf()->ty == Tvoid) + { + if (outId) + error("void functions have no result"); + } + else + { + if (!outId) + outId = Id::result; // provide a default + } + + if (outId) + { // Declare result variable + Loc loc = this->loc; + + if (fensure) + loc = fensure->loc; + + VarDeclaration *v = new VarDeclaration(loc, type->nextOf(), outId, NULL); + v->noscope = 1; + v->storage_class |= STCresult; +#if DMDV2 + if (!isVirtual()) + v->storage_class |= STCconst; + if (f->isref) + { + v->storage_class |= STCref | STCforeach; + } +#endif + sc2->incontract--; + v->semantic(sc2); + sc2->incontract++; + if (!sc2->insert(v)) + error("out result %s is already defined", v->toChars()); + v->parent = this; + vresult = v; + + // vresult gets initialized with the function return value + // in ReturnStatement::semantic() + } + + // BUG: need to treat parameters as const + // BUG: need to disallow returns and throws + if (fensure) + { fensure = fensure->semantic(sc2); + labtab = NULL; // so body can't refer to labels + } + + if (!global.params.useOut) + { fensure = NULL; // discard + vresult = NULL; + } + + // Postcondition invariant + if (addPostInvariant()) + { + Expression *e = NULL; + if (isCtorDeclaration()) + { + // Call invariant directly only if it exists + InvariantDeclaration *inv = ad->inv; + ClassDeclaration *cd = ad->isClassDeclaration(); + + while (!inv && cd) + { + cd = cd->baseClass; + if (!cd) + break; + inv = cd->inv; + } + if (inv) + { + e = new DsymbolExp(0, inv); + e = new CallExp(0, e); + e = e->semantic(sc2); + } + } + else + { // Call invariant virtually + Expression *v = new ThisExp(0); + v->type = vthis->type; +#if STRUCTTHISREF + if (ad->isStructDeclaration()) + v = v->addressOf(sc); +#endif + e = new AssertExp(0, v); + } + if (e) + { + ExpStatement *s = new ExpStatement(0, e); + if (fensure) + fensure = new CompoundStatement(0, s, fensure); + else + fensure = s; + } + } + + if (fensure) + { returnLabel = new LabelDsymbol(Id::returnLabel); + LabelStatement *ls = new LabelStatement(0, Id::returnLabel, fensure); + returnLabel->statement = ls; + } + sc2 = sc2->pop(); + } + + sc2->incontract--; + + if (fbody) + { AggregateDeclaration *ad = isAggregateMember(); + + /* If this is a class constructor + */ + if (ad && isCtorDeclaration()) + { + for (size_t i = 0; i < ad->fields.dim; i++) + { VarDeclaration *v = ad->fields[i]; + + v->ctorinit = 0; + } + } + + if (inferRetType || f->retStyle() != RETstack) + nrvo_can = 0; + + fbody = fbody->semantic(sc2); + if (!fbody) + fbody = new CompoundStatement(0, new Statements()); + + if (inferRetType) + { // If no return type inferred yet, then infer a void + if (!type->nextOf()) + { + ((TypeFunction *)type)->next = Type::tvoid; + //type = type->semantic(loc, sc); // Removed with 6902 + } + f = (TypeFunction *)type; + } + + if (isStaticCtorDeclaration()) + { /* It's a static constructor. Ensure that all + * ctor consts were initialized. + */ + + Dsymbol *p = toParent(); + ScopeDsymbol *pd = p->isScopeDsymbol(); + if (!pd) + { + error("static constructor can only be member of struct/class/module, not %s %s", p->kind(), p->toChars()); + } + else + { + for (size_t i = 0; i < pd->members->dim; i++) + { Dsymbol *s = pd->members->tdata()[i]; + + s->checkCtorConstInit(); + } + } + } + + if (isCtorDeclaration() && ad) + { + //printf("callSuper = x%x\n", sc2->callSuper); + + ClassDeclaration *cd = ad->isClassDeclaration(); + + // Verify that all the ctorinit fields got initialized + if (!(sc2->callSuper & CSXthis_ctor)) + { + for (size_t i = 0; i < ad->fields.dim; i++) + { VarDeclaration *v = ad->fields[i]; + + if (v->ctorinit == 0) + { + /* Current bugs in the flow analysis: + * 1. union members should not produce error messages even if + * not assigned to + * 2. structs should recognize delegating opAssign calls as well + * as delegating calls to other constructors + */ + if (v->isCtorinit() && !v->type->isMutable() && cd) + error("missing initializer for final field %s", v->toChars()); + else if (v->storage_class & STCnodefaultctor) + error("field %s must be initialized in constructor", v->toChars()); + } + } + } + + if (cd && + !(sc2->callSuper & CSXany_ctor) && + cd->baseClass && cd->baseClass->ctor) + { + sc2->callSuper = 0; + + // Insert implicit super() at start of fbody + Expression *e1 = new SuperExp(0); + Expression *e = new CallExp(0, e1); + + e = e->trySemantic(sc2); + if (!e) + error("no match for implicit super() call in constructor"); + else + { + Statement *s = new ExpStatement(0, e); + fbody = new CompoundStatement(0, s, fbody); + } + } + } + else if (fes) + { // For foreach(){} body, append a return 0; + Expression *e = new IntegerExp(0); + Statement *s = new ReturnStatement(0, e); + fbody = new CompoundStatement(0, fbody, s); + assert(!returnLabel); + } + else if (!hasReturnExp && type->nextOf()->ty != Tvoid) + error("has no return statement, but is expected to return a value of type %s", type->nextOf()->toChars()); + else if (hasReturnExp & 8) // if inline asm + { + flags &= ~FUNCFLAGnothrowInprocess; + } + else + { +#if DMDV2 + // Check for errors related to 'nothrow'. + int nothrowErrors = global.errors; + int blockexit = fbody ? fbody->blockExit(f->isnothrow) : BEfallthru; + if (f->isnothrow && (global.errors != nothrowErrors) ) + error("'%s' is nothrow yet may throw", toChars()); + if (flags & FUNCFLAGnothrowInprocess) + { + flags &= ~FUNCFLAGnothrowInprocess; + if (!(blockexit & BEthrow)) + f->isnothrow = TRUE; + } + + int offend = blockexit & BEfallthru; +#endif + if (type->nextOf()->ty == Tvoid) + { + if (offend && isMain()) + { // Add a return 0; statement + Statement *s = new ReturnStatement(0, new IntegerExp(0)); + fbody = new CompoundStatement(0, fbody, s); + } + } + else + { + if (offend) + { Expression *e; +#if DMDV1 + warning(loc, "no return exp; or assert(0); at end of function"); +#else + error("no return exp; or assert(0); at end of function"); +#endif + if (global.params.useAssert && + !global.params.useInline) + { /* Add an assert(0, msg); where the missing return + * should be. + */ + e = new AssertExp( + endloc, + new IntegerExp(0), + new StringExp(loc, (char *)"missing return expression") + ); + } + else + e = new HaltExp(endloc); + e = new CommaExp(0, e, type->nextOf()->defaultInit()); + e = e->semantic(sc2); + Statement *s = new ExpStatement(0, e); + fbody = new CompoundStatement(0, fbody, s); + } + } + } + } + + { + Statements *a = new Statements(); + + // Merge in initialization of 'out' parameters + if (parameters) + { for (size_t i = 0; i < parameters->dim; i++) + { + VarDeclaration *v = parameters->tdata()[i]; + if (v->storage_class & STCout) + { + assert(v->init); + ExpInitializer *ie = v->init->isExpInitializer(); + assert(ie); + if (ie->exp->op == TOKconstruct) + ie->exp->op = TOKassign; // construction occured in parameter processing + a->push(new ExpStatement(0, ie->exp)); + } + } + } + + if (argptr) + { // Initialize _argptr +#if IN_GCC + // Handled in FuncDeclaration::toObjFile + v_argptr = argptr; + v_argptr->init = new VoidInitializer(loc); +#else + Type *t = argptr->type; + if (global.params.is64bit) + { // Initialize _argptr to point to v_argsave + Expression *e1 = new VarExp(0, argptr); + Expression *e = new SymOffExp(0, v_argsave, 6*8 + 8*16); + e->type = argptr->type; + e = new AssignExp(0, e1, e); + e = e->semantic(sc); + a->push(new ExpStatement(0, e)); + } + else + { // Initialize _argptr to point past non-variadic arg + VarDeclaration *p; + unsigned offset = 0; + + Expression *e1 = new VarExp(0, argptr); + // Find the last non-ref parameter + if (parameters && parameters->dim) + { + int lastNonref = parameters->dim -1; + p = parameters->tdata()[lastNonref]; + /* The trouble with out and ref parameters is that taking + * the address of it doesn't work, because later processing + * adds in an extra level of indirection. So we skip over them. + */ + while (p->storage_class & (STCout | STCref)) + { + --lastNonref; + offset += PTRSIZE; + if (lastNonref < 0) + { + p = v_arguments; + break; + } + p = parameters->tdata()[lastNonref]; + } + } + else + p = v_arguments; // last parameter is _arguments[] + if (p->storage_class & STClazy) + // If the last parameter is lazy, it's the size of a delegate + offset += PTRSIZE * 2; + else + offset += p->type->size(); + offset = (offset + PTRSIZE - 1) & ~(PTRSIZE - 1); // assume stack aligns on pointer size + Expression *e = new SymOffExp(0, p, offset); + e->type = Type::tvoidptr; + //e = e->semantic(sc); + e = new AssignExp(0, e1, e); + e->type = t; + a->push(new ExpStatement(0, e)); + p->isargptr = TRUE; + } +#endif + } + + if (_arguments) + { + /* Advance to elements[] member of TypeInfo_Tuple with: + * _arguments = v_arguments.elements; + */ + Expression *e = new VarExp(0, v_arguments); + e = new DotIdExp(0, e, Id::elements); + Expression *e1 = new VarExp(0, _arguments); + e = new ConstructExp(0, e1, e); + e = e->semantic(sc2); + a->push(new ExpStatement(0, e)); + } + + // Merge contracts together with body into one compound statement + + if (frequire && global.params.useIn) + { frequire->incontract = 1; + a->push(frequire); + } + + // Precondition invariant + if (addPreInvariant()) + { + Expression *e = NULL; + if (isDtorDeclaration()) + { + // Call invariant directly only if it exists + InvariantDeclaration *inv = ad->inv; + ClassDeclaration *cd = ad->isClassDeclaration(); + + while (!inv && cd) + { + cd = cd->baseClass; + if (!cd) + break; + inv = cd->inv; + } + if (inv) + { + e = new DsymbolExp(0, inv); + e = new CallExp(0, e); + e = e->semantic(sc2); + } + } + else + { // Call invariant virtually + Expression *v = new ThisExp(0); + v->type = vthis->type; +#if STRUCTTHISREF + if (ad->isStructDeclaration()) + v = v->addressOf(sc); +#endif + Expression *se = new StringExp(0, (char *)"null this"); + se = se->semantic(sc); + se->type = Type::tchar->arrayOf(); + e = new AssertExp(loc, v, se); + } + if (e) + { + ExpStatement *s = new ExpStatement(0, e); + a->push(s); + } + } + + if (fbody) + a->push(fbody); + + if (fensure) + { + a->push(returnLabel->statement); + + if (type->nextOf()->ty != Tvoid) + { + // Create: return vresult; + assert(vresult); + Expression *e = new VarExp(0, vresult); + if (tintro) + { e = e->implicitCastTo(sc, tintro->nextOf()); + e = e->semantic(sc); + } + ReturnStatement *s = new ReturnStatement(0, e); + a->push(s); + } + } + + fbody = new CompoundStatement(0, a); +#if DMDV2 + /* Append destructor calls for parameters as finally blocks. + */ + if (parameters) + { for (size_t i = 0; i < parameters->dim; i++) + { + VarDeclaration *v = parameters->tdata()[i]; + + if (v->storage_class & (STCref | STCout)) + continue; + + /* Don't do this for static arrays, since static + * arrays are called by reference. Remove this + * when we change them to call by value. + */ + if (v->type->toBasetype()->ty == Tsarray) + continue; + + if (v->noscope) + continue; + + Expression *e = v->edtor; + if (e) + { Statement *s = new ExpStatement(0, e); + s = s->semantic(sc2); + if (fbody->blockExit(f->isnothrow) == BEfallthru) + fbody = new CompoundStatement(0, fbody, s); + else + fbody = new TryFinallyStatement(0, fbody, s); + } + } + } +#endif + +#if 1 + if (isSynchronized()) + { /* Wrap the entire function body in a synchronized statement + */ + AggregateDeclaration *ad = isThis(); + ClassDeclaration *cd = ad ? ad->isClassDeclaration() : parent->isClassDeclaration(); + + if (cd) + { +#if TARGET_WINDOS + if (/*config.flags2 & CFG2seh &&*/ // always on for WINDOS + !isStatic() && !fbody->usesEH()) + { + /* The back end uses the "jmonitor" hack for syncing; + * no need to do the sync at this level. + */ + } + else +#endif + { + Expression *vsync; + if (isStatic()) + { // The monitor is in the ClassInfo + vsync = new DotIdExp(loc, new DsymbolExp(loc, cd), Id::classinfo); + } + else + { // 'this' is the monitor + vsync = new VarExp(loc, vthis); + } + fbody = new PeelStatement(fbody); // don't redo semantic() + fbody = new SynchronizedStatement(loc, vsync, fbody); + fbody = fbody->semantic(sc2); + } + } + else + { + error("synchronized function %s must be a member of a class", toChars()); + } + } +#endif + } + + sc2->callSuper = 0; + sc2->pop(); + } + + /* If function survived being marked as impure, then it is pure + */ + if (flags & FUNCFLAGpurityInprocess) + { + flags &= ~FUNCFLAGpurityInprocess; + f->purity = PUREfwdref; + } + + if (flags & FUNCFLAGsafetyInprocess) + { + flags &= ~FUNCFLAGsafetyInprocess; + f->trust = TRUSTsafe; + } + + // Do semantic type AFTER pure/nothrow inference. + if (inferRetType) + { + type = type->semantic(loc, sc); + } + + if (global.gag && global.errors != nerrors) + semanticRun = PASSsemanticdone; // Ensure errors get reported again + else + { + semanticRun = PASSsemantic3done; + semantic3Errors = global.errors - nerrors; + } + //printf("-FuncDeclaration::semantic3('%s.%s', sc = %p, loc = %s)\n", parent->toChars(), toChars(), sc, loc.toChars()); + //fflush(stdout); +} + +void FuncDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + //printf("FuncDeclaration::toCBuffer() '%s'\n", toChars()); + + StorageClassDeclaration::stcToCBuffer(buf, storage_class); + type->toCBuffer(buf, ident, hgs); + bodyToCBuffer(buf, hgs); +} + +VarDeclaration *FuncDeclaration::declareThis(Scope *sc, AggregateDeclaration *ad) +{ + if (ad) + { VarDeclaration *v; + + { + assert(ad->handle); + Type *thandle = ad->handle; +#if STRUCTTHISREF + thandle = thandle->addMod(type->mod); + thandle = thandle->addStorageClass(storage_class); + //if (isPure()) + //thandle = thandle->addMod(MODconst); +#else + if (storage_class & STCconst || type->isConst()) + { + assert(0); // BUG: shared not handled + if (thandle->ty == Tclass) + thandle = thandle->constOf(); + else + { assert(thandle->ty == Tpointer); + thandle = thandle->nextOf()->constOf()->pointerTo(); + } + } + else if (storage_class & STCimmutable || type->isImmutable()) + { + if (thandle->ty == Tclass) + thandle = thandle->invariantOf(); + else + { assert(thandle->ty == Tpointer); + thandle = thandle->nextOf()->invariantOf()->pointerTo(); + } + } + else if (storage_class & STCshared || type->isShared()) + { + assert(0); // not implemented + } +#endif + v = new ThisDeclaration(loc, thandle); + //v = new ThisDeclaration(loc, isCtorDeclaration() ? ad->handle : thandle); + v->storage_class |= STCparameter; +#if STRUCTTHISREF + if (thandle->ty == Tstruct) + v->storage_class |= STCref; +#endif + v->semantic(sc); + if (!sc->insert(v)) + assert(0); + v->parent = this; + return v; + } + } + else if (isNested()) + { + /* The 'this' for a nested function is the link to the + * enclosing function's stack frame. + * Note that nested functions and member functions are disjoint. + */ + VarDeclaration *v = new ThisDeclaration(loc, Type::tvoid->pointerTo()); + v->storage_class |= STCparameter; + v->semantic(sc); + if (!sc->insert(v)) + assert(0); + v->parent = this; + return v; + } + + return NULL; +} + +int FuncDeclaration::equals(Object *o) +{ + if (this == o) + return TRUE; + + Dsymbol *s = isDsymbol(o); + if (s) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { + return toParent()->equals(fd->toParent()) && + ident->equals(fd->ident) && type->equals(fd->type); + } + } + return FALSE; +} + +void FuncDeclaration::bodyToCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (fbody && + (!hgs->hdrgen || hgs->tpltMember || canInline(1,1,1)) + ) + { buf->writenl(); + + // in{} + if (frequire) + { buf->writestring("in"); + buf->writenl(); + frequire->toCBuffer(buf, hgs); + } + + // out{} + if (fensure) + { buf->writestring("out"); + if (outId) + { buf->writebyte('('); + buf->writestring(outId->toChars()); + buf->writebyte(')'); + } + buf->writenl(); + fensure->toCBuffer(buf, hgs); + } + + if (frequire || fensure) + { buf->writestring("body"); + buf->writenl(); + } + + buf->writebyte('{'); + buf->writenl(); + fbody->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); + } + else + { buf->writeByte(';'); + buf->writenl(); + } +} + +/**************************************************** + * Merge into this function the 'in' contracts of all it overrides. + * 'in's are OR'd together, i.e. only one of them needs to pass. + */ + +Statement *FuncDeclaration::mergeFrequire(Statement *sf) +{ + /* If a base function and its override both have an IN contract, then + * only one of them needs to succeed. This is done by generating: + * + * void derived.in() { + * try { + * base.in(); + * } + * catch () { + * ... body of derived.in() ... + * } + * } + * + * So if base.in() doesn't throw, derived.in() need not be executed, and the contract is valid. + * If base.in() throws, then derived.in()'s body is executed. + */ + + /* Implementing this is done by having the overriding function call + * nested functions (the fdrequire functions) nested inside the overridden + * function. This requires that the stack layout of the calling function's + * parameters and 'this' pointer be in the same place (as the nested + * function refers to them). + * This is easy for the parameters, as they are all on the stack in the same + * place by definition, since it's an overriding function. The problem is + * getting the 'this' pointer in the same place, since it is a local variable. + * We did some hacks in the code generator to make this happen: + * 1. always generate exception handler frame, or at least leave space for it + * in the frame (Windows 32 SEH only) + * 2. always generate an EBP style frame + * 3. since 'this' is passed in a register that is subsequently copied into + * a stack local, allocate that local immediately following the exception + * handler block, so it is always at the same offset from EBP. + */ + for (int i = 0; i < foverrides.dim; i++) + { + FuncDeclaration *fdv = foverrides.tdata()[i]; + + /* The semantic pass on the contracts of the overridden functions must + * be completed before code generation occurs (bug 3602). + */ + if (fdv->fdrequire && fdv->fdrequire->semanticRun != PASSsemantic3done) + { + assert(fdv->scope); + Scope *sc = fdv->scope->push(); + sc->stc &= ~STCoverride; + fdv->semantic3(sc); + sc->pop(); + } + + sf = fdv->mergeFrequire(sf); + if (sf && fdv->fdrequire) + { + //printf("fdv->frequire: %s\n", fdv->frequire->toChars()); + /* Make the call: + * try { __require(); } + * catch { frequire; } + */ + Expression *eresult = NULL; + Expression *e = new CallExp(loc, new VarExp(loc, fdv->fdrequire, 0), eresult); + Statement *s2 = new ExpStatement(loc, e); + + Catch *c = new Catch(loc, NULL, NULL, sf); + c->internalCatch = true; + Catches *catches = new Catches(); + catches->push(c); + sf = new TryCatchStatement(loc, s2, catches); + } + else + return NULL; + } + return sf; +} + +/**************************************************** + * Merge into this function the 'out' contracts of all it overrides. + * 'out's are AND'd together, i.e. all of them need to pass. + */ + +Statement *FuncDeclaration::mergeFensure(Statement *sf) +{ + /* Same comments as for mergeFrequire(), except that we take care + * of generating a consistent reference to the 'result' local by + * explicitly passing 'result' to the nested function as a reference + * argument. + * This won't work for the 'this' parameter as it would require changing + * the semantic code for the nested function so that it looks on the parameter + * list for the 'this' pointer, something that would need an unknown amount + * of tweaking of various parts of the compiler that I'd rather leave alone. + */ + for (int i = 0; i < foverrides.dim; i++) + { + FuncDeclaration *fdv = foverrides.tdata()[i]; + + /* The semantic pass on the contracts of the overridden functions must + * be completed before code generation occurs (bug 3602 and 5230). + */ + if (fdv->fdensure && fdv->fdensure->semanticRun != PASSsemantic3done) + { + assert(fdv->scope); + Scope *sc = fdv->scope->push(); + sc->stc &= ~STCoverride; + fdv->semantic3(sc); + sc->pop(); + } + + sf = fdv->mergeFensure(sf); + if (fdv->fdensure) + { + //printf("fdv->fensure: %s\n", fdv->fensure->toChars()); + // Make the call: __ensure(result) + Expression *eresult = NULL; + if (outId) + eresult = new IdentifierExp(loc, outId); + Expression *e = new CallExp(loc, new VarExp(loc, fdv->fdensure, 0), eresult); + Statement *s2 = new ExpStatement(loc, e); + + if (sf) + { + sf = new CompoundStatement(fensure->loc, s2, sf); + } + else + sf = s2; + } + } + return sf; +} + +/**************************************************** + * Determine if 'this' overrides fd. + * Return !=0 if it does. + */ + +int FuncDeclaration::overrides(FuncDeclaration *fd) +{ int result = 0; + + if (fd->ident == ident) + { + int cov = type->covariant(fd->type); + if (cov) + { ClassDeclaration *cd1 = toParent()->isClassDeclaration(); + ClassDeclaration *cd2 = fd->toParent()->isClassDeclaration(); + + if (cd1 && cd2 && cd2->isBaseOf(cd1, NULL)) + result = 1; + } + } + return result; +} + +/************************************************* + * Find index of function in vtbl[0..dim] that + * this function overrides. + * Prefer an exact match to a covariant one. + * Returns: + * -1 didn't find one + * -2 can't determine because of forward references + */ + +int FuncDeclaration::findVtblIndex(Dsymbols *vtbl, int dim) +{ + FuncDeclaration *mismatch = NULL; + int bestvi = -1; + for (int vi = 0; vi < dim; vi++) + { + FuncDeclaration *fdv = vtbl->tdata()[vi]->isFuncDeclaration(); + if (fdv && fdv->ident == ident) + { + if (type->equals(fdv->type)) // if exact match + return vi; // no need to look further + + int cov = type->covariant(fdv->type); + //printf("\tbaseclass cov = %d\n", cov); + switch (cov) + { + case 0: // types are distinct + break; + + case 1: + bestvi = vi; // covariant, but not identical + break; // keep looking for an exact match + + case 2: + mismatch = fdv; // overrides, but is not covariant + break; // keep looking for an exact match + + case 3: + return -2; // forward references + + default: + assert(0); + } + } + } + if (bestvi == -1 && mismatch) + { + //type->print(); + //mismatch->type->print(); + //printf("%s %s\n", type->deco, mismatch->type->deco); + error("of type %s overrides but is not covariant with %s of type %s", + type->toChars(), mismatch->toPrettyChars(), mismatch->type->toChars()); + } + return bestvi; +} + +/**************************************************** + * Overload this FuncDeclaration with the new one f. + * Return !=0 if successful; i.e. no conflict. + */ + +int FuncDeclaration::overloadInsert(Dsymbol *s) +{ + FuncDeclaration *f; + AliasDeclaration *a; + + //printf("FuncDeclaration::overloadInsert(s = %s) this = %s\n", s->toChars(), toChars()); + a = s->isAliasDeclaration(); + if (a) + { + if (overnext) + return overnext->overloadInsert(a); + if (!a->aliassym && a->type->ty != Tident && a->type->ty != Tinstance) + { + //printf("\ta = '%s'\n", a->type->toChars()); + return FALSE; + } + overnext = a; + //printf("\ttrue: no conflict\n"); + return TRUE; + } + f = s->isFuncDeclaration(); + if (!f) + return FALSE; + +#if 0 + /* Disable this check because: + * const void foo(); + * semantic() isn't run yet on foo(), so the const hasn't been + * applied yet. + */ + if (type) + { printf("type = %s\n", type->toChars()); + printf("f->type = %s\n", f->type->toChars()); + } + if (type && f->type && // can be NULL for overloaded constructors + f->type->covariant(type) && + f->type->mod == type->mod && + !isFuncAliasDeclaration()) + { + //printf("\tfalse: conflict %s\n", kind()); + return FALSE; + } +#endif + + if (overnext) + return overnext->overloadInsert(f); + overnext = f; + //printf("\ttrue: no conflict\n"); + return TRUE; +} + +/******************************************** + * Find function in overload list that exactly matches t. + */ + +/*************************************************** + * Visit each overloaded function in turn, and call + * (*fp)(param, f) on it. + * Exit when no more, or (*fp)(param, f) returns 1. + * Returns: + * 0 continue + * 1 done + */ + +int overloadApply(FuncDeclaration *fstart, + int (*fp)(void *, FuncDeclaration *), + void *param) +{ + FuncDeclaration *f; + Declaration *d; + Declaration *next; + + for (d = fstart; d; d = next) + { FuncAliasDeclaration *fa = d->isFuncAliasDeclaration(); + + if (fa) + { + if (overloadApply(fa->funcalias, fp, param)) + return 1; + next = fa->overnext; + } + else + { + AliasDeclaration *a = d->isAliasDeclaration(); + + if (a) + { + Dsymbol *s = a->toAlias(); + next = s->isDeclaration(); + if (next == a) + break; + if (next == fstart) + break; + } + else + { + f = d->isFuncDeclaration(); + if (!f) + { d->error("is aliased to a function"); + break; // BUG: should print error message? + } + if ((*fp)(param, f)) + return 1; + + next = f->overnext; + } + } + } + return 0; +} + +/******************************************** + * If there are no overloads of function f, return that function, + * otherwise return NULL. + */ + +static int fpunique(void *param, FuncDeclaration *f) +{ FuncDeclaration **pf = (FuncDeclaration **)param; + + if (*pf) + { *pf = NULL; + return 1; // ambiguous, done + } + else + { *pf = f; + return 0; + } +} + +FuncDeclaration *FuncDeclaration::isUnique() +{ FuncDeclaration *result = NULL; + + overloadApply(this, &fpunique, &result); + return result; +} + +/******************************************** + * Find function in overload list that exactly matches t. + */ + +struct Param1 +{ + Type *t; // type to match + FuncDeclaration *f; // return value +}; + +int fp1(void *param, FuncDeclaration *f) +{ Param1 *p = (Param1 *)param; + Type *t = p->t; + + if (t->equals(f->type)) + { p->f = f; + return 1; + } + +#if DMDV2 + /* Allow covariant matches, as long as the return type + * is just a const conversion. + * This allows things like pure functions to match with an impure function type. + */ + if (t->ty == Tfunction) + { TypeFunction *tf = (TypeFunction *)f->type; + if (tf->covariant(t) == 1 && + tf->nextOf()->implicitConvTo(t->nextOf()) >= MATCHconst) + { + p->f = f; + return 1; + } + } +#endif + return 0; +} + +FuncDeclaration *FuncDeclaration::overloadExactMatch(Type *t) +{ + Param1 p; + p.t = t; + p.f = NULL; + overloadApply(this, &fp1, &p); + return p.f; +} + + +/******************************************** + * Decide which function matches the arguments best. + */ + +struct Param2 +{ + Match *m; +#if DMDV2 + Expression *ethis; + int property; // 0: unintialized + // 1: seen @property + // 2: not @property +#endif + Expressions *arguments; +}; + +int fp2(void *param, FuncDeclaration *f) +{ Param2 *p = (Param2 *)param; + Match *m = p->m; + Expressions *arguments = p->arguments; + MATCH match; + + if (f != m->lastf) // skip duplicates + { + m->anyf = f; + TypeFunction *tf = (TypeFunction *)f->type; + + int property = (tf->isproperty) ? 1 : 2; + if (p->property == 0) + p->property = property; + else if (p->property != property) + error(f->loc, "cannot overload both property and non-property functions"); + + /* For constructors, don't worry about the right type of ethis. It's a problem + * anyway, because the constructor attribute may not match the ethis attribute, + * but we don't care because the attribute on the ethis doesn't matter until + * after it's constructed. + */ + match = (MATCH) tf->callMatch(f->needThis() && !f->isCtorDeclaration() ? p->ethis : NULL, arguments); + //printf("test1: match = %d\n", match); + if (match != MATCHnomatch) + { + if (match > m->last) + goto LfIsBetter; + + if (match < m->last) + goto LlastIsBetter; + + /* See if one of the matches overrides the other. + */ + if (m->lastf->overrides(f)) + goto LlastIsBetter; + else if (f->overrides(m->lastf)) + goto LfIsBetter; + +#if DMDV2 + /* Try to disambiguate using template-style partial ordering rules. + * In essence, if f() and g() are ambiguous, if f() can call g(), + * but g() cannot call f(), then pick f(). + * This is because f() is "more specialized." + */ + { + MATCH c1 = f->leastAsSpecialized(m->lastf); + MATCH c2 = m->lastf->leastAsSpecialized(f); + //printf("c1 = %d, c2 = %d\n", c1, c2); + if (c1 > c2) + goto LfIsBetter; + if (c1 < c2) + goto LlastIsBetter; + } +#endif + Lambiguous: + m->nextf = f; + m->count++; + return 0; + + LfIsBetter: + m->last = match; + m->lastf = f; + m->count = 1; + return 0; + + LlastIsBetter: + return 0; + } + } + return 0; +} + + +void overloadResolveX(Match *m, FuncDeclaration *fstart, + Expression *ethis, Expressions *arguments) +{ + Param2 p; + p.m = m; + p.ethis = ethis; + p.property = 0; + p.arguments = arguments; + overloadApply(fstart, &fp2, &p); +} + + +FuncDeclaration *FuncDeclaration::overloadResolve(Loc loc, Expression *ethis, Expressions *arguments, int flags) +{ + TypeFunction *tf; + Match m; + +#if 0 +printf("FuncDeclaration::overloadResolve('%s')\n", toChars()); +if (arguments) +{ int i; + + for (i = 0; i < arguments->dim; i++) + { Expression *arg; + + arg = arguments->tdata()[i]; + assert(arg->type); + printf("\t%s: ", arg->toChars()); + arg->type->print(); + } +} +#endif + + memset(&m, 0, sizeof(m)); + m.last = MATCHnomatch; + overloadResolveX(&m, this, ethis, arguments); + + if (m.count == 1) // exactly one match + { + return m.lastf; + } + else + { + OutBuffer buf; + + buf.writeByte('('); + if (arguments) + { + HdrGenState hgs; + + argExpTypesToCBuffer(&buf, arguments, &hgs); + buf.writeByte(')'); + if (ethis) + ethis->type->modToBuffer(&buf); + } + else + buf.writeByte(')'); + + if (m.last == MATCHnomatch) + { + if (flags & 1) // if do not print error messages + return NULL; // no match + + tf = (TypeFunction *)type; + + OutBuffer buf2; + tf->modToBuffer(&buf2); + + //printf("tf = %s, args = %s\n", tf->deco, arguments->tdata()[0]->type->deco); + error(loc, "%s%s is not callable using argument types %s", + Parameter::argsTypesToChars(tf->parameters, tf->varargs), + buf2.toChars(), + buf.toChars()); + return m.anyf; // as long as it's not a FuncAliasDeclaration + } + else + { +#if 1 + TypeFunction *t1 = (TypeFunction *)m.lastf->type; + TypeFunction *t2 = (TypeFunction *)m.nextf->type; + + error(loc, "called with argument types:\n\t(%s)\nmatches both:\n\t%s%s\nand:\n\t%s%s", + buf.toChars(), + m.lastf->toPrettyChars(), Parameter::argsTypesToChars(t1->parameters, t1->varargs), + m.nextf->toPrettyChars(), Parameter::argsTypesToChars(t2->parameters, t2->varargs)); +#else + error(loc, "overloads %s and %s both match argument list for %s", + m.lastf->type->toChars(), + m.nextf->type->toChars(), + m.lastf->toChars()); +#endif + return m.lastf; + } + } +} + +/************************************* + * Determine partial specialization order of 'this' vs g. + * This is very similar to TemplateDeclaration::leastAsSpecialized(). + * Returns: + * match 'this' is at least as specialized as g + * 0 g is more specialized than 'this' + */ + +#if DMDV2 +MATCH FuncDeclaration::leastAsSpecialized(FuncDeclaration *g) +{ +#define LOG_LEASTAS 0 + +#if LOG_LEASTAS + printf("%s.leastAsSpecialized(%s)\n", toChars(), g->toChars()); + printf("%s, %s\n", type->toChars(), g->type->toChars()); +#endif + + /* This works by calling g() with f()'s parameters, and + * if that is possible, then f() is at least as specialized + * as g() is. + */ + + TypeFunction *tf = (TypeFunction *)type; + TypeFunction *tg = (TypeFunction *)g->type; + size_t nfparams = Parameter::dim(tf->parameters); + size_t ngparams = Parameter::dim(tg->parameters); + MATCH match = MATCHexact; + + /* If both functions have a 'this' pointer, and the mods are not + * the same and g's is not const, then this is less specialized. + */ + if (needThis() && g->needThis()) + { + if (tf->mod != tg->mod) + { + if (MODimplicitConv(tf->mod, tg->mod)) + match = MATCHconst; + else + return MATCHnomatch; + } + } + + /* Create a dummy array of arguments out of the parameters to f() + */ + Expressions args; + args.setDim(nfparams); + for (int u = 0; u < nfparams; u++) + { + Parameter *p = Parameter::getNth(tf->parameters, u); + Expression *e; + if (p->storageClass & (STCref | STCout)) + { + e = new IdentifierExp(0, p->ident); + e->type = p->type; + } + else + e = p->type->defaultInit(); + args.tdata()[u] = e; + } + + MATCH m = (MATCH) tg->callMatch(NULL, &args, 1); + if (m) + { + /* A variadic parameter list is less specialized than a + * non-variadic one. + */ + if (tf->varargs && !tg->varargs) + goto L1; // less specialized + +#if LOG_LEASTAS + printf(" matches %d, so is least as specialized\n", m); +#endif + return m; + } + L1: +#if LOG_LEASTAS + printf(" doesn't match, so is not as specialized\n"); +#endif + return MATCHnomatch; +} + +/******************************************* + * Given a symbol that could be either a FuncDeclaration or + * a function template, resolve it to a function symbol. + * sc instantiation scope + * loc instantiation location + * targsi initial list of template arguments + * ethis if !NULL, the 'this' pointer argument + * fargs arguments to function + * flags 1: do not issue error message on no match, just return NULL + */ + +FuncDeclaration *resolveFuncCall(Scope *sc, Loc loc, Dsymbol *s, + Objects *tiargs, + Expression *ethis, + Expressions *arguments, + int flags) +{ + if (!s) + return NULL; // no match + FuncDeclaration *f = s->isFuncDeclaration(); + if (f) + f = f->overloadResolve(loc, ethis, arguments); + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + assert(td); + f = td->deduceFunctionTemplate(sc, loc, tiargs, NULL, arguments, flags); + } + return f; +} +#endif + +/******************************** + * Labels are in a separate scope, one per function. + */ + +LabelDsymbol *FuncDeclaration::searchLabel(Identifier *ident) +{ Dsymbol *s; + + if (!labtab) + labtab = new DsymbolTable(); // guess we need one + + s = labtab->lookup(ident); + if (!s) + { + s = new LabelDsymbol(ident); + labtab->insert(s); + } + return (LabelDsymbol *)s; +} + +/**************************************** + * If non-static member function that has a 'this' pointer, + * return the aggregate it is a member of. + * Otherwise, return NULL. + */ + +AggregateDeclaration *FuncDeclaration::isThis() +{ AggregateDeclaration *ad; + + //printf("+FuncDeclaration::isThis() '%s'\n", toChars()); + ad = NULL; + if ((storage_class & STCstatic) == 0) + { + ad = isMember2(); + } + //printf("-FuncDeclaration::isThis() %p\n", ad); + return ad; +} + +AggregateDeclaration *FuncDeclaration::isMember2() +{ AggregateDeclaration *ad; + + //printf("+FuncDeclaration::isMember2() '%s'\n", toChars()); + ad = NULL; + for (Dsymbol *s = this; s; s = s->parent) + { +//printf("\ts = '%s', parent = '%s', kind = %s\n", s->toChars(), s->parent->toChars(), s->parent->kind()); + ad = s->isMember(); + if (ad) +{ + break; +} + if (!s->parent || + (!s->parent->isTemplateInstance())) +{ + break; +} + } + //printf("-FuncDeclaration::isMember2() %p\n", ad); + return ad; +} + +/***************************************** + * Determine lexical level difference from 'this' to nested function 'fd'. + * Error if this cannot call fd. + * Returns: + * 0 same level + * -1 increase nesting by 1 (fd is nested within 'this') + * >0 decrease nesting by number + */ + +int FuncDeclaration::getLevel(Loc loc, Scope *sc, FuncDeclaration *fd) +{ int level; + Dsymbol *s; + Dsymbol *fdparent; + + //printf("FuncDeclaration::getLevel(fd = '%s')\n", fd->toChars()); + fdparent = fd->toParent2(); + if (fdparent == this) + return -1; + s = this; + level = 0; + while (fd != s && fdparent != s->toParent2()) + { + //printf("\ts = %s, '%s'\n", s->kind(), s->toChars()); + FuncDeclaration *thisfd = s->isFuncDeclaration(); + if (thisfd) + { if (!thisfd->isNested() && !thisfd->vthis) + goto Lerr; + } + else + { + AggregateDeclaration *thiscd = s->isAggregateDeclaration(); + if (thiscd) + { if (!thiscd->isNested()) + goto Lerr; + } + else + goto Lerr; + } + + s = s->toParent2(); + assert(s); + level++; + } + return level; + +Lerr: + // Don't give error if in template constraint + if (!((sc->flags & SCOPEstaticif) && parent->isTemplateDeclaration())) + error(loc, "cannot access frame of function %s", fd->toPrettyChars()); + return 1; +} + +void FuncDeclaration::appendExp(Expression *e) +{ Statement *s; + + s = new ExpStatement(0, e); + appendState(s); +} + +void FuncDeclaration::appendState(Statement *s) +{ + if (!fbody) + fbody = s; + else + { + CompoundStatement *cs = fbody->isCompoundStatement(); + if (cs) + { + if (!cs->statements) + fbody = s; + else + cs->statements->push(s); + } + else + fbody = new CompoundStatement(0, fbody, s); + } +} + +const char *FuncDeclaration::toPrettyChars() +{ + if (isMain()) + return "D main"; + else + return Dsymbol::toPrettyChars(); +} + +int FuncDeclaration::isMain() +{ + return ident == Id::main && + linkage != LINKc && !isMember() && !isNested(); +} + +int FuncDeclaration::isWinMain() +{ + //printf("FuncDeclaration::isWinMain() %s\n", toChars()); +#if 0 + int x = ident == Id::WinMain && + linkage != LINKc && !isMember(); + printf("%s\n", x ? "yes" : "no"); + return x; +#else + return ident == Id::WinMain && + linkage != LINKc && !isMember(); +#endif +} + +int FuncDeclaration::isDllMain() +{ + return ident == Id::DllMain && + linkage != LINKc && !isMember(); +} + +int FuncDeclaration::isExport() +{ + return protection == PROTexport; +} + +int FuncDeclaration::isImportedSymbol() +{ + //printf("isImportedSymbol()\n"); + //printf("protection = %d\n", protection); + return (protection == PROTexport) && !fbody; +} + +// Determine if function goes into virtual function pointer table + +int FuncDeclaration::isVirtual() +{ + Dsymbol *p = toParent(); +#if 0 + printf("FuncDeclaration::isVirtual(%s)\n", toChars()); + printf("isMember:%p isStatic:%d private:%d ctor:%d !Dlinkage:%d\n", isMember(), isStatic(), protection == PROTprivate, isCtorDeclaration(), linkage != LINKd); + printf("result is %d\n", + isMember() && + !(isStatic() || protection == PROTprivate || protection == PROTpackage) && + p->isClassDeclaration() && + !(p->isInterfaceDeclaration() && isFinal())); +#endif + return isMember() && + !(isStatic() || protection == PROTprivate || protection == PROTpackage) && + p->isClassDeclaration() && + !(p->isInterfaceDeclaration() && isFinal()); +} + +// Determine if a function is pedantically virtual + +int FuncDeclaration::isVirtualMethod() +{ + //printf("FuncDeclaration::isVirtualMethod() %s\n", toChars()); + if (!isVirtual()) + return 0; + // If it's a final method, and does not override anything, then it is not virtual + if (isFinal() && foverrides.dim == 0) + { + return 0; + } + return 1; +} + +int FuncDeclaration::isFinal() +{ + ClassDeclaration *cd; +#if 0 + printf("FuncDeclaration::isFinal(%s), %x\n", toChars(), Declaration::isFinal()); + printf("%p %d %d %d\n", isMember(), isStatic(), Declaration::isFinal(), ((cd = toParent()->isClassDeclaration()) != NULL && cd->storage_class & STCfinal)); + printf("result is %d\n", + isMember() && + (Declaration::isFinal() || + ((cd = toParent()->isClassDeclaration()) != NULL && cd->storage_class & STCfinal))); + if (cd) + printf("\tmember of %s\n", cd->toChars()); +#if 0 + !(isStatic() || protection == PROTprivate || protection == PROTpackage) && + (cd = toParent()->isClassDeclaration()) != NULL && + cd->storage_class & STCfinal); +#endif +#endif + return isMember() && + (Declaration::isFinal() || + ((cd = toParent()->isClassDeclaration()) != NULL && cd->storage_class & STCfinal)); +} + +int FuncDeclaration::isAbstract() +{ + return storage_class & STCabstract; +} + +int FuncDeclaration::isCodeseg() +{ + return TRUE; // functions are always in the code segment +} + +int FuncDeclaration::isOverloadable() +{ + return 1; // functions can be overloaded +} + +enum PURE FuncDeclaration::isPure() +{ + //printf("FuncDeclaration::isPure() '%s'\n", toChars()); + assert(type->ty == Tfunction); + TypeFunction *tf = (TypeFunction *)type; + if (flags & FUNCFLAGpurityInprocess) + setImpure(); + if (tf->purity == PUREfwdref) + tf->purityLevel(); + enum PURE purity = tf->purity; + if (purity > PUREweak && needThis()) + { // The attribute of the 'this' reference affects purity strength + if (type->mod & (MODimmutable | MODwild)) + ; + else if (type->mod & MODconst && purity >= PUREconst) + purity = PUREconst; + else + purity = PUREweak; + } + tf->purity = purity; + // ^ This rely on the current situation that every FuncDeclaration has a + // unique TypeFunction. + return purity; +} + +enum PURE FuncDeclaration::isPureBypassingInference() +{ + if (flags & FUNCFLAGpurityInprocess) + return PUREfwdref; + else + return isPure(); +} + +/************************************** + * The function is doing something impure, + * so mark it as impure. + * If there's a purity error, return TRUE. + */ +bool FuncDeclaration::setImpure() +{ + if (flags & FUNCFLAGpurityInprocess) + { + flags &= ~FUNCFLAGpurityInprocess; + } + else if (isPure()) + return TRUE; + return FALSE; +} + +int FuncDeclaration::isSafe() +{ + assert(type->ty == Tfunction); + if (flags & FUNCFLAGsafetyInprocess) + setUnsafe(); + return ((TypeFunction *)type)->trust == TRUSTsafe; +} + +int FuncDeclaration::isTrusted() +{ + assert(type->ty == Tfunction); + if (flags & FUNCFLAGsafetyInprocess) + setUnsafe(); + return ((TypeFunction *)type)->trust == TRUSTtrusted; +} + +/************************************** + * The function is doing something unsave, + * so mark it as unsafe. + * If there's a safe error, return TRUE. + */ +bool FuncDeclaration::setUnsafe() +{ + if (flags & FUNCFLAGsafetyInprocess) + { + flags &= ~FUNCFLAGsafetyInprocess; + ((TypeFunction *)type)->trust = TRUSTsystem; + } + else if (isSafe()) + return TRUE; + return FALSE; +} + +// Determine if function needs +// a static frame pointer to its lexically enclosing function + +int FuncDeclaration::isNested() +{ + //if (!toParent()) + //printf("FuncDeclaration::isNested('%s') parent=%p\n", toChars(), parent); + //printf("\ttoParent2() = '%s'\n", toParent2()->toChars()); + return ((storage_class & STCstatic) == 0) && + (toParent2()->isFuncDeclaration() != NULL); +} + +int FuncDeclaration::needThis() +{ + //printf("FuncDeclaration::needThis() '%s'\n", toChars()); + int i = isThis() != NULL; + //printf("\t%d\n", i); + if (!i && isFuncAliasDeclaration()) + i = ((FuncAliasDeclaration *)this)->funcalias->needThis(); + return i; +} + +int FuncDeclaration::addPreInvariant() +{ + AggregateDeclaration *ad = isThis(); + return (ad && + //ad->isClassDeclaration() && + global.params.useInvariants && + (protection == PROTprotected || protection == PROTpublic || protection == PROTexport) && + !naked && + ident != Id::cpctor); +} + +int FuncDeclaration::addPostInvariant() +{ + AggregateDeclaration *ad = isThis(); + return (ad && + ad->inv && + //ad->isClassDeclaration() && + global.params.useInvariants && + (protection == PROTprotected || protection == PROTpublic || protection == PROTexport) && + !naked && + ident != Id::cpctor); +} + +/********************************** + * Generate a FuncDeclaration for a runtime library function. + */ + +FuncDeclaration *FuncDeclaration::genCfunc(Type *treturn, const char *name) +{ + return genCfunc(treturn, Lexer::idPool(name)); +} + +FuncDeclaration *FuncDeclaration::genCfunc(Type *treturn, Identifier *id) +{ + FuncDeclaration *fd; + TypeFunction *tf; + Dsymbol *s; + static DsymbolTable *st = NULL; + + //printf("genCfunc(name = '%s')\n", id->toChars()); + //printf("treturn\n\t"); treturn->print(); + + // See if already in table + if (!st) + st = new DsymbolTable(); + s = st->lookup(id); + if (s) + { + fd = s->isFuncDeclaration(); + assert(fd); + assert(fd->type->nextOf()->equals(treturn)); + } + else + { + tf = new TypeFunction(NULL, treturn, 0, LINKc); + fd = new FuncDeclaration(0, 0, id, STCstatic, tf); + fd->protection = PROTpublic; + fd->linkage = LINKc; + + st->insert(fd); + } + return fd; +} + +const char *FuncDeclaration::kind() +{ + return "function"; +} + +void FuncDeclaration::checkNestedReference(Scope *sc, Loc loc) +{ + //printf("FuncDeclaration::checkNestedReference() %s\n", toChars()); + if (parent && parent != sc->parent && this->isNested() && + this->ident != Id::require && this->ident != Id::ensure) + { + // The function that this function is in + FuncDeclaration *fdv = toParent()->isFuncDeclaration(); + // The current function + FuncDeclaration *fdthis = sc->parent->isFuncDeclaration(); + + //printf("this = %s in [%s]\n", this->toChars(), this->loc.toChars()); + //printf("fdv = %s in [%s]\n", fdv->toChars(), fdv->loc.toChars()); + //printf("fdthis = %s in [%s]\n", fdthis->toChars(), fdthis->loc.toChars()); + + if (fdv && fdthis && fdv != fdthis) + { + int lv = fdthis->getLevel(loc, sc, fdv); + if (lv == -1) + return; // OK + if (lv == 0) + return; // OK + + // BUG: may need to walk up outer scopes like Declaration::checkNestedReference() does + + // function literal has reference to enclosing scope is delegate + if (FuncLiteralDeclaration *fld = fdthis->isFuncLiteralDeclaration()) + fld->tok = TOKdelegate; + } + } +} + +/******************************* + * Look at all the variables in this function that are referenced + * by nested functions, and determine if a closure needs to be + * created for them. + */ + +#if DMDV2 +int FuncDeclaration::needsClosure() +{ + /* Need a closure for all the closureVars[] if any of the + * closureVars[] are accessed by a + * function that escapes the scope of this function. + * We take the conservative approach and decide that any function that: + * 1) is a virtual function + * 2) has its address taken + * 3) has a parent that escapes + * -or- + * 4) this function returns a local struct/class + * + * Note that since a non-virtual function can be called by + * a virtual one, if that non-virtual function accesses a closure + * var, the closure still has to be taken. Hence, we check for isThis() + * instead of isVirtual(). (thanks to David Friedman) + */ + + //printf("FuncDeclaration::needsClosure() %s\n", toChars()); + for (int i = 0; i < closureVars.dim; i++) + { VarDeclaration *v = closureVars.tdata()[i]; + assert(v->isVarDeclaration()); + //printf("\tv = %s\n", v->toChars()); + + for (int j = 0; j < v->nestedrefs.dim; j++) + { FuncDeclaration *f = v->nestedrefs.tdata()[j]; + assert(f != this); + + //printf("\t\tf = %s, %d, %p, %d\n", f->toChars(), f->isVirtual(), f->isThis(), f->tookAddressOf); + if (f->isThis() || f->tookAddressOf) + goto Lyes; // assume f escapes this function's scope + + // Look to see if any parents of f that are below this escape + for (Dsymbol *s = f->parent; s && s != this; s = s->parent) + { + f = s->isFuncDeclaration(); + if (f && (f->isThis() || f->tookAddressOf)) + goto Lyes; + } + } + } + + /* Look for case (4) + */ + if (closureVars.dim) + { + assert(type->ty == Tfunction); + Type *tret = ((TypeFunction *)type)->next; + assert(tret); + tret = tret->toBasetype(); + if (tret->ty == Tclass || tret->ty == Tstruct) + { Dsymbol *st = tret->toDsymbol(NULL); + for (Dsymbol *s = st->parent; s; s = s->parent) + { + if (s == this) + goto Lyes; + } + } + } + + return 0; + +Lyes: + //printf("\tneeds closure\n"); + return 1; +} +#endif + +/*********************************************** + * Determine if function's variables are referenced by a function + * nested within it. + */ + +int FuncDeclaration::hasNestedFrameRefs() +{ +#if DMDV2 + if (closureVars.dim) +#else + if (nestedFrameRef) +#endif + return 1; + + /* If a virtual method has contracts, assume its variables are referenced + * by those contracts, even if they aren't. Because they might be referenced + * by the overridden or overriding function's contracts. + * This can happen because frequire and fensure are implemented as nested functions, + * and they can be called directly by an overriding function and the overriding function's + * context had better match, or Bugzilla 7337 will bite. + */ + if ((fdrequire || fdensure) && isVirtualMethod()) + return 1; + + if (foverrides.dim && isVirtualMethod()) + { + for (size_t i = 0; i < foverrides.dim; i++) + { + FuncDeclaration *fdv = foverrides.tdata()[i]; + if (fdv->hasNestedFrameRefs()) + return 1; + } + } + + return 0; +} + +/********************************************* + * Return the function's parameter list, and whether + * it is variadic or not. + */ + +Parameters *FuncDeclaration::getParameters(int *pvarargs) +{ Parameters *fparameters; + int fvarargs; + + if (type) + { + assert(type->ty == Tfunction); + TypeFunction *fdtype = (TypeFunction *)type; + fparameters = fdtype->parameters; + fvarargs = fdtype->varargs; + } + if (pvarargs) + *pvarargs = fvarargs; + return fparameters; +} + + +/****************************** FuncAliasDeclaration ************************/ + +// Used as a way to import a set of functions from another scope into this one. + +FuncAliasDeclaration::FuncAliasDeclaration(FuncDeclaration *funcalias) + : FuncDeclaration(funcalias->loc, funcalias->endloc, funcalias->ident, + funcalias->storage_class, funcalias->type) +{ + assert(funcalias != this); + this->funcalias = funcalias; +} + +const char *FuncAliasDeclaration::kind() +{ + return "function alias"; +} + + +/****************************** FuncLiteralDeclaration ************************/ + +FuncLiteralDeclaration::FuncLiteralDeclaration(Loc loc, Loc endloc, Type *type, + enum TOK tok, ForeachStatement *fes) + : FuncDeclaration(loc, endloc, NULL, STCundefined, type) +{ + const char *id; + + if (fes) + id = "__foreachbody"; + else if (tok == TOKreserved) + id = "__lambda"; + else if (tok == TOKdelegate) + id = "__dgliteral"; + else + id = "__funcliteral"; + this->ident = Lexer::uniqueId(id); + this->tok = tok; + this->fes = fes; + //printf("FuncLiteralDeclaration() id = '%s', type = '%s'\n", this->ident->toChars(), type->toChars()); +} + +Dsymbol *FuncLiteralDeclaration::syntaxCopy(Dsymbol *s) +{ + FuncLiteralDeclaration *f; + + //printf("FuncLiteralDeclaration::syntaxCopy('%s')\n", toChars()); + if (s) + f = (FuncLiteralDeclaration *)s; + else + { f = new FuncLiteralDeclaration(loc, endloc, type->syntaxCopy(), tok, fes); + f->ident = ident; // keep old identifier + } + FuncDeclaration::syntaxCopy(f); + return f; +} + +int FuncLiteralDeclaration::isNested() +{ + //printf("FuncLiteralDeclaration::isNested() '%s'\n", toChars()); + return (tok != TOKfunction); +} + +int FuncLiteralDeclaration::isVirtual() +{ + return FALSE; +} + +const char *FuncLiteralDeclaration::kind() +{ + // GCC requires the (char*) casts + return (tok != TOKfunction) ? (char*)"delegate" : (char*)"function"; +} + +void FuncLiteralDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(kind()); + buf->writeByte(' '); + type->toCBuffer(buf, NULL, hgs); + bodyToCBuffer(buf, hgs); +} + + +/********************************* CtorDeclaration ****************************/ + +CtorDeclaration::CtorDeclaration(Loc loc, Loc endloc, StorageClass stc, Type *type) + : FuncDeclaration(loc, endloc, Id::ctor, stc, type) +{ + //printf("CtorDeclaration(loc = %s) %s\n", loc.toChars(), toChars()); +} + +Dsymbol *CtorDeclaration::syntaxCopy(Dsymbol *s) +{ + CtorDeclaration *f = new CtorDeclaration(loc, endloc, storage_class, type->syntaxCopy()); + + f->outId = outId; + f->frequire = frequire ? frequire->syntaxCopy() : NULL; + f->fensure = fensure ? fensure->syntaxCopy() : NULL; + f->fbody = fbody ? fbody->syntaxCopy() : NULL; + assert(!fthrows); // deprecated + + return f; +} + + +void CtorDeclaration::semantic(Scope *sc) +{ + //printf("CtorDeclaration::semantic() %s\n", toChars()); + TypeFunction *tf = (TypeFunction *)type; + assert(tf && tf->ty == Tfunction); + + sc = sc->push(); + sc->stc &= ~STCstatic; // not a static constructor + sc->flags |= SCOPEctor; + + parent = sc->parent; + Dsymbol *parent = toParent2(); + Type *tret; + AggregateDeclaration *ad = parent->isAggregateDeclaration(); + if (!ad || parent->isUnionDeclaration()) + { + error("constructors are only for class or struct definitions"); + tret = Type::tvoid; + } + else + { tret = ad->handle; + assert(tret); + tret = tret->addStorageClass(storage_class | sc->stc); + tret = tret->addMod(type->mod); + } + tf->next = tret; + type = type->semantic(loc, sc); + +#if STRUCTTHISREF + if (ad && ad->isStructDeclaration()) + { if (!originalType) + originalType = type->syntaxCopy(); + ((TypeFunction *)type)->isref = 1; + } +#endif + if (!originalType) + originalType = type; + + // Append: + // return this; + // to the function body + if (fbody && semanticRun < PASSsemantic) + { + Expression *e = new ThisExp(loc); + if (parent->isClassDeclaration()) + e->type = tret; + Statement *s = new ReturnStatement(loc, e); + fbody = new CompoundStatement(loc, fbody, s); + } + + FuncDeclaration::semantic(sc); + + sc->pop(); + + // See if it's the default constructor + if (ad && tf->varargs == 0 && Parameter::dim(tf->parameters) == 0) + { + StructDeclaration *sd = ad->isStructDeclaration(); + if (sd) + { + if (fbody || !(storage_class & STCdisable)) + { error("default constructor for structs only allowed with @disable and no body"); + storage_class |= STCdisable; + fbody = NULL; + } + sd->noDefaultCtor = TRUE; + } + else + ad->defaultCtor = this; + } +} + +const char *CtorDeclaration::kind() +{ + return "constructor"; +} + +char *CtorDeclaration::toChars() +{ + return (char *)"this"; +} + +int CtorDeclaration::isVirtual() +{ + return FALSE; +} + +int CtorDeclaration::addPreInvariant() +{ + return FALSE; +} + +int CtorDeclaration::addPostInvariant() +{ + return (isThis() && vthis && global.params.useInvariants); +} + + +/********************************* PostBlitDeclaration ****************************/ + +#if DMDV2 +PostBlitDeclaration::PostBlitDeclaration(Loc loc, Loc endloc, StorageClass stc) + : FuncDeclaration(loc, endloc, Id::_postblit, stc, NULL) +{ +} + +PostBlitDeclaration::PostBlitDeclaration(Loc loc, Loc endloc, Identifier *id) + : FuncDeclaration(loc, endloc, id, STCundefined, NULL) +{ +} + +Dsymbol *PostBlitDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + PostBlitDeclaration *dd = new PostBlitDeclaration(loc, endloc, ident); + return FuncDeclaration::syntaxCopy(dd); +} + + +void PostBlitDeclaration::semantic(Scope *sc) +{ + //printf("PostBlitDeclaration::semantic() %s\n", toChars()); + //printf("ident: %s, %s, %p, %p\n", ident->toChars(), Id::dtor->toChars(), ident, Id::dtor); + //printf("stc = x%llx\n", sc->stc); + parent = sc->parent; + Dsymbol *parent = toParent(); + StructDeclaration *ad = parent->isStructDeclaration(); + if (!ad) + { + error("post blits are only for struct/union definitions, not %s %s", parent->kind(), parent->toChars()); + } + else if (ident == Id::_postblit && semanticRun < PASSsemantic) + ad->postblits.push(this); + + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd, storage_class); + + sc = sc->push(); + sc->stc &= ~STCstatic; // not static + sc->linkage = LINKd; + + FuncDeclaration::semantic(sc); + + sc->pop(); +} + +int PostBlitDeclaration::overloadInsert(Dsymbol *s) +{ + return FALSE; // cannot overload postblits +} + +int PostBlitDeclaration::addPreInvariant() +{ + return FALSE; +} + +int PostBlitDeclaration::addPostInvariant() +{ + return (isThis() && vthis && global.params.useInvariants); +} + +int PostBlitDeclaration::isVirtual() +{ + return FALSE; +} + +void PostBlitDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("this(this)"); + bodyToCBuffer(buf, hgs); +} +#endif + +/********************************* DtorDeclaration ****************************/ + +DtorDeclaration::DtorDeclaration(Loc loc, Loc endloc) + : FuncDeclaration(loc, endloc, Id::dtor, STCundefined, NULL) +{ +} + +DtorDeclaration::DtorDeclaration(Loc loc, Loc endloc, Identifier *id) + : FuncDeclaration(loc, endloc, id, STCundefined, NULL) +{ +} + +Dsymbol *DtorDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + DtorDeclaration *dd = new DtorDeclaration(loc, endloc, ident); + return FuncDeclaration::syntaxCopy(dd); +} + + +void DtorDeclaration::semantic(Scope *sc) +{ + //printf("DtorDeclaration::semantic() %s\n", toChars()); + //printf("ident: %s, %s, %p, %p\n", ident->toChars(), Id::dtor->toChars(), ident, Id::dtor); + parent = sc->parent; + Dsymbol *parent = toParent(); + AggregateDeclaration *ad = parent->isAggregateDeclaration(); + if (!ad) + { + error("destructors are only for class/struct/union definitions, not %s %s", parent->kind(), parent->toChars()); + } + else if (ident == Id::dtor && semanticRun < PASSsemantic) + ad->dtors.push(this); + + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd); + + sc = sc->push(); + sc->stc &= ~STCstatic; // not a static destructor + sc->linkage = LINKd; + + FuncDeclaration::semantic(sc); + + sc->pop(); +} + +int DtorDeclaration::overloadInsert(Dsymbol *s) +{ + return FALSE; // cannot overload destructors +} + +int DtorDeclaration::addPreInvariant() +{ + return (isThis() && vthis && global.params.useInvariants); +} + +int DtorDeclaration::addPostInvariant() +{ + return FALSE; +} + +const char *DtorDeclaration::kind() +{ + return "destructor"; +} + +char *DtorDeclaration::toChars() +{ + return (char *)"~this"; +} + +int DtorDeclaration::isVirtual() +{ + /* This should be FALSE so that dtor's don't get put into the vtbl[], + * but doing so will require recompiling everything. + */ +#if BREAKABI + return FALSE; +#else + return FuncDeclaration::isVirtual(); +#endif +} + +void DtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("~this()"); + bodyToCBuffer(buf, hgs); +} + +/********************************* StaticCtorDeclaration ****************************/ + +StaticCtorDeclaration::StaticCtorDeclaration(Loc loc, Loc endloc) + : FuncDeclaration(loc, endloc, + Identifier::generateId("_staticCtor"), STCstatic, NULL) +{ +} + +StaticCtorDeclaration::StaticCtorDeclaration(Loc loc, Loc endloc, const char *name) + : FuncDeclaration(loc, endloc, + Identifier::generateId(name), STCstatic, NULL) +{ +} + +Dsymbol *StaticCtorDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + StaticCtorDeclaration *scd = new StaticCtorDeclaration(loc, endloc); + return FuncDeclaration::syntaxCopy(scd); +} + + +void StaticCtorDeclaration::semantic(Scope *sc) +{ + //printf("StaticCtorDeclaration::semantic()\n"); + + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd); + + /* If the static ctor appears within a template instantiation, + * it could get called multiple times by the module constructors + * for different modules. Thus, protect it with a gate. + */ + if (inTemplateInstance() && semanticRun < PASSsemantic) + { + /* Add this prefix to the function: + * static int gate; + * if (++gate != 1) return; + * Note that this is not thread safe; should not have threads + * during static construction. + */ + Identifier *id = Lexer::idPool("__gate"); + VarDeclaration *v = new VarDeclaration(0, Type::tint32, id, NULL); + v->storage_class = isSharedStaticCtorDeclaration() ? STCstatic : STCtls; + Statements *sa = new Statements(); + Statement *s = new ExpStatement(0, v); + sa->push(s); + Expression *e = new IdentifierExp(0, id); + e = new AddAssignExp(0, e, new IntegerExp(1)); + e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(1)); + s = new IfStatement(0, NULL, e, new ReturnStatement(0, NULL), NULL); + sa->push(s); + if (fbody) + sa->push(fbody); + fbody = new CompoundStatement(0, sa); + } + + FuncDeclaration::semantic(sc); + + // We're going to need ModuleInfo + Module *m = getModule(); + if (!m) + m = sc->module; + if (m) + { m->needmoduleinfo = 1; + //printf("module1 %s needs moduleinfo\n", m->toChars()); +#ifdef IN_GCC + m->strictlyneedmoduleinfo = 1; +#endif + } +} + +AggregateDeclaration *StaticCtorDeclaration::isThis() +{ + return NULL; +} + +int StaticCtorDeclaration::isVirtual() +{ + return FALSE; +} + +bool StaticCtorDeclaration::hasStaticCtorOrDtor() +{ + return TRUE; +} + +int StaticCtorDeclaration::addPreInvariant() +{ + return FALSE; +} + +int StaticCtorDeclaration::addPostInvariant() +{ + return FALSE; +} + +void StaticCtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen) + { buf->writestring("static this();"); + buf->writenl(); + return; + } + buf->writestring("static this()"); + bodyToCBuffer(buf, hgs); +} + +/********************************* SharedStaticCtorDeclaration ****************************/ + +SharedStaticCtorDeclaration::SharedStaticCtorDeclaration(Loc loc, Loc endloc) + : StaticCtorDeclaration(loc, endloc, "_sharedStaticCtor") +{ +} + +Dsymbol *SharedStaticCtorDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + SharedStaticCtorDeclaration *scd = new SharedStaticCtorDeclaration(loc, endloc); + return FuncDeclaration::syntaxCopy(scd); +} + +void SharedStaticCtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("shared "); + StaticCtorDeclaration::toCBuffer(buf, hgs); +} + +/********************************* StaticDtorDeclaration ****************************/ + +StaticDtorDeclaration::StaticDtorDeclaration(Loc loc, Loc endloc) + : FuncDeclaration(loc, endloc, + Identifier::generateId("_staticDtor"), STCstatic, NULL) +{ + vgate = NULL; +} + +StaticDtorDeclaration::StaticDtorDeclaration(Loc loc, Loc endloc, const char *name) + : FuncDeclaration(loc, endloc, + Identifier::generateId(name), STCstatic, NULL) +{ + vgate = NULL; +} + +Dsymbol *StaticDtorDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + StaticDtorDeclaration *sdd = new StaticDtorDeclaration(loc, endloc); + return FuncDeclaration::syntaxCopy(sdd); +} + + +void StaticDtorDeclaration::semantic(Scope *sc) +{ + ClassDeclaration *cd = sc->scopesym->isClassDeclaration(); + + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd); + + /* If the static ctor appears within a template instantiation, + * it could get called multiple times by the module constructors + * for different modules. Thus, protect it with a gate. + */ + if (inTemplateInstance() && semanticRun < PASSsemantic) + { + /* Add this prefix to the function: + * static int gate; + * if (--gate != 0) return; + * Increment gate during constructor execution. + * Note that this is not thread safe; should not have threads + * during static destruction. + */ + Identifier *id = Lexer::idPool("__gate"); + VarDeclaration *v = new VarDeclaration(0, Type::tint32, id, NULL); + v->storage_class = isSharedStaticDtorDeclaration() ? STCstatic : STCtls; + Statements *sa = new Statements(); + Statement *s = new ExpStatement(0, v); + sa->push(s); + Expression *e = new IdentifierExp(0, id); + e = new AddAssignExp(0, e, new IntegerExp(-1)); + e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(0)); + s = new IfStatement(0, NULL, e, new ReturnStatement(0, NULL), NULL); + sa->push(s); + if (fbody) + sa->push(fbody); + fbody = new CompoundStatement(0, sa); + vgate = v; + } + + FuncDeclaration::semantic(sc); + + // We're going to need ModuleInfo + Module *m = getModule(); + if (!m) + m = sc->module; + if (m) + { m->needmoduleinfo = 1; + //printf("module2 %s needs moduleinfo\n", m->toChars()); +#ifdef IN_GCC + m->strictlyneedmoduleinfo = 1; +#endif + } +} + +AggregateDeclaration *StaticDtorDeclaration::isThis() +{ + return NULL; +} + +int StaticDtorDeclaration::isVirtual() +{ + return FALSE; +} + +bool StaticDtorDeclaration::hasStaticCtorOrDtor() +{ + return TRUE; +} + +int StaticDtorDeclaration::addPreInvariant() +{ + return FALSE; +} + +int StaticDtorDeclaration::addPostInvariant() +{ + return FALSE; +} + +void StaticDtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen) + return; + buf->writestring("static ~this()"); + bodyToCBuffer(buf, hgs); +} + +/********************************* SharedStaticDtorDeclaration ****************************/ + +SharedStaticDtorDeclaration::SharedStaticDtorDeclaration(Loc loc, Loc endloc) + : StaticDtorDeclaration(loc, endloc, "_sharedStaticDtor") +{ +} + +Dsymbol *SharedStaticDtorDeclaration::syntaxCopy(Dsymbol *s) +{ + assert(!s); + SharedStaticDtorDeclaration *sdd = new SharedStaticDtorDeclaration(loc, endloc); + return FuncDeclaration::syntaxCopy(sdd); +} + +void SharedStaticDtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (!hgs->hdrgen) + { + buf->writestring("shared "); + StaticDtorDeclaration::toCBuffer(buf, hgs); + } +} + + +/********************************* InvariantDeclaration ****************************/ + +InvariantDeclaration::InvariantDeclaration(Loc loc, Loc endloc) + : FuncDeclaration(loc, endloc, Id::classInvariant, STCundefined, NULL) +{ +} + +Dsymbol *InvariantDeclaration::syntaxCopy(Dsymbol *s) +{ + InvariantDeclaration *id; + + assert(!s); + id = new InvariantDeclaration(loc, endloc); + FuncDeclaration::syntaxCopy(id); + return id; +} + + +void InvariantDeclaration::semantic(Scope *sc) +{ + parent = sc->parent; + Dsymbol *parent = toParent(); + AggregateDeclaration *ad = parent->isAggregateDeclaration(); + if (!ad) + { + error("invariants are only for struct/union/class definitions"); + return; + } + else if (ad->inv && ad->inv != this && semanticRun < PASSsemantic) + { + error("more than one invariant for %s", ad->toChars()); + } + ad->inv = this; + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd); + + sc = sc->push(); + sc->stc &= ~STCstatic; // not a static invariant + sc->stc |= STCconst; // invariant() is always const + sc->incontract++; + sc->linkage = LINKd; + + FuncDeclaration::semantic(sc); + + sc->pop(); +} + +int InvariantDeclaration::isVirtual() +{ + return FALSE; +} + +int InvariantDeclaration::addPreInvariant() +{ + return FALSE; +} + +int InvariantDeclaration::addPostInvariant() +{ + return FALSE; +} + +void InvariantDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen) + return; + buf->writestring("invariant"); + bodyToCBuffer(buf, hgs); +} + + +/********************************* UnitTestDeclaration ****************************/ + +/******************************* + * Generate unique unittest function Id so we can have multiple + * instances per module. + */ + +static Identifier *unitTestId() +{ + return Lexer::uniqueId("__unittest"); +} + +UnitTestDeclaration::UnitTestDeclaration(Loc loc, Loc endloc) + : FuncDeclaration(loc, endloc, unitTestId(), STCundefined, NULL) +{ +} + +Dsymbol *UnitTestDeclaration::syntaxCopy(Dsymbol *s) +{ + UnitTestDeclaration *utd; + + assert(!s); + utd = new UnitTestDeclaration(loc, endloc); + return FuncDeclaration::syntaxCopy(utd); +} + + +void UnitTestDeclaration::semantic(Scope *sc) +{ + if (global.params.useUnitTests) + { + if (!type) + type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd); + Scope *sc2 = sc->push(); + // It makes no sense for unit tests to be pure or nothrow. + sc2->stc &= ~(STCnothrow | STCpure); + sc2->linkage = LINKd; + FuncDeclaration::semantic(sc2); + sc2->pop(); + } + +#if 0 + // We're going to need ModuleInfo even if the unit tests are not + // compiled in, because other modules may import this module and refer + // to this ModuleInfo. + // (This doesn't make sense to me?) + Module *m = getModule(); + if (!m) + m = sc->module; + if (m) + { + //printf("module3 %s needs moduleinfo\n", m->toChars()); + m->needmoduleinfo = 1; + } +#endif +} + +AggregateDeclaration *UnitTestDeclaration::isThis() +{ + return NULL; +} + +int UnitTestDeclaration::isVirtual() +{ + return FALSE; +} + +int UnitTestDeclaration::addPreInvariant() +{ + return FALSE; +} + +int UnitTestDeclaration::addPostInvariant() +{ + return FALSE; +} + +void UnitTestDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen) + return; + buf->writestring("unittest"); + bodyToCBuffer(buf, hgs); +} + +/********************************* NewDeclaration ****************************/ + +NewDeclaration::NewDeclaration(Loc loc, Loc endloc, Parameters *arguments, int varargs) + : FuncDeclaration(loc, endloc, Id::classNew, STCstatic, NULL) +{ + this->arguments = arguments; + this->varargs = varargs; +} + +Dsymbol *NewDeclaration::syntaxCopy(Dsymbol *s) +{ + NewDeclaration *f; + + f = new NewDeclaration(loc, endloc, NULL, varargs); + + FuncDeclaration::syntaxCopy(f); + + f->arguments = Parameter::arraySyntaxCopy(arguments); + + return f; +} + + +void NewDeclaration::semantic(Scope *sc) +{ + //printf("NewDeclaration::semantic()\n"); + + parent = sc->parent; + Dsymbol *parent = toParent(); + ClassDeclaration *cd = parent->isClassDeclaration(); + if (!cd && !parent->isStructDeclaration()) + { + error("new allocators only are for class or struct definitions"); + } + Type *tret = Type::tvoid->pointerTo(); + if (!type) + type = new TypeFunction(arguments, tret, varargs, LINKd); + + type = type->semantic(loc, sc); + assert(type->ty == Tfunction); + + // Check that there is at least one argument of type size_t + TypeFunction *tf = (TypeFunction *)type; + if (Parameter::dim(tf->parameters) < 1) + { + error("at least one argument of type size_t expected"); + } + else + { + Parameter *a = Parameter::getNth(tf->parameters, 0); + if (!a->type->equals(Type::tsize_t)) + error("first argument must be type size_t, not %s", a->type->toChars()); + } + + FuncDeclaration::semantic(sc); +} + +const char *NewDeclaration::kind() +{ + return "allocator"; +} + +int NewDeclaration::isVirtual() +{ + return FALSE; +} + +int NewDeclaration::addPreInvariant() +{ + return FALSE; +} + +int NewDeclaration::addPostInvariant() +{ + return FALSE; +} + +void NewDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("new"); + Parameter::argsToCBuffer(buf, hgs, arguments, varargs); + bodyToCBuffer(buf, hgs); +} + + +/********************************* DeleteDeclaration ****************************/ + +DeleteDeclaration::DeleteDeclaration(Loc loc, Loc endloc, Parameters *arguments) + : FuncDeclaration(loc, endloc, Id::classDelete, STCstatic, NULL) +{ + this->arguments = arguments; +} + +Dsymbol *DeleteDeclaration::syntaxCopy(Dsymbol *s) +{ + DeleteDeclaration *f; + + f = new DeleteDeclaration(loc, endloc, NULL); + + FuncDeclaration::syntaxCopy(f); + + f->arguments = Parameter::arraySyntaxCopy(arguments); + + return f; +} + + +void DeleteDeclaration::semantic(Scope *sc) +{ + //printf("DeleteDeclaration::semantic()\n"); + + parent = sc->parent; + Dsymbol *parent = toParent(); + ClassDeclaration *cd = parent->isClassDeclaration(); + if (!cd && !parent->isStructDeclaration()) + { + error("new allocators only are for class or struct definitions"); + } + if (!type) + type = new TypeFunction(arguments, Type::tvoid, 0, LINKd); + + type = type->semantic(loc, sc); + assert(type->ty == Tfunction); + + // Check that there is only one argument of type void* + TypeFunction *tf = (TypeFunction *)type; + if (Parameter::dim(tf->parameters) != 1) + { + error("one argument of type void* expected"); + } + else + { + Parameter *a = Parameter::getNth(tf->parameters, 0); + if (!a->type->equals(Type::tvoid->pointerTo())) + error("one argument of type void* expected, not %s", a->type->toChars()); + } + + FuncDeclaration::semantic(sc); +} + +const char *DeleteDeclaration::kind() +{ + return "deallocator"; +} + +int DeleteDeclaration::isDelete() +{ + return TRUE; +} + +int DeleteDeclaration::isVirtual() +{ + return FALSE; +} + +int DeleteDeclaration::addPreInvariant() +{ + return FALSE; +} + +int DeleteDeclaration::addPostInvariant() +{ + return FALSE; +} + +void DeleteDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("delete"); + Parameter::argsToCBuffer(buf, hgs, arguments, 0); + bodyToCBuffer(buf, hgs); +} + + + + diff --git a/glue.c b/glue.c new file mode 100644 index 00000000..9c223223 --- /dev/null +++ b/glue.c @@ -0,0 +1,1234 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "id.h" +#include "import.h" +#include "template.h" +#include "lib.h" + +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +struct Environment; + +Environment *benv; + +void slist_add(Symbol *s); +void slist_reset(); +void clearStringTab(); + +#define STATICCTOR 0 + +typedef ArrayBase symbols; + +elem *eictor; +symbol *ictorlocalgot; +symbols sctors; +StaticDtorDeclarations ectorgates; +symbols sdtors; +symbols stests; + +symbols ssharedctors; +SharedStaticDtorDeclarations esharedctorgates; +symbols sshareddtors; + +int dtorcount; +int shareddtorcount; + +char *lastmname; + +/************************************** + * Append s to list of object files to generate later. + */ + +Dsymbols obj_symbols_towrite; + +void obj_append(Dsymbol *s) +{ + obj_symbols_towrite.push(s); +} + +void obj_write_deferred(Library *library) +{ + for (size_t i = 0; i < obj_symbols_towrite.dim; i++) + { Dsymbol *s = obj_symbols_towrite.tdata()[i]; + Module *m = s->getModule(); + + char *mname; + if (m) + { mname = m->srcfile->toChars(); + lastmname = mname; + } + else + { + //mname = s->ident->toChars(); + mname = lastmname; + assert(mname); + } + + obj_start(mname); + + static int count; + count++; // sequence for generating names + + /* Create a module that's a doppelganger of m, with just + * enough to be able to create the moduleinfo. + */ + OutBuffer idbuf; + idbuf.printf("%s.%d", m ? m->ident->toChars() : mname, count); + char *idstr = idbuf.toChars(); + idbuf.data = NULL; + Identifier *id = new Identifier(idstr, TOKidentifier); + + Module *md = new Module(mname, id, 0, 0); + md->members = new Dsymbols(); + md->members->push(s); // its only 'member' is s + if (m) + { + md->doppelganger = 1; // identify this module as doppelganger + md->md = m->md; + md->aimports.push(m); // it only 'imports' m + md->massert = m->massert; + md->munittest = m->munittest; + md->marray = m->marray; + } + + md->genobjfile(0); + + /* Set object file name to be source name with sequence number, + * as mangled symbol names get way too long. + */ + char *fname = FileName::removeExt(mname); + OutBuffer namebuf; + unsigned hash = 0; + for (char *p = s->toChars(); *p; p++) + hash += *p; + namebuf.printf("%s_%x_%x.%s", fname, count, hash, global.obj_ext); + namebuf.writeByte(0); + mem.free(fname); + fname = (char *)namebuf.extractData(); + + //printf("writing '%s'\n", fname); + File *objfile = new File(fname); + obj_end(library, objfile); + } + obj_symbols_towrite.dim = 0; +} + +/*********************************************** + * Generate function that calls array of functions and gates. + */ + +symbol *callFuncsAndGates(Module *m, symbols *sctors, StaticDtorDeclarations *ectorgates, + const char *id) +{ + symbol *sctor = NULL; + + if ((sctors && sctors->dim) || + (ectorgates && ectorgates->dim)) + { + static type *t; + if (!t) + { + /* t will be the type of the functions generated: + * extern (C) void func(); + */ + t = type_alloc(TYnfunc); + t->Tflags |= TFprototype | TFfixed; + t->Tmangle = mTYman_c; + t->Tnext = tsvoid; + tsvoid->Tcount++; + } + + localgot = NULL; + sctor = m->toSymbolX(id, SCglobal, t, "FZv"); + cstate.CSpsymtab = &sctor->Sfunc->Flocsym; + elem *ector = NULL; + + if (ectorgates) + { + for (size_t i = 0; i < ectorgates->dim; i++) + { StaticDtorDeclaration *f = (*ectorgates)[i]; + + Symbol *s = f->vgate->toSymbol(); + elem *e = el_var(s); + e = el_bin(OPaddass, TYint, e, el_long(TYint, 1)); + ector = el_combine(ector, e); + } + } + + if (sctors) + { + for (size_t i = 0; i < sctors->dim; i++) + { symbol *s = (*sctors)[i]; + elem *e = el_una(OPucall, TYvoid, el_var(s)); + ector = el_combine(ector, e); + } + } + + block *b = block_calloc(); + b->BC = BCret; + b->Belem = ector; + sctor->Sfunc->Fstartline.Sfilename = m->arg; + sctor->Sfunc->Fstartblock = b; + writefunc(sctor); + } + return sctor; +} + +/************************************** + * Prepare for generating obj file. + */ + +Outbuffer objbuf; + +void obj_start(char *srcfile) +{ + //printf("obj_start()\n"); + + rtlsym_reset(); + slist_reset(); + clearStringTab(); + + obj_init(&objbuf, srcfile, NULL); + + el_reset(); +#if TX86 + cg87_reset(); +#endif + out_reset(); +} + +void obj_end(Library *library, File *objfile) +{ + obj_term(); + + if (library) + { + // Transfer image to library + library->addObject(objfile->name->toChars(), objbuf.buf, objbuf.p - objbuf.buf); + objbuf.buf = NULL; + } + else + { + // Transfer image to file + objfile->setbuffer(objbuf.buf, objbuf.p - objbuf.buf); + objbuf.buf = NULL; + + char *p = FileName::path(objfile->name->toChars()); + FileName::ensurePathExists(p); + //mem.free(p); + + //printf("write obj %s\n", objfile->name->toChars()); + objfile->writev(); + } + objbuf.pend = NULL; + objbuf.p = NULL; + objbuf.len = 0; + objbuf.inc = 0; +} + +/************************************** + * Generate .obj file for Module. + */ + +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.tdata()[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->tdata()[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; + sp->Spreg = I64 ? DI : AX; + 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 FuncDeclaration::toObjFile(int multiobj) +{ + FuncDeclaration *func = this; + ClassDeclaration *cd = func->parent->isClassDeclaration(); + int reverse; + int has_arguments; + + //printf("FuncDeclaration::toObjFile(%p, %s.%s)\n", func, parent->toChars(), func->toChars()); + //if (type) printf("type = %s\n", func->type->toChars()); +#if 0 + //printf("line = %d\n",func->getWhere() / LINEINC); + EEcontext *ee = env->getEEcontext(); + if (ee->EEcompile == 2) + { + if (ee->EElinnum < (func->getWhere() / LINEINC) || + ee->EElinnum > (func->endwhere / LINEINC) + ) + return; // don't compile this function + ee->EEfunc = func->toSymbol(); + } +#endif + + if (semanticRun >= PASSobj) // if toObjFile() already run + return; + + // If errors occurred compiling it, such as bugzilla 6118 + if (type && type->ty == Tfunction && ((TypeFunction *)type)->next->ty == Terror) + return; + + if (!func->fbody) + { + return; + } + if (func->isUnitTestDeclaration() && !global.params.useUnitTests) + return; + + if (multiobj && !isStaticDtorDeclaration() && !isStaticCtorDeclaration()) + { obj_append(this); + return; + } + + assert(semanticRun == PASSsemantic3done); + semanticRun = PASSobj; + + if (global.params.verbose) + printf("function %s\n",func->toChars()); + + Symbol *s = func->toSymbol(); + func_t *f = s->Sfunc; + +#if TARGET_WINDOS + /* This is done so that the 'this' pointer on the stack is the same + * distance away from the function parameters, so that an overriding + * function can call the nested fdensure or fdrequire of its overridden function + * and the stack offsets are the same. + */ + if (isVirtual() && (fensure || frequire)) + f->Fflags3 |= Ffakeeh; +#endif + +#if TARGET_OSX + s->Sclass = SCcomdat; +#else + s->Sclass = SCglobal; +#endif + for (Dsymbol *p = parent; p; p = p->parent) + { + if (p->isTemplateInstance()) + { + s->Sclass = SCcomdat; + break; + } + } + + /* Vector operations should be comdat's + */ + if (isArrayOp) + s->Sclass = SCcomdat; + + if (isNested()) + { +// if (!(config.flags3 & CFG3pic)) +// s->Sclass = SCstatic; + f->Fflags3 |= Fnested; + } + else + { + const char *libname = (global.params.symdebug) + ? global.params.debuglibname + : global.params.defaultlibname; + + // Pull in RTL startup code + if (func->isMain()) + { objextdef("_main"); +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + obj_ehsections(); // initialize exception handling sections +#endif +#if TARGET_WINDOS + objextdef("__acrtused_con"); +#endif + obj_includelib(libname); + s->Sclass = SCglobal; + } + else if (strcmp(s->Sident, "main") == 0 && linkage == LINKc) + { +#if TARGET_WINDOS + objextdef("__acrtused_con"); // bring in C startup code + obj_includelib("snn.lib"); // bring in C runtime library +#endif + s->Sclass = SCglobal; + } + else if (func->isWinMain()) + { + objextdef("__acrtused"); + obj_includelib(libname); + s->Sclass = SCglobal; + } + + // Pull in RTL startup code + else if (func->isDllMain()) + { + objextdef("__acrtused_dll"); + obj_includelib(libname); + s->Sclass = SCglobal; + } + } + + cstate.CSpsymtab = &f->Flocsym; + + // Find module m for this function + Module *m = NULL; + for (Dsymbol *p = parent; p; p = p->parent) + { + m = p->isModule(); + if (m) + break; + } + + IRState irs(m, func); + Dsymbols deferToObj; // write these to OBJ file later + irs.deferToObj = &deferToObj; + + TypeFunction *tf; + enum RET retmethod; + symbol *shidden = NULL; + Symbol *sthis = NULL; + tym_t tyf; + + tyf = tybasic(s->Stype->Tty); + //printf("linkage = %d, tyf = x%x\n", linkage, tyf); + reverse = tyrevfunc(s->Stype->Tty); + + assert(func->type->ty == Tfunction); + tf = (TypeFunction *)(func->type); + has_arguments = (tf->linkage == LINKd) && (tf->varargs == 1); + retmethod = tf->retStyle(); + if (retmethod == RETstack) + { + // If function returns a struct, put a pointer to that + // as the first argument + ::type *thidden = tf->next->pointerTo()->toCtype(); + char hiddenparam[5+4+1]; + static int hiddenparami; // how many we've generated so far + + sprintf(hiddenparam,"__HID%d",++hiddenparami); + shidden = symbol_name(hiddenparam,SCparameter,thidden); + shidden->Sflags |= SFLtrue | SFLfree; +#if DMDV1 + if (func->nrvo_can && func->nrvo_var && func->nrvo_var->nestedref) +#else + if (func->nrvo_can && func->nrvo_var && func->nrvo_var->nestedrefs.dim) +#endif + type_setcv(&shidden->Stype, shidden->Stype->Tty | mTYvolatile); + irs.shidden = shidden; + this->shidden = shidden; + } + + if (vthis) + { + assert(!vthis->csym); + sthis = vthis->toSymbol(); + irs.sthis = sthis; + if (!(f->Fflags3 & Fnested)) + f->Fflags3 |= Fmember; + } + + Symbol **params; + unsigned pi; + + // Estimate number of parameters, pi + pi = (v_arguments != NULL); + if (parameters) + pi += parameters->dim; + // Allow extra 2 for sthis and shidden + params = (Symbol **)alloca((pi + 2) * sizeof(Symbol *)); + + // Get the actual number of parameters, pi, and fill in the params[] + pi = 0; + if (v_arguments) + { + params[pi] = v_arguments->toSymbol(); + pi += 1; + } + if (parameters) + { + for (size_t i = 0; i < parameters->dim; i++) + { VarDeclaration *v = parameters->tdata()[i]; + if (v->csym) + { + error("compiler error, parameter '%s', bugzilla 2962?", v->toChars()); + assert(0); + } + params[pi + i] = v->toSymbol(); + } + pi += parameters->dim; + } + + if (reverse) + { // Reverse params[] entries + for (size_t i = 0; i < pi/2; i++) + { + Symbol *sptmp = params[i]; + params[i] = params[pi - 1 - i]; + params[pi - 1 - i] = sptmp; + } + } + + if (shidden) + { +#if 0 + // shidden becomes last parameter + params[pi] = shidden; +#else + // shidden becomes first parameter + memmove(params + 1, params, pi * sizeof(params[0])); + params[0] = shidden; +#endif + pi++; + } + + + if (sthis) + { +#if 0 + // sthis becomes last parameter + params[pi] = sthis; +#else + // sthis becomes first parameter + memmove(params + 1, params, pi * sizeof(params[0])); + params[0] = sthis; +#endif + pi++; + } + + if ((global.params.isLinux || global.params.isOSX || global.params.isFreeBSD || global.params.isSolaris) && + linkage != LINKd && shidden && sthis) + { + /* swap shidden and sthis + */ + Symbol *sp = params[0]; + params[0] = params[1]; + params[1] = sp; + } + + for (size_t i = 0; i < pi; i++) + { Symbol *sp = params[i]; + sp->Sclass = SCparameter; + sp->Sflags &= ~SFLspill; + sp->Sfl = FLpara; + symbol_add(sp); + } + + // Determine register assignments + if (pi) + { + if (global.params.is64bit) + { + // Order of assignment of pointer or integer parameters + static const unsigned char argregs[6] = { DI,SI,DX,CX,R8,R9 }; + int r = 0; + int xmmcnt = XMM0; + + for (size_t i = 0; i < pi; i++) + { Symbol *sp = params[i]; + tym_t ty = tybasic(sp->Stype->Tty); + // BUG: doesn't work for structs + if (r < sizeof(argregs)/sizeof(argregs[0])) + { + if (type_jparam(sp->Stype)) + { + sp->Sclass = SCfastpar; + sp->Spreg = argregs[r]; + sp->Sfl = FLauto; + ++r; + } + } + if (xmmcnt <= XMM7) + { + if (tyxmmreg(ty)) + { + sp->Sclass = SCfastpar; + sp->Spreg = xmmcnt; + sp->Sfl = FLauto; + ++xmmcnt; + } + } + } + } + else + { + // First parameter goes in register + Symbol *sp = params[0]; + if ((tyf == TYjfunc || tyf == TYmfunc) && + type_jparam(sp->Stype)) + { sp->Sclass = SCfastpar; + sp->Spreg = (tyf == TYjfunc) ? AX : CX; + sp->Sfl = FLauto; + //printf("'%s' is SCfastpar\n",sp->Sident); + } + } + } + + if (func->fbody) + { block *b; + Blockx bx; + Statement *sbody; + + localgot = NULL; + + sbody = func->fbody; + memset(&bx,0,sizeof(bx)); + bx.startblock = block_calloc(); + bx.curblock = bx.startblock; + bx.funcsym = s; + bx.scope_index = -1; + bx.classdec = cd; + bx.member = func; + bx.module = getModule(); + irs.blx = &bx; +#if DMDV2 + buildClosure(&irs); +#endif + +#if 0 + if (func->isSynchronized()) + { + if (cd) + { elem *esync; + if (func->isStatic()) + { // monitor is in ClassInfo + esync = el_ptr(cd->toSymbol()); + } + else + { // 'this' is the monitor + esync = el_var(sthis); + } + + if (func->isStatic() || sbody->usesEH() || + !(config.flags2 & CFG2seh)) + { // BUG: what if frequire or fensure uses EH? + + sbody = new SynchronizedStatement(func->loc, esync, sbody); + } + else + { +#if TARGET_WINDOS + if (config.flags2 & CFG2seh) + { + /* The "jmonitor" uses an optimized exception handling frame + * which is a little shorter than the more general EH frame. + * It isn't strictly necessary. + */ + s->Sfunc->Fflags3 |= Fjmonitor; + } +#endif + el_free(esync); + } + } + else + { + error("synchronized function %s must be a member of a class", func->toChars()); + } + } +#elif TARGET_WINDOS + if (func->isSynchronized() && cd && config.flags2 & CFG2seh && + !func->isStatic() && !sbody->usesEH()) + { + /* The "jmonitor" hack uses an optimized exception handling frame + * which is a little shorter than the more general EH frame. + */ + s->Sfunc->Fflags3 |= Fjmonitor; + } +#endif + + sbody->toIR(&irs); + bx.curblock->BC = BCret; + + f->Fstartblock = bx.startblock; +// einit = el_combine(einit,bx.init); + + if (isCtorDeclaration()) + { + assert(sthis); + for (b = f->Fstartblock; b; b = b->Bnext) + { + if (b->BC == BCret) + { + b->BC = BCretexp; + b->Belem = el_combine(b->Belem, el_var(sthis)); + } + } + } + } + + // If static constructor +#if DMDV2 + if (isSharedStaticCtorDeclaration()) // must come first because it derives from StaticCtorDeclaration + { + ssharedctors.push(s); + } + else +#endif + if (isStaticCtorDeclaration()) + { + sctors.push(s); + } + + // If static destructor +#if DMDV2 + if (isSharedStaticDtorDeclaration()) // must come first because it derives from StaticDtorDeclaration + { + SharedStaticDtorDeclaration *f = isSharedStaticDtorDeclaration(); + assert(f); + if (f->vgate) + { /* Increment destructor's vgate at construction time + */ + esharedctorgates.push(f); + } + + sshareddtors.shift(s); + } + else +#endif + if (isStaticDtorDeclaration()) + { + StaticDtorDeclaration *f = isStaticDtorDeclaration(); + assert(f); + if (f->vgate) + { /* Increment destructor's vgate at construction time + */ + ectorgates.push(f); + } + + sdtors.shift(s); + } + + // If unit test + if (isUnitTestDeclaration()) + { + stests.push(s); + } + + if (global.errors) + return; + + writefunc(s); + if (isExport()) + obj_export(s, Poffset); + + for (size_t i = 0; i < irs.deferToObj->dim; i++) + { + Dsymbol *s = irs.deferToObj->tdata()[i]; + s->toObjFile(0); + } + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + // A hack to get a pointer to this function put in the .dtors segment + if (ident && memcmp(ident->toChars(), "_STD", 4) == 0) + obj_staticdtor(s); +#endif +#if DMDV2 + if (irs.startaddress) + { + printf("Setting start address\n"); + obj_startaddress(irs.startaddress); + } +#endif +} + +/* ================================================================== */ + +/***************************** + * Return back end type corresponding to D front end type. + */ + +unsigned Type::totym() +{ unsigned t; + + switch (ty) + { + case Tvoid: t = TYvoid; break; + case Tint8: t = TYschar; break; + case Tuns8: t = TYuchar; break; + case Tint16: t = TYshort; break; + case Tuns16: t = TYushort; break; + case Tint32: t = TYint; break; + case Tuns32: t = TYuint; break; + case Tint64: t = TYllong; break; + case Tuns64: t = TYullong; break; + case Tfloat32: t = TYfloat; break; + case Tfloat64: t = TYdouble; break; + case Tfloat80: t = TYldouble; break; + case Timaginary32: t = TYifloat; break; + case Timaginary64: t = TYidouble; break; + case Timaginary80: t = TYildouble; break; + case Tcomplex32: t = TYcfloat; break; + case Tcomplex64: t = TYcdouble; break; + case Tcomplex80: t = TYcldouble; break; + case Tbool: t = TYbool; break; + case Tchar: t = TYchar; break; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case Twchar: t = TYwchar_t; break; + case Tdchar: t = TYdchar; break; +#else + case Twchar: t = TYwchar_t; break; + case Tdchar: + t = (global.params.symdebug == 1) ? TYdchar : TYulong; + break; +#endif + + case Taarray: t = TYaarray; break; + case Tclass: + case Treference: + case Tpointer: t = TYnptr; break; + case Tdelegate: t = TYdelegate; break; + case Tarray: t = TYdarray; break; +#if SARRAYVALUE + case Tsarray: t = TYstruct; break; +#else + case Tsarray: t = TYarray; break; +#endif + case Tstruct: t = TYstruct; break; + + case Tenum: + case Ttypedef: + t = toBasetype()->totym(); + break; + + case Tident: + case Ttypeof: +#ifdef DEBUG + printf("ty = %d, '%s'\n", ty, toChars()); +#endif + error(0, "forward reference of %s", toChars()); + t = TYint; + break; + + case Tnull: + t = TYnptr; + break; + + case Tvector: + { TypeVector *tv = (TypeVector *)this; + TypeBasic *tb = tv->elementType(); + switch (tb->ty) + { case Tvoid: + case Tint8: t = TYschar16; break; + case Tuns8: t = TYuchar16; break; + case Tint16: t = TYshort8; break; + case Tuns16: t = TYushort8; break; + case Tint32: t = TYlong4; break; + case Tuns32: t = TYulong4; break; + case Tint64: t = TYllong2; break; + case Tuns64: t = TYullong2; break; + case Tfloat32: t = TYfloat4; break; + case Tfloat64: t = TYdouble2; break; + default: + assert(0); + break; + } + break; + } + + default: +#ifdef DEBUG + printf("ty = %d, '%s'\n", ty, toChars()); + halt(); +#endif + assert(0); + } + +#if DMDV2 + // Add modifiers + switch (mod) + { + case 0: + break; + case MODconst: + case MODwild: + t |= mTYconst; + break; + case MODimmutable: + t |= mTYimmutable; + break; + case MODshared: + t |= mTYshared; + break; + case MODshared | MODwild: + case MODshared | MODconst: + t |= mTYshared | mTYconst; + break; + default: + assert(0); + } +#endif + + return t; +} + +unsigned TypeFunction::totym() +{ + tym_t tyf; + + //printf("TypeFunction::totym(), linkage = %d\n", linkage); + switch (linkage) + { + case LINKwindows: + tyf = (varargs == 1) ? TYnfunc : TYnsfunc; + break; + + case LINKpascal: + tyf = (varargs == 1) ? TYnfunc : TYnpfunc; + break; + + case LINKc: + tyf = TYnfunc; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (I32 && retStyle() == RETstack) + tyf = TYhfunc; +#endif + break; + + case LINKd: + tyf = (varargs == 1) ? TYnfunc : TYjfunc; + break; + + case LINKcpp: + tyf = TYnfunc; + break; + + default: + printf("linkage = %d\n", linkage); + assert(0); + } +#if DMDV2 + if (isnothrow) + tyf |= mTYnothrow; +#endif + return tyf; +} + +/************************************** + */ + +Symbol *Type::toSymbol() +{ + assert(0); + return NULL; +} + +Symbol *TypeClass::toSymbol() +{ + return sym->toSymbol(); +} + +/************************************* + * Generate symbol in data segment for critical section. + */ + +Symbol *Module::gencritsec() +{ + Symbol *s; + type *t; + + t = Type::tint32->toCtype(); + s = symbol_name("critsec", SCstatic, t); + s->Sfl = FLdata; + /* Must match D_CRITICAL_SECTION in phobos/internal/critical.c + */ + dtnzeros(&s->Sdt, PTRSIZE + (I64 ? os_critsecsize64() : os_critsecsize32())); +#if ELFOBJ || MACHOBJ // Burton + s->Sseg = DATA; +#endif + outdata(s); + return s; +} + +/************************************** + * Generate elem that is a pointer to the module file name. + */ + +elem *Module::toEfilename() +{ elem *efilename; + + if (!sfilename) + { + dt_t *dt = NULL; + char *id; + int len; + + id = srcfile->toChars(); + len = strlen(id); + dtsize_t(&dt, len); + dtabytes(&dt,TYnptr, 0, len + 1, id); + + sfilename = symbol_generate(SCstatic,type_fake(TYdarray)); + sfilename->Sdt = dt; + sfilename->Sfl = FLdata; +#if ELFOBJ + sfilename->Sseg = CDATA; +#endif +#if MACHOBJ + // Because of PIC and CDATA being in the _TEXT segment, cannot + // have pointers in CDATA + sfilename->Sseg = DATA; +#endif + outdata(sfilename); + } + + efilename = el_var(sfilename); + return efilename; +} + + diff --git a/gpl.txt b/gpl.txt new file mode 100644 index 00000000..43cd72c3 --- /dev/null +++ b/gpl.txt @@ -0,0 +1,248 @@ + GNU GENERAL PUBLIC LICENSE + Version 1, February 1989 + + Copyright (C) 1989 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The license agreements of most software companies try to keep users +at the mercy of those companies. By contrast, our General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. The +General Public License applies to the Free Software Foundation's +software and to any other program whose authors commit to using it. +You can use it for your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Specifically, the General Public License is designed to make +sure that you have the freedom to give away or sell copies of free +software, that you receive source code or can get it if you want it, +that you can change the software or use pieces of it in new free +programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of a such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must tell them their rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any program or other work which +contains a notice placed by the copyright holder saying it may be +distributed under the terms of this General Public License. The +"Program", below, refers to any such program or work, and a "work based +on the Program" means either the Program or any work containing the +Program or a portion of it, either verbatim or with modifications. Each +licensee is addressed as "you". + + 1. You may copy and distribute verbatim copies of the Program's source +code as you receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice and +disclaimer of warranty; keep intact all the notices that refer to this +General Public License and to the absence of any warranty; and give any +other recipients of the Program a copy of this General Public License +along with the Program. You may charge a fee for the physical act of +transferring a copy. + + 2. You may modify your copy or copies of the Program or any portion of +it, and copy and distribute such modifications under the terms of Paragraph +1 above, provided that you also do the following: + + a) cause the modified files to carry prominent notices stating that + you changed the files and the date of any change; and + + b) cause the whole of any work that you distribute or publish, that + in whole or in part contains the Program or any part thereof, either + with or without modifications, to be licensed at no charge to all + third parties under the terms of this General Public License (except + that you may choose to grant warranty protection to some or all + third parties, at your option). + + c) If the modified program normally reads commands interactively when + run, you must cause it, when started running for such interactive use + in the simplest and most usual way, to print or display an + announcement including an appropriate copyright notice and a notice + that there is no warranty (or else, saying that you provide a + warranty) and that users may redistribute the program under these + conditions, and telling the user how to view a copy of this General + Public License. + + d) You may charge a fee for the physical act of transferring a + copy, and you may at your option offer warranty protection in + exchange for a fee. + +Mere aggregation of another independent work with the Program (or its +derivative) on a volume of a storage or distribution medium does not bring +the other work under the scope of these terms. + + 3. You may copy and distribute the Program (or a portion or derivative of +it, under Paragraph 2) in object code or executable form under the terms of +Paragraphs 1 and 2 above provided that you also do one of the following: + + a) accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of + Paragraphs 1 and 2 above; or, + + b) accompany it with a written offer, valid for at least three + years, to give any third party free (except for a nominal charge + for the cost of distribution) a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of + Paragraphs 1 and 2 above; or, + + c) accompany it with the information you received as to where the + corresponding source code may be obtained. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form alone.) + +Source code for a work means the preferred form of the work for making +modifications to it. For an executable file, complete source code means +all the source code for all modules it contains; but, as a special +exception, it need not include source code for modules which are standard +libraries that accompany the operating system on which the executable +file runs, or for standard header files or definitions files that +accompany that operating system. + + 4. You may not copy, modify, sublicense, distribute or transfer the +Program except as expressly provided under this General Public License. +Any attempt otherwise to copy, modify, sublicense, distribute or transfer +the Program is void, and will automatically terminate your rights to use +the Program under this License. However, parties who have received +copies, or rights to use copies, from you under this General Public +License will not have their licenses terminated so long as such parties +remain in full compliance. + + 5. By copying, distributing or modifying the Program (or any work based +on the Program) you indicate your acceptance of this license to do so, +and all its terms and conditions. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the original +licensor to copy, distribute or modify the Program subject to these +terms and conditions. You may not impose any further restrictions on the +recipients' exercise of the rights granted herein. + + 7. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of the license which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +the license, you may choose any version ever published by the Free Software +Foundation. + + 8. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to humanity, the best way to achieve this is to make it +free software which everyone can redistribute and change under these +terms. + + To do so, attach the following notices to the program. It is safest to +attach them to the start of each source file to most effectively convey +the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19xx name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the +appropriate parts of the General Public License. Of course, the +commands you use may be called something other than `show w' and `show +c'; they could even be mouse-clicks or menu items--whatever suits your +program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + program `Gnomovision' (a program to direct compilers to make passes + at assemblers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/hdrgen.c b/hdrgen.c new file mode 100644 index 00000000..78dd4001 --- /dev/null +++ b/hdrgen.c @@ -0,0 +1,100 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// Initial header generation implementation by Dave Fladebo +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Routines to emit header files + +#define PRETTY_PRINT +#define TEST_EMIT_ALL 0 // For Testing + +#define LOG 0 + +#include +#include +#include +#if __DMC__ +#include +#endif + +#include "rmem.h" + +#include "id.h" +#include "init.h" + +#include "attrib.h" +#include "cond.h" +#include "enum.h" +#include "import.h" +#include "module.h" +#include "mtype.h" +#include "scope.h" +#include "staticassert.h" +#include "template.h" +#include "utf.h" +#include "version.h" + +#include "declaration.h" +#include "aggregate.h" +#include "expression.h" +#include "statement.h" +#include "mtype.h" +#include "hdrgen.h" + +void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); + +void Module::genhdrfile() +{ + OutBuffer hdrbufr; + + hdrbufr.printf("// D import file generated from '%s'", srcfile->toChars()); + hdrbufr.writenl(); + + HdrGenState hgs; + memset(&hgs, 0, sizeof(hgs)); + hgs.hdrgen = 1; + + toCBuffer(&hdrbufr, &hgs); + + // Transfer image to file + hdrfile->setbuffer(hdrbufr.data, hdrbufr.offset); + hdrbufr.data = NULL; + + char *pt = FileName::path(hdrfile->toChars()); + if (*pt) + FileName::ensurePathExists(pt); + mem.free(pt); + hdrfile->writev(); +} + + +void Module::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (md) + { + buf->writestring("module "); + buf->writestring(md->toChars()); + buf->writebyte(';'); + buf->writenl(); + } + + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + s->toHBuffer(buf, hgs); + } +} + + +void Dsymbol::toHBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + toCBuffer(buf, hgs); +} + + +/*************************************/ diff --git a/hdrgen.h b/hdrgen.h new file mode 100644 index 00000000..79cfb732 --- /dev/null +++ b/hdrgen.h @@ -0,0 +1,34 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// initial header generation implementation by Dave Fladebo +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +struct HdrGenState +{ + int hdrgen; // 1 if generating header file + int ddoc; // 1 if generating Ddoc file + int console; // 1 if writing to console + int tpltMember; + int inCallExp; + int inPtrExp; + int inSlcExp; + int inDotExp; + int inBinExp; + int inArrExp; + int emitInst; + struct + { + int init; + int decl; + } FLinit; + + HdrGenState() { memset(this, 0, sizeof(HdrGenState)); } +}; + + diff --git a/iasm.c b/iasm.c new file mode 100644 index 00000000..6973bf7f --- /dev/null +++ b/iasm.c @@ -0,0 +1,4851 @@ + +/* + * Copyright (c) 1992-1999 by Symantec + * Copyright (c) 1999-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * http://www.dsource.org/projects/dmd/browser/branches/dmd-1.x/src/iasm.c + * http://www.dsource.org/projects/dmd/browser/trunk/src/iasm.c + * Written by Mike Cote, John Micco and Walter Bright + * D version by Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Inline assembler for the D programming language compiler + +#include +#include +#include +#include +#include +#include +#include +#if __DMC__ +#undef setjmp +#include +#endif + + +// D compiler +#include "mars.h" +#include "lexer.h" +#include "mtype.h" +#include "statement.h" +#include "id.h" +#include "declaration.h" +#include "scope.h" +#include "init.h" +#include "enum.h" +#include "module.h" + +// C/C++ compiler +#define SCOPE_H 1 // avoid conflicts with D's Scope +#include "cc.h" +#include "token.h" +#include "global.h" +#include "el.h" +#include "type.h" +#include "oper.h" +#include "code.h" +#include "iasm.h" +#include "xmm.h" + +// I32 isn't set correctly yet because this is the front end, and I32 +// is a backend flag +#undef I16 +#undef I32 +#undef I64 +#define I16 0 +#define I32 (global.params.is64bit == 0) +#define I64 (global.params.is64bit == 1) + +//#define EXTRA_DEBUG 1 + +#undef ADDFWAIT +#define ADDFWAIT() 0 + +// Error numbers +enum ASMERRMSGS +{ + EM_bad_float_op, + EM_bad_addr_mode, + EM_align, + EM_opcode_exp, + EM_prefix, + EM_eol, + EM_bad_operand, + EM_bad_integral_operand, + EM_ident_exp, + EM_not_struct, + EM_nops_expected, + EM_bad_op, + EM_const_init, + EM_undefined, + EM_pointer, + EM_colon, + EM_rbra, + EM_rpar, + EM_ptr_exp, + EM_num, + EM_float, + EM_char, + EM_label_expected, + EM_uplevel, + EM_type_as_operand, + EM_invalid_64bit_opcode, +}; + +const char *asmerrmsgs[] = +{ + "unknown operand for floating point instruction", + "bad addr mode", + "align %d must be a power of 2", + "opcode expected, not %s", + "prefix", + "end of instruction", + "bad operand", + "bad integral operand", + "identifier expected", + "not struct", + "%u operands found for %s instead of the expected %u", + "bad type/size of operands '%s'", + "constant initializer expected", + "undefined identifier '%s'", + "pointer", + "colon", + "] expected instead of '%s'", + ") expected instead of '%s'", + "ptr expected", + "integer expected", + "floating point expected", + "character is truncated", + "label expected", + "uplevel nested reference to variable %s", + "cannot use type %s as an operand", + "opcode %s is unavailable in 64bit mode" +}; + +// Additional tokens for the inline assembler +typedef enum +{ + ASMTKlocalsize = TOKMAX + 1, + ASMTKdword, + ASMTKeven, + ASMTKfar, + ASMTKnaked, + ASMTKnear, + ASMTKptr, + ASMTKqword, + ASMTKseg, + ASMTKword, + ASMTKmax = ASMTKword-(TOKMAX+1)+1 +} ASMTK; + +static const char *apszAsmtk[ASMTKmax] = { + "__LOCAL_SIZE", + "dword", + "even", + "far", + "naked", + "near", + "ptr", + "qword", + "seg", + "word", +}; + +struct ASM_STATE +{ + unsigned char ucItype; // Instruction type +#define ITprefix 0x10 // special prefix +#define ITjump 0x20 // jump instructions CALL, Jxx and LOOPxx +#define ITimmed 0x30 // value of an immediate operand controls + // code generation +#define ITopt 0x40 // not all operands are required +#define ITshift 0x50 // rotate and shift instructions +#define ITfloat 0x60 // floating point coprocessor instructions +#define ITdata 0x70 // DB, DW, DD, DQ, DT pseudo-ops +#define ITaddr 0x80 // DA (define addresss) pseudo-op +#define ITMASK 0xF0 +#define ITSIZE 0x0F // mask for size + + Loc loc; + unsigned char bInit; + LabelDsymbol *psDollar; + Dsymbol *psLocalsize; + jmp_buf env; + unsigned char bReturnax; + AsmStatement *statement; + Scope *sc; +}; + +ASM_STATE asmstate; + +static Token *asmtok; +static enum TOK tok_value; +//char debuga = 1; + +// From ptrntab.c +const char *asm_opstr(OP *pop); +OP *asm_op_lookup(const char *s); +void init_optab(); + +static unsigned char asm_TKlbra_seen = FALSE; + +typedef struct +{ + char regstr[6]; + unsigned char val; + opflag_t ty; +} REG; + +static REG regFp = { "ST", 0, _st }; + +static REG aregFp[] = { + { "ST(0)", 0, _sti }, + { "ST(1)", 1, _sti }, + { "ST(2)", 2, _sti }, + { "ST(3)", 3, _sti }, + { "ST(4)", 4, _sti }, + { "ST(5)", 5, _sti }, + { "ST(6)", 6, _sti }, + { "ST(7)", 7, _sti } +}; +#define _AL 0 +#define _AH 4 +#define _AX 0 +#define _EAX 0 +#define _BL 3 +#define _BH 7 +#define _BX 3 +#define _EBX 3 +#define _CL 1 +#define _CH 5 +#define _CX 1 +#define _ECX 1 +#define _DL 2 +#define _DH 6 +#define _DX 2 +#define _EDX 2 +#define _BP 5 +#define _EBP 5 +#define _SP 4 +#define _ESP 4 +#define _DI 7 +#define _EDI 7 +#define _SI 6 +#define _ESI 6 +#define _ES 0 +#define _CS 1 +#define _SS 2 +#define _DS 3 +#define _GS 5 +#define _FS 4 + +static REG regtab[] = +{ +"AL", _AL, _r8 | _al, +"AH", _AH, _r8, +"AX", _AX, _r16 | _ax, +"EAX", _EAX, _r32 | _eax, +"BL", _BL, _r8, +"BH", _BH, _r8, +"BX", _BX, _r16, +"EBX", _EBX, _r32, +"CL", _CL, _r8 | _cl, +"CH", _CH, _r8, +"CX", _CX, _r16, +"ECX", _ECX, _r32, +"DL", _DL, _r8, +"DH", _DH, _r8, +"DX", _DX, _r16 | _dx, +"EDX", _EDX, _r32, +"BP", _BP, _r16, +"EBP", _EBP, _r32, +"SP", _SP, _r16, +"ESP", _ESP, _r32, +"DI", _DI, _r16, +"EDI", _EDI, _r32, +"SI", _SI, _r16, +"ESI", _ESI, _r32, +"ES", _ES, _seg | _es, +"CS", _CS, _seg | _cs, +"SS", _SS, _seg | _ss , +"DS", _DS, _seg | _ds, +"GS", _GS, _seg | _gs, +"FS", _FS, _seg | _fs, +"CR0", 0, _special | _crn, +"CR2", 2, _special | _crn, +"CR3", 3, _special | _crn, +"CR4", 4, _special | _crn, +"DR0", 0, _special | _drn, +"DR1", 1, _special | _drn, +"DR2", 2, _special | _drn, +"DR3", 3, _special | _drn, +"DR4", 4, _special | _drn, +"DR5", 5, _special | _drn, +"DR6", 6, _special | _drn, +"DR7", 7, _special | _drn, +"TR3", 3, _special | _trn, +"TR4", 4, _special | _trn, +"TR5", 5, _special | _trn, +"TR6", 6, _special | _trn, +"TR7", 7, _special | _trn, +"MM0", 0, _mm, +"MM1", 1, _mm, +"MM2", 2, _mm, +"MM3", 3, _mm, +"MM4", 4, _mm, +"MM5", 5, _mm, +"MM6", 6, _mm, +"MM7", 7, _mm, +"XMM0", 0, _xmm | _xmm0, +"XMM1", 1, _xmm, +"XMM2", 2, _xmm, +"XMM3", 3, _xmm, +"XMM4", 4, _xmm, +"XMM5", 5, _xmm, +"XMM6", 6, _xmm, +"XMM7", 7, _xmm, +}; + +// 64 bit only registers +#define _RAX 0 +#define _RBX 3 +#define _RCX 1 +#define _RDX 2 +#define _RSI 6 +#define _RDI 7 +#define _RBP 5 +#define _RSP 4 +#define _R8 8 +#define _R9 9 +#define _R10 10 +#define _R11 11 +#define _R12 12 +#define _R13 13 +#define _R14 14 +#define _R15 15 + +#define _R8D 8 +#define _R9D 9 +#define _R10D 10 +#define _R11D 11 +#define _R12D 12 +#define _R13D 13 +#define _R14D 14 +#define _R15D 15 + +#define _R8W 8 +#define _R9W 9 +#define _R10W 10 +#define _R11W 11 +#define _R12W 12 +#define _R13W 13 +#define _R14W 13 +#define _R15W 15 + +#define _SIL 6 +#define _DIL 7 +#define _BPL 5 +#define _SPL 4 +#define _R8B 8 +#define _R9B 9 +#define _R10B 10 +#define _R11B 11 +#define _R12B 12 +#define _R13B 13 +#define _R14B 14 +#define _R15B 15 + +static REG regtab64[] = +{ +"RAX", _RAX, _r64 | _rax, +"RBX", _RBX, _r64, +"RCX", _RCX, _r64, +"RDX", _RDX, _r64, +"RSI", _RSI, _r64, +"RDI", _RDI, _r64, +"RBP", _RBP, _r64, +"RSP", _RSP, _r64, +"R8", _R8, _r64, +"R9", _R9, _r64, +"R10", _R10, _r64, +"R11", _R11, _r64, +"R12", _R12, _r64, +"R13", _R13, _r64, +"R14", _R14, _r64, +"R15", _R15, _r64, + +"R8D", _R8D, _r32, +"R9D", _R9D, _r32, +"R10D", _R10D, _r32, +"R11D", _R11D, _r32, +"R12D", _R12D, _r32, +"R13D", _R13D, _r32, +"R14D", _R14D, _r32, +"R15D", _R15D, _r32, + +"R8W", _R8W, _r16, +"R9W", _R9W, _r16, +"R10W", _R10W, _r16, +"R11W", _R11W, _r16, +"R12W", _R12W, _r16, +"R13W", _R13W, _r16, +"R14W", _R14W, _r16, +"R15W", _R15W, _r16, + +"SIL", _SIL, _r8, +"DIL", _DIL, _r8, +"BPL", _BPL, _r8, +"SPL", _SPL, _r8, +"R8B", _R8B, _r8, +"R9B", _R9B, _r8, +"R10B", _R10B, _r8, +"R11B", _R11B, _r8, +"R12B", _R12B, _r8, +"R13B", _R13B, _r8, +"R14B", _R14B, _r8, +"R15B", _R15B, _r8, + +"XMM8", 8, _xmm, +"XMM9", 9, _xmm, +"XMM10", 10, _xmm, +"XMM11", 11, _xmm, +"XMM12", 12, _xmm, +"XMM13", 13, _xmm, +"XMM14", 14, _xmm, +"XMM15", 15, _xmm, + +"YMM0", 0, _ymm, +"YMM1", 1, _ymm, +"YMM2", 2, _ymm, +"YMM3", 3, _ymm, +"YMM4", 4, _ymm, +"YMM5", 5, _ymm, +"YMM6", 6, _ymm, +"YMM7", 7, _ymm, +"YMM8", 8, _ymm, +"YMM9", 9, _ymm, +"YMM10", 10, _ymm, +"YMM11", 11, _ymm, +"YMM12", 12, _ymm, +"YMM13", 13, _ymm, +"YMM14", 14, _ymm, +"YMM15", 15, _ymm, +}; + +typedef enum { + ASM_JUMPTYPE_UNSPECIFIED, + ASM_JUMPTYPE_SHORT, + ASM_JUMPTYPE_NEAR, + ASM_JUMPTYPE_FAR +} ASM_JUMPTYPE; // ajt + +typedef struct opnd +{ + REG *base; // if plain register + REG *pregDisp1; // if [register1] + REG *pregDisp2; + REG *segreg; // if segment override + char indirect; // if had a '*' or '->' + char bOffset; // if 'offset' keyword + char bSeg; // if 'segment' keyword + char bPtr; // if 'ptr' keyword + unsigned uchMultiplier; // register multiplier; valid values are 0,1,2,4,8 + opflag_t usFlags; + Dsymbol *s; + targ_llong disp; + long double real; + Type *ptype; + ASM_JUMPTYPE ajt; +} OPND; + +// +// Exported functions called from the compiler +// +int asm_state(int iFlags); +void iasm_term(); + +// +// Local functions defined and only used here +// +STATIC OPND *asm_add_exp(); +STATIC OPND *opnd_calloc(); +STATIC void opnd_free(OPND *popnd); +STATIC OPND *asm_and_exp(); +STATIC OPND *asm_cond_exp(); +STATIC opflag_t asm_determine_operand_flags(OPND *popnd); +code *asm_genloc(Loc loc, code *c); +int asm_getnum(); + +STATIC void asmerr(const char *, ...); + +#if __clang__ +STATIC void asmerr(int, ...) __attribute__((analyzer_noreturn)); +#else +STATIC void asmerr(int, ...); +#if __DMC__ +#pragma SC noreturn(asmerr) +#endif +#endif + +STATIC OPND *asm_equal_exp(); +STATIC OPND *asm_inc_or_exp(); +STATIC OPND *asm_log_and_exp(); +STATIC OPND *asm_log_or_exp(); +STATIC char asm_length_type_size(OPND *popnd); +STATIC void asm_token(); +STATIC void asm_token_trans(Token *tok); +STATIC unsigned char asm_match_flags(opflag_t usOp , opflag_t usTable ); +STATIC unsigned char asm_match_float_flags(opflag_t usOp, opflag_t usTable); +STATIC void asm_make_modrm_byte( +#ifdef DEBUG + unsigned char *puchOpcode, unsigned *pusIdx, +#endif + code *pc, + unsigned usFlags, + OPND *popnd, OPND *popnd2); +STATIC regm_t asm_modify_regs(PTRNTAB ptb, OPND *popnd1, OPND *popnd2); +STATIC void asm_output_flags(opflag_t usFlags); +STATIC void asm_output_popnd(OPND *popnd); +STATIC unsigned asm_type_size(Type * ptype); +STATIC opflag_t asm_float_type_size(Type * ptype, opflag_t *pusFloat); +STATIC OPND *asm_mul_exp(); +STATIC OPND *asm_br_exp(); +STATIC OPND *asm_primary_exp(); +STATIC OPND *asm_prim_post(OPND *); +STATIC OPND *asm_rel_exp(); +STATIC OPND *asm_shift_exp(); +STATIC OPND *asm_una_exp(); +STATIC OPND *asm_xor_exp(); +STATIC void *link_alloc(size_t, void *); +STATIC void asm_chktok(enum TOK toknum, unsigned errnum); +STATIC code *asm_db_parse(OP *pop); +STATIC code *asm_da_parse(OP *pop); + +unsigned compute_hashkey(char *); + + +/******************************* + */ + +STATIC OPND *opnd_calloc() +{ OPND *o; + + o = new OPND(); + memset(o, 0, sizeof(*o)); + return o; +} + +/******************************* + */ + +STATIC void opnd_free(OPND *o) +{ + if (o) + { + delete o; + } +} + +/******************************* + */ + +STATIC void asm_chktok(enum TOK toknum,unsigned errnum) +{ + if (tok_value == toknum) + asm_token(); // scan past token + else + /* When we run out of tokens, asmtok is NULL. + * But when this happens when a ';' was hit. + */ + asmerr(errnum, asmtok ? asmtok->toChars() : ";"); +} + + +/******************************* + */ + +STATIC PTRNTAB asm_classify(OP *pop, OPND *popnd1, OPND *popnd2, + OPND *popnd3, OPND *popnd4, unsigned *pusNumops) +{ + unsigned usNumops; + unsigned usActual; + PTRNTAB ptbRet = { NULL }; + opflag_t opflags1 = 0 ; + opflag_t opflags2 = 0; + opflag_t opflags3 = 0; + opflag_t opflags4 = 0; + char bFake = FALSE; + char bInvalid64bit = FALSE; + + unsigned char bMatch1, bMatch2, bMatch3, bMatch4, bRetry = FALSE; + + // How many arguments are there? the parser is strictly left to right + // so this should work. + + if (!popnd1) + usNumops = 0; + else + { + popnd1->usFlags = opflags1 = asm_determine_operand_flags(popnd1); + if (!popnd2) + usNumops = 1; + else + { + popnd2->usFlags = opflags2 = asm_determine_operand_flags(popnd2); + if (!popnd3) + usNumops = 2; + else + { + popnd3->usFlags = opflags3 = asm_determine_operand_flags(popnd3); + if (!popnd4) + usNumops = 3; + else + { + popnd4->usFlags = opflags4 = asm_determine_operand_flags(popnd4); + usNumops = 4; + } + } + } + } + + // Now check to insure that the number of operands is correct + usActual = (pop->usNumops & ITSIZE); + if (usActual != usNumops && asmstate.ucItype != ITopt && + asmstate.ucItype != ITfloat) + { +PARAM_ERROR: + asmerr(EM_nops_expected, usNumops, asm_opstr(pop), usActual); + } + if (usActual < usNumops) + *pusNumops = usActual; + else + *pusNumops = usNumops; +// +// The number of arguments matches, now check to find the opcode +// in the associated opcode table +// +RETRY: + //printf("usActual = %d\n", usActual); + switch (usActual) + { + case 0: + if (I64 && (pop->ptb.pptb0->usFlags & _i64_bit)) + asmerr( EM_invalid_64bit_opcode, asm_opstr(pop)); // illegal opcode in 64bit mode + + ptbRet = pop->ptb; + + goto RETURN_IT; + + case 1: + { //printf("opflags1 = "); asm_output_flags(opflags1); printf("\n"); + PTRNTAB1 *table1; + for (table1 = pop->ptb.pptb1; table1->usOpcode != ASM_END; + table1++) + { + //printf("table = "); asm_output_flags(table1->usOp1); printf("\n"); + bMatch1 = asm_match_flags(opflags1, table1->usOp1); + //printf("bMatch1 = x%x\n", bMatch1); + if (bMatch1) + { if (table1->usOpcode == 0x68 && + !I16 && + table1->usOp1 == _imm16 + ) + // Don't match PUSH imm16 in 32 bit code + continue; + + // Check if match is invalid in 64bit mode + if (I64 && (table1->usFlags & _i64_bit)) + { + bInvalid64bit = TRUE; + continue; + } + + break; + } + if ((asmstate.ucItype == ITimmed) && + asm_match_flags(opflags1, + CONSTRUCT_FLAGS(_8 | _16 | _32, _imm, _normal, + 0)) && + popnd1->disp == table1->usFlags) + break; + if ((asmstate.ucItype == ITopt || + asmstate.ucItype == ITfloat) && + !usNumops && + !table1->usOp1) + { + if (usNumops > 1) + goto PARAM_ERROR; + break; + } + } + if (table1->usOpcode == ASM_END) + { +#ifdef DEBUG + if (debuga) + { printf("\t%s\t", asm_opstr(pop)); + if (popnd1) + asm_output_popnd(popnd1); + if (popnd2) { + printf(","); + asm_output_popnd(popnd2); + } + if (popnd3) { + printf(","); + asm_output_popnd(popnd3); + } + printf("\n"); + + printf("OPCODE mism = "); + if (popnd1) + asm_output_flags(popnd1->usFlags); + else + printf("NONE"); + printf("\n"); + } +#endif +TYPE_SIZE_ERROR: + if (popnd1 && ASM_GET_aopty(popnd1->usFlags) != _reg) + { + opflags1 = popnd1->usFlags |= _anysize; + if (asmstate.ucItype == ITjump) + { + if (bRetry && popnd1->s && !popnd1->s->isLabel()) + { + asmerr(EM_label_expected, popnd1->s->toChars()); + } + + popnd1->usFlags |= CONSTRUCT_FLAGS(0, 0, 0, + _fanysize); + } + } + if (popnd2 && ASM_GET_aopty(popnd2->usFlags) != _reg) { + opflags2 = popnd2->usFlags |= (_anysize); + if (asmstate.ucItype == ITjump) + popnd2->usFlags |= CONSTRUCT_FLAGS(0, 0, 0, + _fanysize); + } + if (popnd3 && ASM_GET_aopty(popnd3->usFlags) != _reg) { + opflags3 = popnd3->usFlags |= (_anysize); + if (asmstate.ucItype == ITjump) + popnd3->usFlags |= CONSTRUCT_FLAGS(0, 0, 0, + _fanysize); + } + if (bRetry) + { + if(bInvalid64bit) + asmerr("operand for '%s' invalid in 64bit mode", asm_opstr(pop)); + else + asmerr(EM_bad_op, asm_opstr(pop)); // illegal type/size of operands + } + bRetry = TRUE; + goto RETRY; + + } + ptbRet.pptb1 = table1; + goto RETURN_IT; + } + case 2: + { //printf("opflags1 = "); asm_output_flags(opflags1); printf(" "); + //printf("opflags2 = "); asm_output_flags(opflags2); printf("\n"); + PTRNTAB2 *table2; + for (table2 = pop->ptb.pptb2; + table2->usOpcode != ASM_END; + table2++) + { + //printf("table1 = "); asm_output_flags(table2->usOp1); printf(" "); + //printf("table2 = "); asm_output_flags(table2->usOp2); printf("\n"); + if (I64 && (table2->usFlags & _i64_bit)) + asmerr( EM_invalid_64bit_opcode, asm_opstr(pop)); + + bMatch1 = asm_match_flags(opflags1, table2->usOp1); + bMatch2 = asm_match_flags(opflags2, table2->usOp2); + //printf("match1 = %d, match2 = %d\n",bMatch1,bMatch2); + if (bMatch1 && bMatch2) { + + //printf("match\n"); + + /* If they both match and the first op in the table is not AL + * or size of 8 and the second is immediate 8, + * then check to see if the constant + * is a signed 8 bit constant. If so, then do not match, otherwise match + */ + if (!bRetry && + !((ASM_GET_uSizemask(table2->usOp1) & _8) || + (ASM_GET_uRegmask(table2->usOp1) & _al)) && + (ASM_GET_aopty(table2->usOp2) == _imm) && + (ASM_GET_uSizemask(table2->usOp2) & _8)) + { + + if (popnd2->disp <= SCHAR_MAX) + break; + else + bFake = TRUE; + } + else + break; + } + if (asmstate.ucItype == ITopt || + asmstate.ucItype == ITfloat) + { + switch (usNumops) + { + case 0: + if (!table2->usOp1) + goto Lfound2; + break; + case 1: + if (bMatch1 && !table2->usOp2) + goto Lfound2; + break; + case 2: + break; + default: + goto PARAM_ERROR; + } + } +#if 0 + if (asmstate.ucItype == ITshift && + !table2->usOp2 && + bMatch1 && popnd2->disp == 1 && + asm_match_flags(opflags2, + CONSTRUCT_FLAGS(_8|_16|_32, _imm,_normal,0)) + ) + break; +#endif + } + Lfound2: + if (table2->usOpcode == ASM_END) + { +#ifdef DEBUG + if (debuga) + { printf("\t%s\t", asm_opstr(pop)); + if (popnd1) + asm_output_popnd(popnd1); + if (popnd2) { + printf(","); + asm_output_popnd(popnd2); + } + if (popnd3) { + printf(","); + asm_output_popnd(popnd3); + } + printf("\n"); + + printf("OPCODE mismatch = "); + if (popnd1) + asm_output_flags(popnd1->usFlags); + else + printf("NONE"); + printf( " Op2 = "); + if (popnd2) + asm_output_flags(popnd2->usFlags); + else + printf("NONE"); + printf("\n"); + } +#endif + goto TYPE_SIZE_ERROR; + } + ptbRet.pptb2 = table2; + goto RETURN_IT; + } + case 3: + { + PTRNTAB3 *table3; + for (table3 = pop->ptb.pptb3; + table3->usOpcode != ASM_END; + table3++) + { + bMatch1 = asm_match_flags(opflags1, table3->usOp1); + bMatch2 = asm_match_flags(opflags2, table3->usOp2); + bMatch3 = asm_match_flags(opflags3, table3->usOp3); + if (bMatch1 && bMatch2 && bMatch3) + goto Lfound3; + if (asmstate.ucItype == ITopt) + { + switch (usNumops) + { + case 0: + if (!table3->usOp1) + goto Lfound3; + break; + case 1: + if (bMatch1 && !table3->usOp2) + goto Lfound3; + break; + case 2: + if (bMatch1 && bMatch2 && !table3->usOp3) + goto Lfound3; + break; + case 3: + break; + default: + goto PARAM_ERROR; + } + } + } + Lfound3: + if (table3->usOpcode == ASM_END) + { +#ifdef DEBUG + if (debuga) + { printf("\t%s\t", asm_opstr(pop)); + if (popnd1) + asm_output_popnd(popnd1); + if (popnd2) { + printf(","); + asm_output_popnd(popnd2); + } + if (popnd3) { + printf(","); + asm_output_popnd(popnd3); + } + printf("\n"); + + printf("OPCODE mismatch = "); + if (popnd1) + asm_output_flags(popnd1->usFlags); + else + printf("NONE"); + printf( " Op2 = "); + if (popnd2) + asm_output_flags(popnd2->usFlags); + else + printf("NONE"); + if (popnd3) + asm_output_flags(popnd3->usFlags); + printf("\n"); + } +#endif + goto TYPE_SIZE_ERROR; + } + ptbRet.pptb3 = table3; + goto RETURN_IT; + } + case 4: + { + PTRNTAB4 *table4; + for (table4 = pop->ptb.pptb4; + table4->usOpcode != ASM_END; + table4++) + { + bMatch1 = asm_match_flags(opflags1, table4->usOp1); + bMatch2 = asm_match_flags(opflags2, table4->usOp2); + bMatch3 = asm_match_flags(opflags3, table4->usOp3); + bMatch4 = asm_match_flags(opflags4, table4->usOp4); + if (bMatch1 && bMatch2 && bMatch3 && bMatch4) + goto Lfound4; + if (asmstate.ucItype == ITopt) + { + switch (usNumops) + { + case 0: + if (!table4->usOp1) + goto Lfound3; + break; + case 1: + if (bMatch1 && !table4->usOp2) + goto Lfound3; + break; + case 2: + if (bMatch1 && bMatch2 && !table4->usOp3) + goto Lfound3; + break; + case 3: + if (bMatch1 && bMatch2 && bMatch3 && !table4->usOp4) + goto Lfound3; + break; + case 4: + break; + default: + goto PARAM_ERROR; + } + } + } + Lfound4: + if (table4->usOpcode == ASM_END) + { +#ifdef DEBUG + if (debuga) + { printf("\t%s\t", asm_opstr(pop)); + if (popnd1) + asm_output_popnd(popnd1); + if (popnd2) { + printf(","); + asm_output_popnd(popnd2); + } + if (popnd3) { + printf(","); + asm_output_popnd(popnd3); + } + if (popnd4) { + printf(","); + asm_output_popnd(popnd4); + } + printf("\n"); + + printf("OPCODE mismatch = "); + if (popnd1) + asm_output_flags(popnd1->usFlags); + else + printf("NONE"); + printf( " Op2 = "); + if (popnd2) + asm_output_flags(popnd2->usFlags); + else + printf("NONE"); + printf( " Op3 = "); + if (popnd3) + asm_output_flags(popnd3->usFlags); + else + printf("NONE"); + printf( " Op4 = "); + if (popnd4) + asm_output_flags(popnd4->usFlags); + else + printf("NONE"); + printf("\n"); + } +#endif + goto TYPE_SIZE_ERROR; + } + ptbRet.pptb4 = table4; + goto RETURN_IT; + } + } +RETURN_IT: + if (bRetry && !bFake) + { + asmerr(EM_bad_op, asm_opstr(pop)); + } + return ptbRet; +} + +/******************************* + */ + +STATIC opflag_t asm_determine_float_flags(OPND *popnd) +{ + //printf("asm_determine_float_flags()\n"); + + opflag_t us, usFloat; + + // Insure that if it is a register, that it is not a normal processor + // register. + + if (popnd->base && + !popnd->s && !popnd->disp && !popnd->real + && !(popnd->base->ty & (_r8 | _r16 | _r32))) + { + return popnd->base->ty; + } + if (popnd->pregDisp1 && !popnd->base) + { + us = asm_float_type_size(popnd->ptype, &usFloat); + //printf("us = x%x, usFloat = x%x\n", us, usFloat); + if (popnd->pregDisp1->ty & (_r32 | _r64)) + return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); + else + if (popnd->pregDisp1->ty & _r16) + return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); + } + else if (popnd->s != 0) + { + us = asm_float_type_size(popnd->ptype, &usFloat); + return CONSTRUCT_FLAGS(us, _m, _normal, usFloat); + } + + if (popnd->segreg) + { + us = asm_float_type_size(popnd->ptype, &usFloat); + if (I16) + return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); + else + return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); + } + +#if 0 + if (popnd->real) + { + switch (popnd->ptype->ty) + { + case Tfloat32: + popnd->s = fconst(popnd->real); + return(CONSTRUCT_FLAGS(_32, _m, _normal, 0)); + + case Tfloat64: + popnd->s = dconst(popnd->real); + return(CONSTRUCT_FLAGS(0, _m, _normal, _f64)); + + case Tfloat80: + popnd->s = ldconst(popnd->real); + return(CONSTRUCT_FLAGS(0, _m, _normal, _f80)); + } + } +#endif + + asmerr(EM_bad_float_op); // unknown operand for floating point instruction + return 0; +} + +/******************************* + */ + +STATIC opflag_t asm_determine_operand_flags(OPND *popnd) +{ + Dsymbol *ps; + int ty; + opflag_t us; + opflag_t sz; + ASM_OPERAND_TYPE opty; + ASM_MODIFIERS amod; + + // If specified 'offset' or 'segment' but no symbol + if ((popnd->bOffset || popnd->bSeg) && !popnd->s) + asmerr(EM_bad_addr_mode); // illegal addressing mode + + if (asmstate.ucItype == ITfloat) + return asm_determine_float_flags(popnd); + + // If just a register + if (popnd->base && !popnd->s && !popnd->disp && !popnd->real) + return popnd->base->ty; +#if DEBUG + if (debuga) + printf("popnd->base = %s\n, popnd->pregDisp1 = %p\n", popnd->base ? popnd->base->regstr : "NONE", popnd->pregDisp1); +#endif + ps = popnd->s; + Declaration *ds = ps ? ps->isDeclaration() : NULL; + if (ds && ds->storage_class & STClazy) + sz = _anysize; + else + sz = asm_type_size((ds && ds->storage_class & (STCout | STCref)) ? popnd->ptype->pointerTo() : popnd->ptype); + if (popnd->pregDisp1 && !popnd->base) + { + if (ps && ps->isLabel() && sz == _anysize) + sz = I16 ? _16 : _32; + return (popnd->pregDisp1->ty & (_r32 | _r64)) + ? CONSTRUCT_FLAGS(sz, _m, _addr32, 0) + : CONSTRUCT_FLAGS(sz, _m, _addr16, 0); + } + else if (ps) + { + if (popnd->bOffset || popnd->bSeg || ps == asmstate.psLocalsize) + return I16 + ? CONSTRUCT_FLAGS(_16, _imm, _normal, 0) + : CONSTRUCT_FLAGS(_32, _imm, _normal, 0); + + if (ps->isLabel()) + { + switch (popnd->ajt) + { + case ASM_JUMPTYPE_UNSPECIFIED: + if (ps == asmstate.psDollar) + { + if (popnd->disp >= CHAR_MIN && + popnd->disp <= CHAR_MAX) + us = CONSTRUCT_FLAGS(_8, _rel, _flbl,0); + else + if (popnd->disp >= SHRT_MIN && + popnd->disp <= SHRT_MAX && !I64) + us = CONSTRUCT_FLAGS(_16, _rel, _flbl,0); + else + us = CONSTRUCT_FLAGS(_32, _rel, _flbl,0); + } + else if (asmstate.ucItype != ITjump) + { if (sz == _8) + { us = CONSTRUCT_FLAGS(_8,_rel,_flbl,0); + break; + } + goto case_near; + } + else + us = I16 + ? CONSTRUCT_FLAGS(_8|_16, _rel, _flbl,0) + : CONSTRUCT_FLAGS(_8|_32, _rel, _flbl,0); + break; + + case ASM_JUMPTYPE_NEAR: + case_near: + us = I16 + ? CONSTRUCT_FLAGS(_16, _rel, _flbl, 0) + : CONSTRUCT_FLAGS(_32, _rel, _flbl, 0); + break; + case ASM_JUMPTYPE_SHORT: + us = CONSTRUCT_FLAGS(_8, _rel, _flbl, 0); + break; + case ASM_JUMPTYPE_FAR: + us = I16 + ? CONSTRUCT_FLAGS(_32, _rel, _flbl, 0) + : CONSTRUCT_FLAGS(_48, _rel, _flbl, 0); + break; + default: + assert(0); + } + return us; + } + if (!popnd->ptype) + return CONSTRUCT_FLAGS(sz, _m, _normal, 0); + ty = popnd->ptype->ty; + if (ty == Tpointer && popnd->ptype->nextOf()->ty == Tfunction && + !ps->isVarDeclaration()) + { +#if 1 + return CONSTRUCT_FLAGS(_32, _m, _fn16, 0); +#else + ty = popnd->ptype->Tnext->Tty; + if (tyfarfunc(tybasic(ty))) { + return I32 + ? CONSTRUCT_FLAGS(_48, _mnoi, _fn32, 0) + : CONSTRUCT_FLAGS(_32, _mnoi, _fn32, 0); + } + else { + return I32 + ? CONSTRUCT_FLAGS(_32, _m, _fn16, 0) + : CONSTRUCT_FLAGS(_16, _m, _fn16, 0); + } +#endif + } + else if (ty == Tfunction) + { +#if 1 + return CONSTRUCT_FLAGS(_32, _rel, _fn16, 0); +#else + if (tyfarfunc(tybasic(ty))) + return I32 + ? CONSTRUCT_FLAGS(_48, _p, _fn32, 0) + : CONSTRUCT_FLAGS(_32, _p, _fn32, 0); + else + return I32 + ? CONSTRUCT_FLAGS(_32, _rel, _fn16, 0) + : CONSTRUCT_FLAGS(_16, _rel, _fn16, 0); +#endif + } + else if (asmstate.ucItype == ITjump) + { amod = _normal; + goto L1; + } + else + return CONSTRUCT_FLAGS(sz, _m, _normal, 0); + } + if (popnd->segreg /*|| popnd->bPtr*/) + { + amod = I16 ? _addr16 : _addr32; + if (asmstate.ucItype == ITjump) + { + L1: + opty = _m; + if (I16) + { if (sz == _32) + opty = _mnoi; + } + else + { if (sz == _48) + opty = _mnoi; + } + us = CONSTRUCT_FLAGS(sz,opty,amod,0); + } + else + us = CONSTRUCT_FLAGS(sz, +// _rel, amod, 0); + _m, amod, 0); + } + + else if (popnd->ptype) + us = CONSTRUCT_FLAGS(sz, _imm, _normal, 0); + + else if (popnd->disp >= CHAR_MIN && popnd->disp <= UCHAR_MAX) + us = CONSTRUCT_FLAGS( _8 | _16 | _32 | _64, _imm, _normal, 0); + else if (popnd->disp >= SHRT_MIN && popnd->disp <= USHRT_MAX) + us = CONSTRUCT_FLAGS( _16 | _32 | _64, _imm, _normal, 0); + else if (popnd->disp >= INT_MIN && popnd->disp <= UINT_MAX) + us = CONSTRUCT_FLAGS( _32 | _64, _imm, _normal, 0); + else + us = CONSTRUCT_FLAGS( _64, _imm, _normal, 0); + return us; +} + +/****************************** + * Convert assembly instruction into a code, and append + * it to the code generated for this block. + */ + +STATIC code *asm_emit(Loc loc, + unsigned usNumops, PTRNTAB ptb, + OP *pop, + OPND *popnd1, OPND *popnd2, OPND *popnd3, OPND *popnd4) +{ +#ifdef DEBUG + unsigned char auchOpcode[16]; + unsigned usIdx = 0; + #define emit(op) (auchOpcode[usIdx++] = op) +#else + #define emit(op) ((void)(op)) +#endif + Identifier *id; +// unsigned us; + unsigned char *puc; + unsigned usDefaultseg; + code *pc = NULL; + OPND *popndTmp; + ASM_OPERAND_TYPE aoptyTmp; + unsigned uSizemaskTmp; + REG *pregSegment; + code *pcPrefix = NULL; + //ASM_OPERAND_TYPE aopty1 = _reg , aopty2 = 0, aopty3 = 0; + ASM_MODIFIERS amod1 = _normal, amod2 = _normal; + unsigned uSizemaskTable1 =0, uSizemaskTable2 =0, + uSizemaskTable3 =0; + ASM_OPERAND_TYPE aoptyTable1 = _reg, aoptyTable2 = _reg, aoptyTable3 = _reg; + ASM_MODIFIERS amodTable1 = _normal, + amodTable2 = _normal; + unsigned uRegmaskTable1 = 0, uRegmaskTable2 =0; + + pc = code_calloc(); + pc->Iflags |= CFpsw; // assume we want to keep the flags + if (popnd1) + { + //aopty1 = ASM_GET_aopty(popnd1->usFlags); + amod1 = ASM_GET_amod(popnd1->usFlags); + + uSizemaskTable1 = ASM_GET_uSizemask(ptb.pptb1->usOp1); + aoptyTable1 = ASM_GET_aopty(ptb.pptb1->usOp1); + amodTable1 = ASM_GET_amod(ptb.pptb1->usOp1); + uRegmaskTable1 = ASM_GET_uRegmask(ptb.pptb1->usOp1); + + } + if (popnd2) + { +#if 0 + printf("\nasm_emit:\nop: "); + asm_output_flags(popnd2->usFlags); + printf("\ntb: "); + asm_output_flags(ptb.pptb2->usOp2); + printf("\n"); +#endif + //aopty2 = ASM_GET_aopty(popnd2->usFlags); + amod2 = ASM_GET_amod(popnd2->usFlags); + + uSizemaskTable2 = ASM_GET_uSizemask(ptb.pptb2->usOp2); + aoptyTable2 = ASM_GET_aopty(ptb.pptb2->usOp2); + amodTable2 = ASM_GET_amod(ptb.pptb2->usOp2); + uRegmaskTable2 = ASM_GET_uRegmask(ptb.pptb2->usOp2); + } + if (popnd3) + { + //aopty3 = ASM_GET_aopty(popnd3->usFlags); + + uSizemaskTable3 = ASM_GET_uSizemask(ptb.pptb3->usOp3); + aoptyTable3 = ASM_GET_aopty(ptb.pptb3->usOp3); + } + + asmstate.statement->regs |= asm_modify_regs(ptb, popnd1, popnd2); + + if (I16 && ptb.pptb0->usFlags & _I386) + { + switch (usNumops) + { + case 0: + break; + case 1: + if (popnd1 && popnd1->s) + { +L386_WARNING: + id = popnd1->s->ident; +L386_WARNING2: + if (config.target_cpu < TARGET_80386) + { // Reference to %s caused a 386 instruction to be generated + //warerr(WM_386_op, id->toChars()); + } + } + break; + case 2: + case 3: // The third operand is always an _imm + if (popnd1 && popnd1->s) + goto L386_WARNING; + if (popnd2 && popnd2->s) + { + id = popnd2->s->ident; + goto L386_WARNING2; + } + break; + } + } + + if (ptb.pptb0->usFlags & _64_bit && !I64) + error(asmstate.loc, "use -m64 to compile 64 bit instructions"); + + if (I64 && (ptb.pptb0->usFlags & _64_bit)) + { + emit(REX | REX_W); + pc->Irex |= REX_W; + } + + switch (usNumops) + { + case 0: + if (((I32 | I64) && (ptb.pptb0->usFlags & _16_bit)) || + (I16 && (ptb.pptb0->usFlags & _32_bit))) + { + emit(0x66); + pc->Iflags |= CFopsize; + } + break; + + // vex adds 4 operand instructions, but already provides + // encoded operation size + case 4: + break; + + // 3 and 2 are the same because the third operand is always + // an immediate and does not affect operation size + case 3: + case 2: + if ((I32 && + (amod2 == _addr16 || + (uSizemaskTable2 & _16 && aoptyTable2 == _rel) || + (uSizemaskTable2 & _32 && aoptyTable2 == _mnoi) || + (ptb.pptb2->usFlags & _16_bit_addr) + ) + ) || + (I16 && + (amod2 == _addr32 || + (uSizemaskTable2 & _32 && aoptyTable2 == _rel) || + (uSizemaskTable2 & _48 && aoptyTable2 == _mnoi) || + (ptb.pptb2->usFlags & _32_bit_addr))) + ) + { + emit(0x67); + pc->Iflags |= CFaddrsize; + if (I32) + amod2 = _addr16; + else + amod2 = _addr32; + popnd2->usFlags &= ~CONSTRUCT_FLAGS(0,0,7,0); + popnd2->usFlags |= CONSTRUCT_FLAGS(0,0,amod2,0); + } + + + /* Fall through, operand 1 controls the opsize, but the + address size can be in either operand 1 or operand 2, + hence the extra checking the flags tested for SHOULD + be mutex on operand 1 and operand 2 because there is + only one MOD R/M byte + */ + + case 1: + if ((I32 && + (amod1 == _addr16 || + (uSizemaskTable1 & _16 && aoptyTable1 == _rel) || + (uSizemaskTable1 & _32 && aoptyTable1 == _mnoi) || + (ptb.pptb1->usFlags & _16_bit_addr))) || + (I16 && + (amod1 == _addr32 || + (uSizemaskTable1 & _32 && aoptyTable1 == _rel) || + (uSizemaskTable1 & _48 && aoptyTable1 == _mnoi) || + (ptb.pptb1->usFlags & _32_bit_addr)))) + { + emit(0x67); // address size prefix + pc->Iflags |= CFaddrsize; + if (I32) + amod1 = _addr16; + else + amod1 = _addr32; + popnd1->usFlags &= ~CONSTRUCT_FLAGS(0,0,7,0); + popnd1->usFlags |= CONSTRUCT_FLAGS(0,0,amod1,0); + } + + // If the size of the operand is unknown, assume that it is + // the default size + if (((I64 || I32) && (ptb.pptb0->usFlags & _16_bit)) || + (I16 && (ptb.pptb0->usFlags & _32_bit))) + { + //if (asmstate.ucItype != ITjump) + { emit(0x66); + pc->Iflags |= CFopsize; + } + } + if (((pregSegment = (popndTmp = popnd1)->segreg) != NULL) || + ((popndTmp = popnd2) != NULL && + (pregSegment = popndTmp->segreg) != NULL) + ) + { + if ((popndTmp->pregDisp1 && + popndTmp->pregDisp1->val == _BP) || + popndTmp->pregDisp2 && + popndTmp->pregDisp2->val == _BP) + usDefaultseg = _SS; + else + usDefaultseg = _DS; + if (pregSegment->val != usDefaultseg) + switch (pregSegment->val) { + case _CS: + emit(0x2e); + pc->Iflags |= CFcs; + break; + case _SS: + emit(0x36); + pc->Iflags |= CFss; + break; + case _DS: + emit(0x3e); + pc->Iflags |= CFds; + break; + case _ES: + emit(0x26); + pc->Iflags |= CFes; + break; + case _FS: + emit(0x64); + pc->Iflags |= CFfs; + break; + case _GS: + emit(0x65); + pc->Iflags |= CFgs; + break; + default: + assert(0); + } + } + break; + } + unsigned usOpcode = ptb.pptb0->usOpcode; + + pc->Iop = usOpcode; + if (pc->Ivex.pfx == 0xC4) + { +#ifdef DEBUG + unsigned oIdx = usIdx; +#endif + // vvvv + switch (pc->Ivex.vvvv) + { + case VEX_NOO: + pc->Ivex.vvvv = 0xF; // not used + + if ((aoptyTable1 == _m || aoptyTable1 == _rm) && + aoptyTable2 == _reg) + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, popnd2); + else + if (usNumops == 2 || usNumops == 3 && aoptyTable3 == _imm) + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd2, popnd1); + else + assert(!usNumops); // no operands + + if (usNumops == 3) + { + popndTmp = popnd3; + aoptyTmp = ASM_GET_aopty(ptb.pptb3->usOp3); + uSizemaskTmp = ASM_GET_uSizemask(ptb.pptb3->usOp3); + assert(aoptyTmp == _imm); + } + break; + + case VEX_NDD: + pc->Ivex.vvvv = ~popnd1->base->val; + + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd2, NULL); + + if (usNumops == 3) + { + popndTmp = popnd3; + aoptyTmp = ASM_GET_aopty(ptb.pptb3->usOp3); + uSizemaskTmp = ASM_GET_uSizemask(ptb.pptb3->usOp3); + assert(aoptyTmp == _imm); + } + break; + + case VEX_DDS: + assert(usNumops == 3); + pc->Ivex.vvvv = ~popnd2->base->val; + + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd3, popnd1); + break; + + case VEX_NDS: + pc->Ivex.vvvv = ~popnd2->base->val; + + if (aoptyTable1 == _m || aoptyTable1 == _rm) + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, popnd3); + else + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd3, popnd1); + + if (usNumops == 4) + { + popndTmp = popnd4; + aoptyTmp = ASM_GET_aopty(ptb.pptb4->usOp4); + uSizemaskTmp = ASM_GET_uSizemask(ptb.pptb4->usOp4); + assert(aoptyTmp == _imm); + } + break; + + default: + assert(0); + } + + // REX + // REX_W is solely taken from WO/W1/WIG + // pc->Ivex.w = !!(pc->Irex & REX_W); + pc->Ivex.b = !(pc->Irex & REX_B); + pc->Ivex.x = !(pc->Irex & REX_X); + pc->Ivex.r = !(pc->Irex & REX_R); + + /* Check if a 3-byte vex is needed. + */ + if (pc->Ivex.w || !pc->Ivex.x || !pc->Ivex.b || pc->Ivex.mmmm > 0x1) + { +#ifdef DEBUG + memmove(&auchOpcode[oIdx+3], &auchOpcode[oIdx], usIdx-oIdx); + usIdx = oIdx; +#endif + emit(0xC4); + emit(VEX3_B1(pc->Ivex)); + emit(VEX3_B2(pc->Ivex)); + pc->Iflags |= CFvex3; + } + else + { +#ifdef DEBUG + memmove(&auchOpcode[oIdx+2], &auchOpcode[oIdx], usIdx-oIdx); + usIdx = oIdx; +#endif + emit(0xC5); + emit(VEX2_B1(pc->Ivex)); + } + pc->Iflags |= CFvex; + emit(pc->Ivex.op); + if (popndTmp) + goto L1; + goto L2; + } + else if ((usOpcode & 0xFFFD00) == 0x0F3800) // SSSE3, SSE4 + { emit(0xFF); + emit(0xFD); + emit(0x00); + goto L3; + } + + switch (usOpcode & 0xFF0000) + { + case 0: + break; + + case 0x660000: + usOpcode &= 0xFFFF; + goto L3; + + case 0xF20000: // REPNE + case 0xF30000: // REP/REPE + // BUG: What if there's an address size prefix or segment + // override prefix? Must the REP be adjacent to the rest + // of the opcode? + usOpcode &= 0xFFFF; + goto L3; + + case 0x0F0000: // an AMD instruction + puc = ((unsigned char *) &usOpcode); + if (puc[1] != 0x0F) // if not AMD instruction 0x0F0F + goto L4; + emit(puc[2]); + emit(puc[1]); + emit(puc[0]); + pc->Iop >>= 8; + pc->IEVint2 = puc[0]; + pc->IFL2 = FLconst; + goto L3; + + default: + puc = ((unsigned char *) &usOpcode); + L4: + emit(puc[2]); + emit(puc[1]); + emit(puc[0]); + pc->Iop >>= 8; + pc->Irm = puc[0]; + goto L3; + } + if (usOpcode & 0xff00) + { + puc = ((unsigned char *) &(usOpcode)); + emit(puc[1]); + emit(puc[0]); + pc->Iop = puc[1]; + if (pc->Iop == 0x0f) + pc->Iop = 0x0F00 | puc[0]; + else + { + if (usOpcode == 0xDFE0) // FSTSW AX + { pc->Irm = puc[0]; + goto L2; + } + if (asmstate.ucItype == ITfloat) + pc->Irm = puc[0]; + else + { pc->IEVint2 = puc[0]; + pc->IFL2 = FLconst; + } + } + } + else + { + emit(usOpcode); + } + L3: ; + + // If CALL, Jxx or LOOPx to a symbolic location + if (/*asmstate.ucItype == ITjump &&*/ + popnd1 && popnd1->s && popnd1->s->isLabel()) + { Dsymbol *s; + + s = popnd1->s; + if (s == asmstate.psDollar) + { + pc->IFL2 = FLconst; + if (uSizemaskTable1 & (_8 | _16)) + pc->IEVint2 = popnd1->disp; + else if (uSizemaskTable1 & _32) + pc->IEVpointer2 = (targ_size_t) popnd1->disp; + } + else + { LabelDsymbol *label; + + label = s->isLabel(); + if (label) + { if ((pc->Iop & ~0x0F) == 0x70) + pc->Iflags |= CFjmp16; + if (usNumops == 1) + { pc->IFL2 = FLblock; + pc->IEVlsym2 = label; + } + else + { pc->IFL1 = FLblock; + pc->IEVlsym1 = label; + } + } + } + } + + switch (usNumops) + { + case 0: + break; + case 1: + if (((aoptyTable1 == _reg || aoptyTable1 == _float) && + amodTable1 == _normal && (uRegmaskTable1 & _rplus_r))) + { + unsigned reg = popnd1->base->val; + if (reg & 8) + { reg &= 7; + pc->Irex |= REX_B; + assert(I64); + } + if (asmstate.ucItype == ITfloat) + pc->Irm += reg; + else + pc->Iop += reg; +#ifdef DEBUG + auchOpcode[usIdx-1] += reg; +#endif + } + else + { asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, NULL); + } + popndTmp = popnd1; + aoptyTmp = aoptyTable1; + uSizemaskTmp = uSizemaskTable1; +L1: + if (aoptyTmp == _imm) + { + Declaration *d = popndTmp->s ? popndTmp->s->isDeclaration() + : NULL; + if (popndTmp->bSeg) + { + + if (!(d && d->isDataseg())) + asmerr(EM_bad_addr_mode); // illegal addressing mode + } + switch (uSizemaskTmp) + { + case _8: + case _16: + case _32: + case _64: + if (popndTmp->s == asmstate.psLocalsize) + { + pc->IFL2 = FLlocalsize; + pc->IEVdsym2 = NULL; + pc->Iflags |= CFoff; + pc->IEVoffset2 = popndTmp->disp; + } + else if (d) + { +#if 0 + if ((pc->IFL2 = d->Sfl) == 0) +#endif + pc->IFL2 = FLdsymbol; + pc->Iflags &= ~(CFseg | CFoff); + if (popndTmp->bSeg) + pc->Iflags |= CFseg; + else + pc->Iflags |= CFoff; + pc->IEVoffset2 = popndTmp->disp; + pc->IEVdsym2 = d; + } + else + { + pc->IEVllong2 = popndTmp->disp; + pc->IFL2 = FLconst; + } + break; + } + } + + break; + case 2: +// +// If there are two immediate operands then +// + if (aoptyTable1 == _imm && + aoptyTable2 == _imm) + { + pc->IEVint1 = popnd1->disp; + pc->IFL1 = FLconst; + pc->IEVint2 = popnd2->disp; + pc->IFL2 = FLconst; + break; + } + if (aoptyTable2 == _m || + aoptyTable2 == _rel || + // If not MMX register (_mm) or XMM register (_xmm) + (amodTable1 == _rspecial && !(uRegmaskTable1 & (0x08 | 0x10)) && !uSizemaskTable1) || + aoptyTable2 == _rm || + (popnd1->usFlags == _r32 && popnd2->usFlags == _xmm) || + (popnd1->usFlags == _r32 && popnd2->usFlags == _mm)) + { +#if 0 +printf("test4 %d,%d,%d,%d\n", +(aoptyTable2 == _m), +(aoptyTable2 == _rel), +(amodTable1 == _rspecial && !(uRegmaskTable1 & (0x08 | 0x10))), +(aoptyTable2 == _rm) +); +printf("usOpcode = %x\n", usOpcode); +#endif + if (ptb.pptb0->usOpcode == 0x0F7E || // MOVD _rm32,_mm + ptb.pptb0->usOpcode == 0x660F7E // MOVD _rm32,_xmm + ) + { + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, popnd2); + } + else + { + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd2, popnd1); + } + popndTmp = popnd1; + aoptyTmp = aoptyTable1; + uSizemaskTmp = uSizemaskTable1; + } + else + { + if (((aoptyTable1 == _reg || aoptyTable1 == _float) && + amodTable1 == _normal && + (uRegmaskTable1 & _rplus_r))) + { + unsigned reg = popnd1->base->val; + if (reg & 8) + { reg &= 7; + pc->Irex |= REX_B; + assert(I64); + } + if (asmstate.ucItype == ITfloat) + pc->Irm += reg; + else + pc->Iop += reg; +#ifdef DEBUG + auchOpcode[usIdx-1] += reg; +#endif + } + else + if (((aoptyTable2 == _reg || aoptyTable2 == _float) && + amodTable2 == _normal && + (uRegmaskTable2 & _rplus_r))) + { + unsigned reg = popnd2->base->val; + if (reg & 8) + { reg &= 7; + pc->Irex |= REX_B; + assert(I64); + } + if (asmstate.ucItype == ITfloat) + pc->Irm += reg; + else + pc->Iop += reg; +#ifdef DEBUG + auchOpcode[usIdx-1] += reg; +#endif + } + else if (ptb.pptb0->usOpcode == 0xF30FD6 || + ptb.pptb0->usOpcode == 0x0F12 || + ptb.pptb0->usOpcode == 0x0F16 || + ptb.pptb0->usOpcode == 0x660F50 || + ptb.pptb0->usOpcode == 0x0F50 || + ptb.pptb0->usOpcode == 0x660FD7 || + ptb.pptb0->usOpcode == MOVDQ2Q || + ptb.pptb0->usOpcode == 0x0FD7) + { + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd2, popnd1); + } + else + { + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, popnd2); + + } + if (aoptyTable1 == _imm) + { + popndTmp = popnd1; + aoptyTmp = aoptyTable1; + uSizemaskTmp = uSizemaskTable1; + } + else + { + popndTmp = popnd2; + aoptyTmp = aoptyTable2; + uSizemaskTmp = uSizemaskTable2; + } + } + goto L1; + + case 3: + if (aoptyTable2 == _m || aoptyTable2 == _rm || + usOpcode == 0x0FC5 || // pextrw _r32, _mm, _imm8 + usOpcode == 0x660FC5 || // pextrw _r32, _xmm, _imm8 + usOpcode == 0x660F3A20 || // pinsrb _xmm, _r32/m8, _imm8 + usOpcode == 0x660F3A22 // pinsrd _xmm, _rm32, _imm8 + ) + { + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd2, popnd1); + popndTmp = popnd3; + aoptyTmp = aoptyTable3; + uSizemaskTmp = uSizemaskTable3; + } + else { + + if (((aoptyTable1 == _reg || aoptyTable1 == _float) && + amodTable1 == _normal && + (uRegmaskTable1 &_rplus_r))) + { + unsigned reg = popnd1->base->val; + if (reg & 8) + { reg &= 7; + pc->Irex |= REX_B; + assert(I64); + } + if (asmstate.ucItype == ITfloat) + pc->Irm += reg; + else + pc->Iop += reg; +#ifdef DEBUG + auchOpcode[usIdx-1] += reg; +#endif + } + else + if (((aoptyTable2 == _reg || aoptyTable2 == _float) && + amodTable2 == _normal && + (uRegmaskTable2 &_rplus_r))) + { + unsigned reg = popnd1->base->val; + if (reg & 8) + { reg &= 7; + pc->Irex |= REX_B; + assert(I64); + } + if (asmstate.ucItype == ITfloat) + pc->Irm += reg; + else + pc->Iop += reg; +#ifdef DEBUG + auchOpcode[usIdx-1] += reg; +#endif + } + else + asm_make_modrm_byte( +#ifdef DEBUG + auchOpcode, &usIdx, +#endif + pc, + ptb.pptb1->usFlags, + popnd1, popnd2); + + popndTmp = popnd3; + aoptyTmp = aoptyTable3; + uSizemaskTmp = uSizemaskTable3; + + } + goto L1; + } +L2: + + if ((pc->Iop & ~7) == 0xD8 && + ADDFWAIT() && + !(ptb.pptb0->usFlags & _nfwait)) + pc->Iflags |= CFwait; + else if ((ptb.pptb0->usFlags & _fwait) && + config.target_cpu >= TARGET_80386) + pc->Iflags |= CFwait; + +#ifdef DEBUG + if (debuga) + { unsigned u; + + for (u = 0; u < usIdx; u++) + printf(" %02X", auchOpcode[u]); + + printf("\t%s\t", asm_opstr(pop)); + if (popnd1) + asm_output_popnd(popnd1); + if (popnd2) { + printf(","); + asm_output_popnd(popnd2); + } + if (popnd3) { + printf(","); + asm_output_popnd(popnd3); + } + printf("\n"); + } +#endif + pc = cat(pcPrefix, pc); + pc = asm_genloc(loc, pc); + return pc; +} + +/******************************* + * Prepend line number to c. + */ + +code *asm_genloc(Loc loc, code *c) +{ + if (global.params.symdebug) + { code *pcLin; + Srcpos srcpos; + + memset(&srcpos, 0, sizeof(srcpos)); + srcpos.Slinnum = loc.linnum; + srcpos.Sfilename = (char *)loc.filename; + pcLin = genlinnum(NULL, srcpos); + c = cat(pcLin, c); + } + return c; +} + + +/******************************* + */ + +STATIC void asmerr(int errnum, ...) +{ const char *format; + + const char *p = asmstate.loc.toChars(); + if (*p) + printf("%s: ", p); + + format = asmerrmsgs[errnum]; + va_list ap; + va_start(ap, errnum); + vprintf(format, ap); + va_end(ap); + + printf("\n"); + fflush(stdout); + longjmp(asmstate.env,1); +} + +/******************************* + */ + +STATIC void asmerr(const char *format, ...) +{ + const char *p = asmstate.loc.toChars(); + if (*p) + printf("%s: ", p); + + va_list ap; + va_start(ap, format); + vprintf(format, ap); + va_end(ap); + + printf("\n"); + fflush(stdout); + + longjmp(asmstate.env,1); +} + +/******************************* + */ + +STATIC opflag_t asm_float_type_size(Type *ptype, opflag_t *pusFloat) +{ + *pusFloat = 0; + + //printf("asm_float_type_size('%s')\n", ptype->toChars()); + if (ptype && ptype->isscalar()) + { + int sz = (int)ptype->size(); + if (sz == REALSIZE) + { *pusFloat = _f80; + return 0; + } + switch (sz) + { + case 2: + return _16; + case 4: + return _32; + case 8: + *pusFloat = _f64; + return 0; + case 10: + *pusFloat = _f80; + return 0; + default: + break; + } + } + *pusFloat = _fanysize; + return _anysize; +} + +/******************************* + */ + +STATIC int asm_isint(OPND *o) +{ + if (!o || o->base || o->s) + return 0; + //return o->disp != 0; + return 1; +} + +STATIC int asm_isNonZeroInt(OPND *o) +{ + if (!o || o->base || o->s) + return 0; + return o->disp != 0; +} + +/******************************* + */ + +STATIC int asm_is_fpreg(char *szReg) +{ +#if 1 + return(szReg[2] == '\0' && szReg[0] == 'S' && + szReg[1] == 'T'); +#else + return(szReg[2] == '\0' && (szReg[0] == 's' || szReg[0] == 'S') && + (szReg[1] == 't' || szReg[1] == 'T')); +#endif +} + +/******************************* + * Merge operands o1 and o2 into a single operand. + */ + +STATIC OPND *asm_merge_opnds(OPND *o1, OPND *o2) +{ +#ifdef DEBUG + const char *psz; +#endif +#ifdef DEBUG + if (debuga) + { printf("asm_merge_opnds(o1 = "); + if (o1) asm_output_popnd(o1); + printf(", o2 = "); + if (o2) asm_output_popnd(o2); + printf(")\n"); + } +#endif + if (!o1) + return o2; + if (!o2) + return o1; +#ifdef EXTRA_DEBUG + printf("Combining Operands: mult1 = %d, mult2 = %d", + o1->uchMultiplier, o2->uchMultiplier); +#endif + /* combine the OPND's disp field */ + if (o2->segreg) { + if (o1->segreg) { +#ifdef DEBUG + psz = "o1->segment && o2->segreg"; +#endif + goto ILLEGAL_ADDRESS_ERROR; + } + else + o1->segreg = o2->segreg; + } + + // combine the OPND's symbol field + if (o1->s && o2->s) + { +#ifdef DEBUG + psz = "o1->s && os->s"; +#endif +ILLEGAL_ADDRESS_ERROR: +#ifdef DEBUG + printf("Invalid addr because /%s/\n", psz); +#endif + + asmerr(EM_bad_addr_mode); // illegal addressing mode + } + else if (o2->s) + o1->s = o2->s; + else if (o1->s && o1->s->isTupleDeclaration()) + { TupleDeclaration *tup = o1->s->isTupleDeclaration(); + + size_t index = o2->disp; + if (index >= tup->objects->dim) + error(asmstate.loc, "tuple index %u exceeds length %u", index, tup->objects->dim); + else + { + Object *o = tup->objects->tdata()[index]; + if (o->dyncast() == DYNCAST_DSYMBOL) + { o1->s = (Dsymbol *)o; + return o1; + } + else if (o->dyncast() == DYNCAST_EXPRESSION) + { Expression *e = (Expression *)o; + if (e->op == TOKvar) + { o1->s = ((VarExp *)e)->var; + return o1; + } + else if (e->op == TOKfunction) + { o1->s = ((FuncExp *)e)->fd; + return o1; + } + } + error(asmstate.loc, "invalid asm operand %s", o1->s->toChars()); + } + } + + if (o1->disp && o2->disp) + o1->disp += o2->disp; + else if (o2->disp) + o1->disp = o2->disp; + + /* combine the OPND's base field */ + if (o1->base != NULL && o2->base != NULL) { +#ifdef DEBUG + psz = "o1->base != NULL && o2->base != NULL"; +#endif + goto ILLEGAL_ADDRESS_ERROR; + } + else if (o2->base) + o1->base = o2->base; + + /* Combine the displacement register fields */ + if (o2->pregDisp1) + { + if (o1->pregDisp2) + { +#ifdef DEBUG + psz = "o2->pregDisp1 && o1->pregDisp2"; +#endif + goto ILLEGAL_ADDRESS_ERROR; + } + else if (o1->pregDisp1) + { + if (o1->uchMultiplier || + (o2->pregDisp1->val == _ESP && + (o2->pregDisp1->ty & _r32) && + !o2->uchMultiplier)) + { + o1->pregDisp2 = o1->pregDisp1; + o1->pregDisp1 = o2->pregDisp1; + } + else + o1->pregDisp2 = o2->pregDisp1; + } + else + o1->pregDisp1 = o2->pregDisp1; + } + if (o2->pregDisp2) { + if (o1->pregDisp2) { +#ifdef DEBUG + psz = "o1->pregDisp2 && o2->pregDisp2"; +#endif + goto ILLEGAL_ADDRESS_ERROR; + } + else + o1->pregDisp2 = o2->pregDisp2; + } + if (o2->uchMultiplier) + { + if (o1->uchMultiplier) + { +#ifdef DEBUG + psz = "o1->uchMultiplier && o2->uchMultiplier"; +#endif + goto ILLEGAL_ADDRESS_ERROR; + } + else + o1->uchMultiplier = o2->uchMultiplier; + } + if (o2->ptype && !o1->ptype) + o1->ptype = o2->ptype; + if (o2->bOffset) + o1->bOffset = o2->bOffset; + if (o2->bSeg) + o1->bSeg = o2->bSeg; + + if (o2->ajt && !o1->ajt) + o1->ajt = o2->ajt; + + opnd_free(o2); +#ifdef EXTRA_DEBUG + printf("Result = %d\n", + o1->uchMultiplier); +#endif +#ifdef DEBUG + if (debuga) + { printf("Merged result = /"); + asm_output_popnd(o1); + printf("/\n"); + } +#endif + return o1; +} + +/*************************************** + */ + +STATIC void asm_merge_symbol(OPND *o1, Dsymbol *s) +{ + VarDeclaration *v; + EnumMember *em; + + //printf("asm_merge_symbol(s = %s %s)\n", s->kind(), s->toChars()); + s = s->toAlias(); + //printf("s = %s %s\n", s->kind(), s->toChars()); + if (s->isLabel()) + { + o1->s = s; + return; + } + + v = s->isVarDeclaration(); + if (v) + { + if (v->isParameter()) + asmstate.statement->refparam = TRUE; + + v->checkNestedReference(asmstate.sc, asmstate.loc); +#if 0 + if (!v->isDataseg() && v->parent != asmstate.sc->parent && v->parent) + { + asmerr(EM_uplevel, v->toChars()); + } +#endif + if (v->storage_class & STCfield) + { + o1->disp += v->offset; + goto L2; + } + if ((v->isConst() +#if DMDV2 + || v->isImmutable() || v->storage_class & STCmanifest +#endif + ) && !v->type->isfloating() && v->init) + { ExpInitializer *ei = v->init->isExpInitializer(); + + if (ei) + { + o1->disp = ei->exp->toInteger(); + return; + } + } + } + em = s->isEnumMember(); + if (em) + { + o1->disp = em->value->toInteger(); + return; + } + o1->s = s; // a C identifier +L2: + Declaration *d = s->isDeclaration(); + if (!d) + { + asmerr("%s %s is not a declaration", s->kind(), s->toChars()); + } + else if (d->getType()) + asmerr(EM_type_as_operand, d->getType()->toChars()); + else if (d->isTupleDeclaration()) + ; + else + o1->ptype = d->type->toBasetype(); +} + +/**************************** + * Fill in the modregrm and sib bytes of code. + */ + +STATIC void asm_make_modrm_byte( +#ifdef DEBUG + unsigned char *puchOpcode, unsigned *pusIdx, +#endif + code *pc, + unsigned usFlags, + OPND *popnd, OPND *popnd2) +{ + #undef modregrm + + typedef union { + unsigned char uchOpcode; + struct { + unsigned rm : 3; + unsigned reg : 3; + unsigned mod : 2; + } modregrm; + } MODRM_BYTE; // mrmb + + typedef union { + unsigned char uchOpcode; + struct { + unsigned base : 3; + unsigned index : 3; + unsigned ss : 2; + } sib; + } SIB_BYTE; + + + MODRM_BYTE mrmb = { 0 }; + SIB_BYTE sib = { 0 }; + char bSib = FALSE; + char bDisp = FALSE; +#ifdef DEBUG + unsigned char *puc; +#endif + char bModset = FALSE; + Dsymbol *s; + + unsigned uSizemask =0; + ASM_OPERAND_TYPE aopty; + ASM_MODIFIERS amod; + unsigned char bOffsetsym = FALSE; + +#if 0 + printf("asm_make_modrm_byte(usFlags = x%x)\n", usFlags); + printf("op1: "); + asm_output_flags(popnd->usFlags); + if (popnd2) + { printf(" op2: "); + asm_output_flags(popnd2->usFlags); + } + printf("\n"); +#endif + + uSizemask = ASM_GET_uSizemask(popnd->usFlags); + aopty = ASM_GET_aopty(popnd->usFlags); + amod = ASM_GET_amod(popnd->usFlags); + s = popnd->s; + if (s) + { + Declaration *d = s->isDeclaration(); + + if (amod == _fn16 && aopty == _rel && popnd2) + { aopty = _m; + goto L1; + } + + if (amod == _fn16 || amod == _fn32) + { + pc->Iflags |= CFoff; +#ifdef DEBUG + puchOpcode[(*pusIdx)++] = 0; + puchOpcode[(*pusIdx)++] = 0; +#endif + if (aopty == _m || aopty == _mnoi) + { + pc->IFL1 = FLdata; + pc->IEVdsym1 = d; + pc->IEVoffset1 = 0; + } + else + { + if (aopty == _p) + pc->Iflags |= CFseg; +#ifdef DEBUG + if (aopty == _p || aopty == _rel) + { puchOpcode[(*pusIdx)++] = 0; + puchOpcode[(*pusIdx)++] = 0; + } +#endif + pc->IFL2 = FLfunc; + pc->IEVdsym2 = d; + pc->IEVoffset2 = 0; + //return; + } + } + else + { + L1: + LabelDsymbol *label = s->isLabel(); + if (label) + { + if (s == asmstate.psDollar) + { + pc->IFL1 = FLconst; + if (uSizemask & (_8 | _16)) + pc->IEVint1 = popnd->disp; + else if (uSizemask & _32) + pc->IEVpointer1 = (targ_size_t) popnd->disp; + } + else + { pc->IFL1 = FLblockoff; + pc->IEVlsym1 = label; + } + } + else if (s == asmstate.psLocalsize) + { + pc->IFL1 = FLlocalsize; + pc->IEVdsym1 = NULL; + pc->Iflags |= CFoff; + pc->IEVoffset1 = popnd->disp; + } + else if (s->isFuncDeclaration()) + { + pc->IFL1 = FLfunc; + pc->IEVdsym1 = d; + pc->IEVoffset1 = popnd->disp; + } + else + { +#ifdef DEBUG + if (debuga) + printf("Setting up symbol %s\n", d->ident->toChars()); +#endif + pc->IFL1 = FLdsymbol; + pc->IEVdsym1 = d; + pc->Iflags |= CFoff; + pc->IEVoffset1 = popnd->disp; + } + } + } + mrmb.modregrm.reg = usFlags & NUM_MASK; + + if (s && (aopty == _m || aopty == _mnoi) && !s->isLabel()) + { + if (s == asmstate.psLocalsize) + { + DATA_REF: + mrmb.modregrm.rm = BPRM; + if (amod == _addr16 || amod == _addr32) + mrmb.modregrm.mod = 0x2; + else + mrmb.modregrm.mod = 0x0; + } + else + { + Declaration *d = s->isDeclaration(); + assert(d); + if (d->isDataseg() || d->isCodeseg()) + { + if ((I32 && amod == _addr16) || + (I16 && amod == _addr32)) + asmerr(EM_bad_addr_mode); // illegal addressing mode + goto DATA_REF; + } + mrmb.modregrm.rm = BPRM; + mrmb.modregrm.mod = 0x2; + } + } + + if (aopty == _reg || amod == _rspecial) { + mrmb.modregrm.mod = 0x3; + mrmb.modregrm.rm |= popnd->base->val; + if (popnd->base->val & NUM_MASKR) + pc->Irex |= REX_B; + } + else if (amod == _addr16 || (amod == _flbl && I16)) + { unsigned rm; + +#ifdef DEBUG + if (debuga) + printf("This is an ADDR16\n"); +#endif + if (!popnd->pregDisp1) + { rm = 0x6; + if (!s) + bDisp = TRUE; + } + else + { unsigned r1r2; + #define X(r1,r2) (((r1) * 16) + (r2)) + #define Y(r1) X(r1,9) + + + if (popnd->pregDisp2) + r1r2 = X(popnd->pregDisp1->val,popnd->pregDisp2->val); + else + r1r2 = Y(popnd->pregDisp1->val); + switch (r1r2) + { + case X(_BX,_SI): rm = 0; break; + case X(_BX,_DI): rm = 1; break; + case Y(_BX): rm = 7; break; + + case X(_BP,_SI): rm = 2; break; + case X(_BP,_DI): rm = 3; break; + case Y(_BP): rm = 6; bDisp = TRUE; break; + + case X(_SI,_BX): rm = 0; break; + case X(_SI,_BP): rm = 2; break; + case Y(_SI): rm = 4; break; + + case X(_DI,_BX): rm = 1; break; + case X(_DI,_BP): rm = 3; break; + case Y(_DI): rm = 5; break; + + default: + asmerr("bad 16 bit index address mode"); + } + #undef X + #undef Y + } + mrmb.modregrm.rm = rm; + +#ifdef DEBUG + if (debuga) + printf("This is an mod = %d, popnd->s =%p, popnd->disp = %lld\n", + mrmb.modregrm.mod, s, (long long)popnd->disp); +#endif + if (!s || (!mrmb.modregrm.mod && popnd->disp)) + { + if ((!popnd->disp && !bDisp) || + !popnd->pregDisp1) + mrmb.modregrm.mod = 0x0; + else + if (popnd->disp >= CHAR_MIN && + popnd->disp <= SCHAR_MAX) + mrmb.modregrm.mod = 0x1; + else + mrmb.modregrm.mod = 0X2; + } + else + bOffsetsym = TRUE; + + } + else if (amod == _addr32 || (amod == _flbl && I32)) + { +#ifdef DEBUG + if (debuga) + printf("This is an ADDR32\n"); +#endif + if (!popnd->pregDisp1) + mrmb.modregrm.rm = 0x5; + else if (popnd->pregDisp2 || + popnd->uchMultiplier || + popnd->pregDisp1->val == _ESP) + { + if (popnd->pregDisp2) + { if (popnd->pregDisp2->val == _ESP) + asmerr(EM_bad_addr_mode); // illegal addressing mode + } + else + { if (popnd->uchMultiplier && + popnd->pregDisp1->val ==_ESP) + asmerr(EM_bad_addr_mode); // illegal addressing mode + bDisp = TRUE; + } + + mrmb.modregrm.rm = 0x4; + bSib = TRUE; + if (bDisp) + { + if (!popnd->uchMultiplier && + popnd->pregDisp1->val==_ESP) + { + sib.sib.base = popnd->pregDisp1->val; + sib.sib.index = 0x4; + } + else + { +#ifdef DEBUG + if (debuga) + printf("Resetting the mod to 0\n"); +#endif + if (popnd->pregDisp2) + { + if (popnd->pregDisp2->val != _EBP) + asmerr(EM_bad_addr_mode); // illegal addressing mode + } + else + { mrmb.modregrm.mod = 0x0; + bModset = TRUE; + } + + sib.sib.base = 0x5; + sib.sib.index = popnd->pregDisp1->val; + } + } + else + { + sib.sib.base = popnd->pregDisp1->val; + if (popnd->pregDisp1->val & NUM_MASKR) + pc->Irex |= REX_B; + // + // This is to handle the special case + // of using the EBP (or R13) register and no + // displacement. You must put in an + // 8 byte displacement in order to + // get the correct opcodes. + // + if ((popnd->pregDisp1->val == _EBP || + popnd->pregDisp1->val == _R13) && + (!popnd->disp && !s)) + { +#ifdef DEBUG + if (debuga) + printf("Setting the mod to 1 in the _EBP case\n"); +#endif + mrmb.modregrm.mod = 0x1; + bDisp = TRUE; // Need a + // displacement + bModset = TRUE; + } + + sib.sib.index = popnd->pregDisp2->val; + if (popnd->pregDisp2->val & NUM_MASKR) + pc->Irex |= REX_X; + + } + switch (popnd->uchMultiplier) + { + case 0: sib.sib.ss = 0; break; + case 1: sib.sib.ss = 0; break; + case 2: sib.sib.ss = 1; break; + case 4: sib.sib.ss = 2; break; + case 8: sib.sib.ss = 3; break; + + default: + asmerr(EM_bad_addr_mode); // illegal addressing mode + break; + } + } + else + { unsigned rm; + + if (popnd->uchMultiplier) + asmerr(EM_bad_addr_mode); // illegal addressing mode + switch (popnd->pregDisp1->val & NUM_MASK) + { + case _EAX: rm = 0; break; + case _ECX: rm = 1; break; + case _EDX: rm = 2; break; + case _EBX: rm = 3; break; + case _ESI: rm = 6; break; + case _EDI: rm = 7; break; + + case _EBP: + if (!popnd->disp && !s) + { + mrmb.modregrm.mod = 0x1; + bDisp = TRUE; // Need a displacement + bModset = TRUE; + } + rm = 5; + break; + + default: + asmerr(EM_bad_addr_mode); // illegal addressing mode + rm = 0; // no uninitialized data + break; + } + if (popnd->pregDisp1->val & NUM_MASKR) + pc->Irex |= REX_B; + mrmb.modregrm.rm = rm; + } + + if (!bModset && (!s || + (!mrmb.modregrm.mod && popnd->disp))) + { + if ((!popnd->disp && !mrmb.modregrm.mod) || + (!popnd->pregDisp1 && !popnd->pregDisp2)) + { mrmb.modregrm.mod = 0x0; + bDisp = TRUE; + } + else if (popnd->disp >= CHAR_MIN && + popnd->disp <= SCHAR_MAX) + mrmb.modregrm.mod = 0x1; + else + mrmb.modregrm.mod = 0x2; + } + else + bOffsetsym = TRUE; + } + if (popnd2 && !mrmb.modregrm.reg && + asmstate.ucItype != ITshift && + (ASM_GET_aopty(popnd2->usFlags) == _reg || + ASM_GET_amod(popnd2->usFlags) == _rseg || + ASM_GET_amod(popnd2->usFlags) == _rspecial)) + { + mrmb.modregrm.reg = popnd2->base->val; + if (popnd2->base->val & NUM_MASKR) + pc->Irex |= REX_R; + } +#ifdef DEBUG + puchOpcode[ (*pusIdx)++ ] = mrmb.uchOpcode; +#endif + pc->Irm = mrmb.uchOpcode; + //printf("Irm = %02x\n", pc->Irm); + if (bSib) + { +#ifdef DEBUG + puchOpcode[ (*pusIdx)++ ] = sib.uchOpcode; +#endif + pc->Isib= sib.uchOpcode; + } + if ((!s || (popnd->pregDisp1 && !bOffsetsym)) && + aopty != _imm && + (popnd->disp || bDisp)) + { + if (popnd->usFlags & _a16) + { +#ifdef DEBUG + puc = ((unsigned char *) &(popnd->disp)); + puchOpcode[(*pusIdx)++] = puc[1]; + puchOpcode[(*pusIdx)++] = puc[0]; +#endif + if (usFlags & (_modrm | NUM_MASK)) { +#ifdef DEBUG + if (debuga) + printf("Setting up value %lld\n", (long long)popnd->disp); +#endif + pc->IEVint1 = popnd->disp; + pc->IFL1 = FLconst; + } + else { + pc->IEVint2 = popnd->disp; + pc->IFL2 = FLconst; + } + + } + else + { +#ifdef DEBUG + puc = ((unsigned char *) &(popnd->disp)); + puchOpcode[(*pusIdx)++] = puc[3]; + puchOpcode[(*pusIdx)++] = puc[2]; + puchOpcode[(*pusIdx)++] = puc[1]; + puchOpcode[(*pusIdx)++] = puc[0]; +#endif + if (usFlags & (_modrm | NUM_MASK)) { +#ifdef DEBUG + if (debuga) + printf("Setting up value %lld\n", (long long)popnd->disp); +#endif + pc->IEVpointer1 = (targ_size_t) popnd->disp; + pc->IFL1 = FLconst; + } + else { + pc->IEVpointer2 = (targ_size_t) popnd->disp; + pc->IFL2 = FLconst; + } + + } + } +} + +/******************************* + */ + +STATIC regm_t asm_modify_regs(PTRNTAB ptb, OPND *popnd1, OPND *popnd2) +{ + regm_t usRet = 0; + + switch (ptb.pptb0->usFlags & MOD_MASK) { + case _modsi: + usRet |= mSI; + break; + case _moddx: + usRet |= mDX; + break; + case _mod2: + if (popnd2) + usRet |= asm_modify_regs(ptb, popnd2, NULL); + break; + case _modax: + usRet |= mAX; + break; + case _modnot1: + popnd1 = NULL; + break; + case _modaxdx: + usRet |= (mAX | mDX); + break; + case _moddi: + usRet |= mDI; + break; + case _modsidi: + usRet |= (mSI | mDI); + break; + case _modcx: + usRet |= mCX; + break; + case _modes: + /*usRet |= mES;*/ + break; + case _modall: + asmstate.bReturnax = TRUE; + return /*mES |*/ ALLREGS; + case _modsiax: + usRet |= (mSI | mAX); + break; + case _modsinot1: + usRet |= mSI; + popnd1 = NULL; + break; + case _modcxr11: + usRet |= (mCX | mR11); + break; + case _modxmm0: + usRet |= mXMM0; + break; + } + if (popnd1 && ASM_GET_aopty(popnd1->usFlags) == _reg) + { + switch (ASM_GET_amod(popnd1->usFlags)) + { + default: + usRet |= 1 << popnd1->base->val; + usRet &= ~(mBP | mSP); // ignore changing these + break; + + case _rseg: + //if (popnd1->base->val == _ES) + //usRet |= mES; + break; + + case _rspecial: + break; + } + } + if (usRet & mAX) + asmstate.bReturnax = TRUE; + + return usRet; +} + +/******************************* + * Match flags in operand against flags in opcode table. + * Returns: + * !=0 if match + */ + +STATIC unsigned char asm_match_flags(opflag_t usOp, opflag_t usTable) +{ + ASM_OPERAND_TYPE aoptyTable; + ASM_OPERAND_TYPE aoptyOp; + ASM_MODIFIERS amodTable; + ASM_MODIFIERS amodOp; + unsigned uRegmaskTable; + unsigned uRegmaskOp; + unsigned char bRegmatch; + unsigned char bRetval = FALSE; + unsigned uSizemaskOp; + unsigned uSizemaskTable; + unsigned bSizematch; + + //printf("asm_match_flags(usOp = x%x, usTable = x%x)\n", usOp, usTable); + if (asmstate.ucItype == ITfloat) + { + bRetval = asm_match_float_flags(usOp, usTable); + goto EXIT; + } + + uSizemaskOp = ASM_GET_uSizemask(usOp); + uSizemaskTable = ASM_GET_uSizemask(usTable); + + // Check #1, if the sizes do not match, NO match + bSizematch = (uSizemaskOp & uSizemaskTable); + + amodOp = ASM_GET_amod(usOp); + + aoptyTable = ASM_GET_aopty(usTable); + aoptyOp = ASM_GET_aopty(usOp); + + // _mmm64 matches with a 64 bit mem or an MMX register + if (usTable == _mmm64) + { + if (usOp == _mm) + goto Lmatch; + if (aoptyOp == _m && (bSizematch || uSizemaskOp == _anysize)) + goto Lmatch; + goto EXIT; + } + + // _xmm_m32, _xmm_m64, _xmm_m128 match with XMM register or memory + if (usTable == _xmm_m16 || + usTable == _xmm_m32 || + usTable == _xmm_m64 || + usTable == _xmm_m128) + { + if (usOp == _xmm || usOp == (_xmm|_xmm0)) + goto Lmatch; + if (aoptyOp == _m && (bSizematch || uSizemaskOp == _anysize)) + goto Lmatch; + } + + if (usTable == _ymm_m256) + { + if (usOp == _ymm) + goto Lmatch; + if (aoptyOp == _m && (bSizematch || uSizemaskOp == _anysize)) + goto Lmatch; + } + + if (!bSizematch && uSizemaskTable) + { + //printf("no size match\n"); + goto EXIT; + } + + +// +// The operand types must match, otherwise return FALSE. +// There is one exception for the _rm which is a table entry which matches +// _reg or _m +// + if (aoptyTable != aoptyOp) + { + if (aoptyTable == _rm && (aoptyOp == _reg || + aoptyOp == _m || + aoptyOp == _rel)) + goto Lok; + if (aoptyTable == _mnoi && aoptyOp == _m && + (uSizemaskOp == _32 && amodOp == _addr16 || + uSizemaskOp == _48 && amodOp == _addr32 || + uSizemaskOp == _48 && amodOp == _normal) + ) + goto Lok; + goto EXIT; + } +Lok: + +// +// Looks like a match so far, check to see if anything special is going on +// + amodTable = ASM_GET_amod(usTable); + uRegmaskOp = ASM_GET_uRegmask(usOp); + uRegmaskTable = ASM_GET_uRegmask(usTable); + bRegmatch = ((!uRegmaskTable && !uRegmaskOp) || + (uRegmaskTable & uRegmaskOp)); + + switch (amodTable) + { + case _normal: // Normal's match with normals + switch(amodOp) { + case _normal: + case _addr16: + case _addr32: + case _fn16: + case _fn32: + case _flbl: + bRetval = (bSizematch || bRegmatch); + goto EXIT; + default: + goto EXIT; + } + case _rseg: + case _rspecial: + bRetval = (amodOp == amodTable && bRegmatch); + goto EXIT; + default: + assert(0); + } +EXIT: +#if 0 + printf("OP : "); + asm_output_flags(usOp); + printf("\nTBL: "); + asm_output_flags(usTable); + printf(": %s\n", bRetval ? "MATCH" : "NOMATCH"); +#endif + return bRetval; + +Lmatch: + //printf("match\n"); + return 1; +} + +/******************************* + */ + +STATIC unsigned char asm_match_float_flags(opflag_t usOp, opflag_t usTable) +{ + ASM_OPERAND_TYPE aoptyTable; + ASM_OPERAND_TYPE aoptyOp; + ASM_MODIFIERS amodTable; + ASM_MODIFIERS amodOp; + unsigned uRegmaskTable; + unsigned uRegmaskOp; + unsigned bRegmatch; + + +// +// Check #1, if the sizes do not match, NO match +// + uRegmaskOp = ASM_GET_uRegmask(usOp); + uRegmaskTable = ASM_GET_uRegmask(usTable); + bRegmatch = (uRegmaskTable & uRegmaskOp); + + if (!(ASM_GET_uSizemask(usTable) & ASM_GET_uSizemask(usOp) || + bRegmatch)) + return(FALSE); + + aoptyTable = ASM_GET_aopty(usTable); + aoptyOp = ASM_GET_aopty(usOp); +// +// The operand types must match, otherwise return FALSE. +// There is one exception for the _rm which is a table entry which matches +// _reg or _m +// + if (aoptyTable != aoptyOp) + { + if (aoptyOp != _float) + return(FALSE); + } + +// +// Looks like a match so far, check to see if anything special is going on +// + amodOp = ASM_GET_amod(usOp); + amodTable = ASM_GET_amod(usTable); + switch (amodTable) + { + // Normal's match with normals + case _normal: + switch(amodOp) + { + case _normal: + case _addr16: + case _addr32: + case _fn16: + case _fn32: + case _flbl: + return(TRUE); + default: + return(FALSE); + } + case _rseg: + case _rspecial: + return(FALSE); + default: + assert(0); + return 0; + } +} + +#ifdef DEBUG + +/******************************* + */ + +STATIC void asm_output_flags(opflag_t opflags) +{ + ASM_OPERAND_TYPE aopty = ASM_GET_aopty(opflags); + ASM_MODIFIERS amod = ASM_GET_amod(opflags); + unsigned uRegmask = ASM_GET_uRegmask(opflags); + unsigned uSizemask = ASM_GET_uSizemask(opflags); + + if (uSizemask == _anysize) + printf("_anysize "); + else if (uSizemask == 0) + printf("0 "); + else + { + if (uSizemask & _8) + printf("_8 "); + if (uSizemask & _16) + printf("_16 "); + if (uSizemask & _32) + printf("_32 "); + if (uSizemask & _48) + printf("_48 "); + if (uSizemask & _64) + printf("_64 "); + } + + printf("_"); + switch (aopty) { + case _reg: + printf("reg "); + break; + case _m: + printf("m "); + break; + case _imm: + printf("imm "); + break; + case _rel: + printf("rel "); + break; + case _mnoi: + printf("mnoi "); + break; + case _p: + printf("p "); + break; + case _rm: + printf("rm "); + break; + case _float: + printf("float "); + break; + default: + printf(" UNKNOWN "); + } + + printf("_"); + switch (amod) { + case _normal: + printf("normal "); + if (uRegmask & 1) printf("_al "); + if (uRegmask & 2) printf("_ax "); + if (uRegmask & 4) printf("_eax "); + if (uRegmask & 8) printf("_dx "); + if (uRegmask & 0x10) printf("_cl "); + if (uRegmask & 0x40) printf("_rax "); + if (uRegmask & 0x20) printf("_rplus_r "); + return; + case _rseg: + printf("rseg "); + break; + case _rspecial: + printf("rspecial "); + break; + case _addr16: + printf("addr16 "); + break; + case _addr32: + printf("addr32 "); + break; + case _fn16: + printf("fn16 "); + break; + case _fn32: + printf("fn32 "); + break; + case _flbl: + printf("flbl "); + break; + default: + printf("UNKNOWN "); + break; + } + printf("uRegmask=x%02x", uRegmask); + +} + +/******************************* + */ + +STATIC void asm_output_popnd(OPND *popnd) +{ + if (popnd->segreg) + printf("%s:", popnd->segreg->regstr); + + if (popnd->s) + printf("%s", popnd->s->ident->toChars()); + + if (popnd->base) + printf("%s", popnd->base->regstr); + if (popnd->pregDisp1) { + if (popnd->pregDisp2) { + if (popnd->usFlags & _a32) + if (popnd->uchMultiplier) + printf("[%s][%s*%d]", + popnd->pregDisp1->regstr, + popnd->pregDisp2->regstr, + popnd->uchMultiplier); + else + printf("[%s][%s]", + popnd->pregDisp1->regstr, + popnd->pregDisp2->regstr); + else + printf("[%s+%s]", + popnd->pregDisp1->regstr, + popnd->pregDisp2->regstr); + } + else { + if (popnd->uchMultiplier) + printf("[%s*%d]", + popnd->pregDisp1->regstr, + popnd->uchMultiplier); + else + printf("[%s]", + popnd->pregDisp1->regstr); + } + } + if (ASM_GET_aopty(popnd->usFlags) == _imm) + printf("%llxh", (long long)popnd->disp); + else + if (popnd->disp) + printf("+%llxh", (long long)popnd->disp); +} + +#endif + +/******************************* + */ + +STATIC REG *asm_reg_lookup(char *s) +{ + int i; + + //dbg_printf("asm_reg_lookup('%s')\n",s); + + for (i = 0; i < sizeof(regtab) / sizeof(regtab[0]); i++) + { + if (strcmp(s,regtab[i].regstr) == 0) + { + return ®tab[i]; + } + } + if (I64) + { + for (i = 0; i < sizeof(regtab64) / sizeof(regtab64[0]); i++) + { + if (strcmp(s,regtab64[i].regstr) == 0) + { + return ®tab64[i]; + } + } + } + return NULL; +} + + +/******************************* + */ + +STATIC void asm_token() +{ + if (asmtok) + asmtok = asmtok->next; + asm_token_trans(asmtok); +} + +/******************************* + */ + +STATIC void asm_token_trans(Token *tok) +{ + tok_value = TOKeof; + if (tok) + { + tok_value = tok->value; + if (tok_value == TOKidentifier) + { size_t len; + char *id; + + id = tok->ident->toChars(); + len = strlen(id); + if (len < 20) + { + ASMTK asmtk = (ASMTK) binary(id, apszAsmtk, ASMTKmax); + if ((int)asmtk >= 0) + tok_value = (enum TOK) (asmtk + TOKMAX + 1); + } + } + } +} + +/******************************* + */ + +STATIC unsigned asm_type_size(Type * ptype) +{ unsigned u; + + //if (ptype) printf("asm_type_size('%s') = %d\n", ptype->toChars(), (int)ptype->size()); + u = _anysize; + if (ptype && ptype->ty != Tfunction /*&& ptype->isscalar()*/) + { + switch ((int)ptype->size()) + { + case 0: asmerr(EM_bad_op, "0 size"); break; + case 1: u = _8; break; + case 2: u = _16; break; + case 4: u = _32; break; + case 6: u = _48; break; + case 8: if (I64) u = _64; break; + } + } + return u; +} + +/******************************* + * start of inline assemblers expression parser + * NOTE: functions in call order instead of alphabetical + */ + +/******************************************* + * Parse DA expression + * + * Very limited define address to place a code + * address in the assembly + * Problems: + * o Should use dw offset and dd offset instead, + * for near/far support. + * o Should be able to add an offset to the label address. + * o Blocks addressed by DA should get their Bpred set correctly + * for optimizer. + */ + +STATIC code *asm_da_parse(OP *pop) +{ + code *clst = NULL; + + while (1) + { code *c; + + if (tok_value == TOKidentifier) + { + LabelDsymbol *label; + + label = asmstate.sc->func->searchLabel(asmtok->ident); + if (!label) + error(asmstate.loc, "label '%s' not found\n", asmtok->ident->toChars()); + + c = code_calloc(); + c->Iop = ASM; + c->Iflags = CFaddrsize; + c->IFL1 = FLblockoff; + c->IEVlsym1 = label; + c = asm_genloc(asmstate.loc, c); + clst = cat(clst,c); + } + else + asmerr(EM_bad_addr_mode); // illegal addressing mode + asm_token(); + if (tok_value != TOKcomma) + break; + asm_token(); + } + + asmstate.statement->regs |= mES|ALLREGS; + asmstate.bReturnax = TRUE; + + return clst; +} + +/******************************************* + * Parse DB, DW, DD, DQ and DT expressions. + */ + +STATIC code *asm_db_parse(OP *pop) +{ + unsigned usSize; + unsigned usMaxbytes; + unsigned usBytes; + union DT + { targ_ullong ul; + targ_float f; + targ_double d; + targ_ldouble ld; + char value[10]; + } dt; + code *c; + unsigned op; + static unsigned char opsize[] = { 1,2,4,8,4,8,10 }; + + op = pop->usNumops & ITSIZE; + usSize = opsize[op]; + + usBytes = 0; + usMaxbytes = 0; + c = code_calloc(); + c->Iop = ASM; + + while (1) + { + size_t len; + unsigned char *q; + + if (usBytes+usSize > usMaxbytes) + { usMaxbytes = usBytes + usSize + 10; + c->IEV1.as.bytes = (char *)mem_realloc(c->IEV1.as.bytes,usMaxbytes); + } + switch (tok_value) + { + case TOKint32v: + dt.ul = asmtok->int32value; + goto L1; + case TOKuns32v: + dt.ul = asmtok->uns32value; + goto L1; + case TOKint64v: + dt.ul = asmtok->int64value; + goto L1; + case TOKuns64v: + dt.ul = asmtok->uns64value; + goto L1; + L1: + switch (op) + { + case OPdb: + case OPds: + case OPdi: + case OPdl: + break; + default: + asmerr(EM_float); + } + goto L2; + + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + switch (op) + { + case OPdf: + dt.f = asmtok->float80value; + break; + case OPdd: + dt.d = asmtok->float80value; + break; + case OPde: + dt.ld = asmtok->float80value; + break; + default: + asmerr(EM_num); + } + goto L2; + + L2: + memcpy(c->IEV1.as.bytes + usBytes,&dt,usSize); + usBytes += usSize; + break; + + case TOKstring: + len = asmtok->len; + q = asmtok->ustring; + L3: + if (len) + { + usMaxbytes += len * usSize; + c->IEV1.as.bytes = + (char *)mem_realloc(c->IEV1.as.bytes,usMaxbytes); + memcpy(c->IEV1.as.bytes + usBytes,asmtok->ustring,len); + + char *p = c->IEV1.as.bytes + usBytes; + for (size_t i = 0; i < len; i++) + { + // Be careful that this works + memset(p, 0, usSize); + switch (op) + { + case OPdb: + *p = (unsigned char)*q; + if (*p != *q) + asmerr(EM_char); + break; + + case OPds: + *(short *)p = *(unsigned char *)q; + if (*(short *)p != *q) + asmerr(EM_char); + break; + + case OPdi: + case OPdl: + *(long *)p = *q; + break; + + default: + asmerr(EM_float); + } + q++; + p += usSize; + } + + usBytes += len * usSize; + } + break; + + case TOKidentifier: + { Expression *e = new IdentifierExp(asmstate.loc, asmtok->ident); + e = e->semantic(asmstate.sc); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->op == TOKint64) + { dt.ul = e->toInteger(); + goto L2; + } + else if (e->op == TOKfloat64) + { + switch (op) + { + case OPdf: + dt.f = e->toReal(); + break; + case OPdd: + dt.d = e->toReal(); + break; + case OPde: + dt.ld = e->toReal(); + break; + default: + asmerr(EM_num); + } + goto L2; + } + else if (e->op == TOKstring) + { StringExp *se = (StringExp *)e; + q = (unsigned char *)se->string; + len = se->len; + goto L3; + } + goto Ldefault; + } + + default: + Ldefault: + asmerr(EM_const_init); // constant initializer + break; + } + c->IEV1.as.len = usBytes; + + asm_token(); + if (tok_value != TOKcomma) + break; + asm_token(); + } + + c = asm_genloc(asmstate.loc, c); + + asmstate.statement->regs |= /* mES| */ ALLREGS; + asmstate.bReturnax = TRUE; + + return c; +} + +/********************************** + * Parse and get integer expression. + */ + +int asm_getnum() +{ int v; + dinteger_t i; + + switch (tok_value) + { + case TOKint32v: + v = asmtok->int32value; + break; + + case TOKuns32v: + v = asmtok->uns32value; + break; + + case TOKidentifier: + Expression *e; + + e = new IdentifierExp(asmstate.loc, asmtok->ident); + e = e->semantic(asmstate.sc); + e = e->optimize(WANTvalue | WANTinterpret); + i = e->toInteger(); + v = (int) i; + if (v != i) + asmerr(EM_num); + break; + + default: + asmerr(EM_num); + v = 0; // no uninitialized values + break; + } + asm_token(); + return v; +} + +/******************************* + */ + +STATIC OPND *asm_cond_exp() +{ + OPND *o1,*o2,*o3; + + //printf("asm_cond_exp()\n"); + o1 = asm_log_or_exp(); + if (tok_value == TOKquestion) + { + asm_token(); + o2 = asm_cond_exp(); + asm_token(); + asm_chktok(TOKcolon,EM_colon); + o3 = asm_cond_exp(); + o1 = (o1->disp) ? o2 : o3; + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_log_or_exp() +{ + OPND *o1,*o2; + + o1 = asm_log_and_exp(); + while (tok_value == TOKoror) + { + asm_token(); + o2 = asm_log_and_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp = o1->disp || o2->disp; + else + asmerr(EM_bad_integral_operand); // illegal operand + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_log_and_exp() +{ + OPND *o1,*o2; + + o1 = asm_inc_or_exp(); + while (tok_value == TOKandand) + { + asm_token(); + o2 = asm_inc_or_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp = o1->disp && o2->disp; + else { + asmerr(EM_bad_integral_operand); // illegal operand + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_inc_or_exp() +{ + OPND *o1,*o2; + + o1 = asm_xor_exp(); + while (tok_value == TOKor) + { + asm_token(); + o2 = asm_xor_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp |= o2->disp; + else { + asmerr(EM_bad_integral_operand); // illegal operand + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_xor_exp() +{ + OPND *o1,*o2; + + o1 = asm_and_exp(); + while (tok_value == TOKxor) + { + asm_token(); + o2 = asm_and_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp ^= o2->disp; + else { + asmerr(EM_bad_integral_operand); // illegal operand + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_and_exp() +{ + OPND *o1,*o2; + + o1 = asm_equal_exp(); + while (tok_value == TOKand) + { + asm_token(); + o2 = asm_equal_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp &= o2->disp; + else { + asmerr(EM_bad_integral_operand); // illegal operand + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_equal_exp() +{ + OPND *o1,*o2; + + o1 = asm_rel_exp(); + while (1) + { + switch (tok_value) + { + case TOKequal: + asm_token(); + o2 = asm_rel_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp = o1->disp == o2->disp; + else { + asmerr(EM_bad_integral_operand); // illegal operand + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + case TOKnotequal: + asm_token(); + o2 = asm_rel_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp = o1->disp != o2->disp; + else { + asmerr(EM_bad_integral_operand); + } + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + default: + return o1; + } + } +} + +/******************************* + */ + +STATIC OPND *asm_rel_exp() +{ + OPND *o1,*o2; + enum TOK tok_save; + + o1 = asm_shift_exp(); + while (1) + { + switch (tok_value) + { + case TOKgt: + case TOKge: + case TOKlt: + case TOKle: + tok_save = tok_value; + asm_token(); + o2 = asm_shift_exp(); + if (asm_isint(o1) && asm_isint(o2)) + { + switch (tok_save) + { + case TOKgt: + o1->disp = o1->disp > o2->disp; + break; + case TOKge: + o1->disp = o1->disp >= o2->disp; + break; + case TOKlt: + o1->disp = o1->disp < o2->disp; + break; + case TOKle: + o1->disp = o1->disp <= o2->disp; + break; + } + } + else + asmerr(EM_bad_integral_operand); + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + default: + return o1; + } + } +} + +/******************************* + */ + +STATIC OPND *asm_shift_exp() +{ + OPND *o1,*o2; + enum TOK tk; + + o1 = asm_add_exp(); + while (tok_value == TOKshl || tok_value == TOKshr || tok_value == TOKushr) + { tk = tok_value; + asm_token(); + o2 = asm_add_exp(); + if (asm_isint(o1) && asm_isint(o2)) + { if (tk == TOKshl) + o1->disp <<= o2->disp; + else if (tk == TOKushr) + o1->disp = (unsigned)o1->disp >> o2->disp; + else + o1->disp >>= o2->disp; + } + else + asmerr(EM_bad_integral_operand); + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_add_exp() +{ + OPND *o1,*o2; + + o1 = asm_mul_exp(); + while (1) + { + switch (tok_value) + { + case TOKadd: + asm_token(); + o2 = asm_mul_exp(); + o1 = asm_merge_opnds(o1, o2); + break; + + case TOKmin: + asm_token(); + o2 = asm_mul_exp(); + if (asm_isint(o1) && asm_isint(o2)) + { + o1->disp -= o2->disp; + o2->disp = 0; + } + else + o2->disp = - o2->disp; + o1 = asm_merge_opnds(o1, o2); + break; + + default: + return o1; + } + } +} + +/******************************* + */ + +STATIC OPND *asm_mul_exp() +{ + OPND *o1,*o2; + OPND *popndTmp; + + //printf("+asm_mul_exp()\n"); + o1 = asm_br_exp(); + while (1) + { + switch (tok_value) + { + case TOKmul: + asm_token(); + o2 = asm_br_exp(); +#ifdef EXTRA_DEBUG + printf("Star o1.isint=%d, o2.isint=%d, lbra_seen=%d\n", + asm_isint(o1), asm_isint(o2), asm_TKlbra_seen ); +#endif + if (asm_isNonZeroInt(o1) && asm_isNonZeroInt(o2)) + o1->disp *= o2->disp; + else if (asm_TKlbra_seen && o1->pregDisp1 && asm_isNonZeroInt(o2)) + { + o1->uchMultiplier = o2->disp; +#ifdef EXTRA_DEBUG + printf("Multiplier: %d\n", o1->uchMultiplier); +#endif + } + else if (asm_TKlbra_seen && o2->pregDisp1 && asm_isNonZeroInt(o1)) + { + popndTmp = o2; + o2 = o1; + o1 = popndTmp; + o1->uchMultiplier = o2->disp; +#ifdef EXTRA_DEBUG + printf("Multiplier: %d\n", + o1->uchMultiplier); +#endif + } + else if (asm_isint(o1) && asm_isint(o2)) + o1->disp *= o2->disp; + else + asmerr(EM_bad_operand); + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + case TOKdiv: + asm_token(); + o2 = asm_br_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp /= o2->disp; + else + asmerr(EM_bad_integral_operand); + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + case TOKmod: + asm_token(); + o2 = asm_br_exp(); + if (asm_isint(o1) && asm_isint(o2)) + o1->disp %= o2->disp; + else + asmerr(EM_bad_integral_operand); + o2->disp = 0; + o1 = asm_merge_opnds(o1, o2); + break; + + default: + return o1; + } + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_br_exp() +{ + OPND *o1,*o2; + + //printf("asm_br_exp()\n"); + o1 = asm_una_exp(); + while (1) + { + switch (tok_value) + { + case TOKlbracket: + { +#ifdef EXTRA_DEBUG + printf("Saw a left bracket\n"); +#endif + asm_token(); + asm_TKlbra_seen++; + o2 = asm_cond_exp(); + asm_TKlbra_seen--; + asm_chktok(TOKrbracket,EM_rbra); +#ifdef EXTRA_DEBUG + printf("Saw a right bracket\n"); +#endif + o1 = asm_merge_opnds(o1, o2); + if (tok_value == TOKidentifier) + { o2 = asm_una_exp(); + o1 = asm_merge_opnds(o1, o2); + } + break; + } + default: + return o1; + } + } +} + +/******************************* + */ + +STATIC OPND *asm_una_exp() +{ + OPND *o1; + Type *ptype; + ASM_JUMPTYPE ajt = ASM_JUMPTYPE_UNSPECIFIED; + char bPtr = 0; + + switch ((int)tok_value) + { +#if 0 + case TOKand: + asm_token(); + o1 = asm_una_exp(); + break; + + case TOKmul: + asm_token(); + o1 = asm_una_exp(); + ++o1->indirect; + break; +#endif + case TOKadd: + asm_token(); + o1 = asm_una_exp(); + break; + + case TOKmin: + asm_token(); + o1 = asm_una_exp(); + if (asm_isint(o1)) + o1->disp = -o1->disp; + break; + + case TOKnot: + asm_token(); + o1 = asm_una_exp(); + if (asm_isint(o1)) + o1->disp = !o1->disp; + break; + + case TOKtilde: + asm_token(); + o1 = asm_una_exp(); + if (asm_isint(o1)) + o1->disp = ~o1->disp; + break; + +#if 0 + case TOKlparen: + // stoken() is called directly here because we really + // want the INT token to be an INT. + stoken(); + if (type_specifier(&ptypeSpec)) /* if type_name */ + { + + ptype = declar_abstract(ptypeSpec); + /* read abstract_declarator */ + fixdeclar(ptype);/* fix declarator */ + type_free(ptypeSpec);/* the declar() function + allocates the typespec again */ + chktok(TOKrparen,EM_rpar); + ptype->Tcount--; + goto CAST_REF; + } + else + { + type_free(ptypeSpec); + o1 = asm_cond_exp(); + chktok(TOKrparen, EM_rpar); + } + break; +#endif + + case TOKidentifier: + // Check for offset keyword + if (asmtok->ident == Id::offset) + { + if (!global.params.useDeprecated) + error(asmstate.loc, "offset deprecated, use offsetof"); + goto Loffset; + } + if (asmtok->ident == Id::offsetof) + { + Loffset: + asm_token(); + o1 = asm_cond_exp(); + if (!o1) + o1 = opnd_calloc(); + o1->bOffset= TRUE; + } + else + o1 = asm_primary_exp(); + break; + + case ASMTKseg: + asm_token(); + o1 = asm_cond_exp(); + if (!o1) + o1 = opnd_calloc(); + o1->bSeg= TRUE; + break; + + case TOKint16: + if (asmstate.ucItype != ITjump) + { + ptype = Type::tint16; + goto TYPE_REF; + } + ajt = ASM_JUMPTYPE_SHORT; + asm_token(); + goto JUMP_REF2; + + case ASMTKnear: + ajt = ASM_JUMPTYPE_NEAR; + goto JUMP_REF; + + case ASMTKfar: + ajt = ASM_JUMPTYPE_FAR; +JUMP_REF: + asm_token(); + asm_chktok((enum TOK) ASMTKptr, EM_ptr_exp); +JUMP_REF2: + o1 = asm_cond_exp(); + if (!o1) + o1 = opnd_calloc(); + o1->ajt= ajt; + break; + + case TOKint8: + ptype = Type::tint8; + goto TYPE_REF; + case TOKint32: + case ASMTKdword: + ptype = Type::tint32; + goto TYPE_REF; + case TOKfloat32: + ptype = Type::tfloat32; + goto TYPE_REF; + case ASMTKqword: + case TOKfloat64: + ptype = Type::tfloat64; + goto TYPE_REF; + case TOKfloat80: + ptype = Type::tfloat80; + goto TYPE_REF; + case ASMTKword: + ptype = Type::tint16; +TYPE_REF: + bPtr = 1; + asm_token(); + asm_chktok((enum TOK) ASMTKptr, EM_ptr_exp); + o1 = asm_cond_exp(); + if (!o1) + o1 = opnd_calloc(); + o1->ptype = ptype; + o1->bPtr = bPtr; + break; + + default: + o1 = asm_primary_exp(); + break; + } + return o1; +} + +/******************************* + */ + +STATIC OPND *asm_primary_exp() +{ + OPND *o1 = NULL; + OPND *o2 = NULL; + Dsymbol *s; + Dsymbol *scopesym; + + REG *regp; + + switch (tok_value) + { + case TOKdollar: + o1 = opnd_calloc(); + o1->s = asmstate.psDollar; + asm_token(); + break; + +#if 0 + case TOKthis: + strcpy(tok.TKid,cpp_name_this); +#endif + case TOKthis: + case TOKidentifier: + o1 = opnd_calloc(); + regp = asm_reg_lookup(asmtok->ident->toChars()); + if (regp != NULL) + { + asm_token(); + // see if it is segment override (like SS:) + if (!asm_TKlbra_seen && + (regp->ty & _seg) && + tok_value == TOKcolon) + { + o1->segreg = regp; + asm_token(); + o2 = asm_cond_exp(); + o1 = asm_merge_opnds(o1, o2); + } + else if (asm_TKlbra_seen) + { // should be a register + if (o1->pregDisp1) + asmerr(EM_bad_operand); + else + o1->pregDisp1 = regp; + } + else + { if (o1->base == NULL) + o1->base = regp; + else + asmerr(EM_bad_operand); + } + break; + } + // If floating point instruction and id is a floating register + else if (asmstate.ucItype == ITfloat && + asm_is_fpreg(asmtok->ident->toChars())) + { + asm_token(); + if (tok_value == TOKlparen) + { unsigned n; + + asm_token(); + asm_chktok(TOKint32v, EM_num); + n = (unsigned)asmtok->uns64value; + if (n > 7) + asmerr(EM_bad_operand); + o1->base = &(aregFp[n]); + asm_chktok(TOKrparen, EM_rpar); + } + else + o1->base = ®Fp; + } + else + { + if (asmstate.ucItype == ITjump) + { + s = NULL; + if (asmstate.sc->func->labtab) + s = asmstate.sc->func->labtab->lookup(asmtok->ident); + if (!s) + s = asmstate.sc->search(0, asmtok->ident, &scopesym); + if (!s) + { // Assume it is a label, and define that label + s = asmstate.sc->func->searchLabel(asmtok->ident); + } + } + else + s = asmstate.sc->search(0, asmtok->ident, &scopesym); + if (!s) + asmerr(EM_undefined, asmtok->toChars()); + + Identifier *id = asmtok->ident; + asm_token(); + if (tok_value == TOKdot) + { Expression *e; + VarExp *v; + + e = new IdentifierExp(asmstate.loc, id); + while (1) + { + asm_token(); + if (tok_value == TOKidentifier) + { + e = new DotIdExp(asmstate.loc, e, asmtok->ident); + asm_token(); + if (tok_value != TOKdot) + break; + } + else + { + asmerr(EM_ident_exp); + break; + } + } + e = e->semantic(asmstate.sc); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->isConst()) + { + if (e->type->isintegral()) + { + o1->disp = e->toInteger(); + goto Lpost; + } + else if (e->type->isreal()) + { + o1->real = e->toReal(); + o1->ptype = e->type; + goto Lpost; + } + else + { + asmerr(EM_bad_op, e->toChars()); + } + } + else if (e->op == TOKvar) + { + v = (VarExp *)(e); + s = v->var; + } + else + { + asmerr(EM_bad_op, e->toChars()); + } + } + + asm_merge_symbol(o1,s); + + /* This attempts to answer the question: is + * char[8] foo; + * of size 1 or size 8? Presume it is 8 if foo + * is the last token of the operand. + */ + if (o1->ptype && tok_value != TOKcomma && tok_value != TOKeof) + { + for (; + o1->ptype->ty == Tsarray; + o1->ptype = o1->ptype->nextOf()) + { + ; + } + } + + Lpost: +#if 0 + // for [] + if (tok_value == TOKlbracket) + o1 = asm_prim_post(o1); +#endif + goto Lret; + } + break; + + case TOKint32v: + case TOKuns32v: + o1 = opnd_calloc(); + o1->disp = asmtok->int32value; + asm_token(); + break; + + case TOKint64v: + case TOKuns64v: + o1 = opnd_calloc(); + o1->disp = asmtok->int64value; + asm_token(); + break; + + case TOKfloat32v: + o1 = opnd_calloc(); + o1->real = asmtok->float80value; + o1->ptype = Type::tfloat32; + asm_token(); + break; + + case TOKfloat64v: + o1 = opnd_calloc(); + o1->real = asmtok->float80value; + o1->ptype = Type::tfloat64; + asm_token(); + break; + + case TOKfloat80v: + o1 = opnd_calloc(); + o1->real = asmtok->float80value; + o1->ptype = Type::tfloat80; + asm_token(); + break; + + case ASMTKlocalsize: + o1 = opnd_calloc(); + o1->s = asmstate.psLocalsize; + o1->ptype = Type::tint32; + asm_token(); + break; + } +Lret: + return o1; +} + +/******************************* + */ + +#if 0 +STATIC OPND *asm_prim_post(OPND *o1) +{ + OPND *o2; + Declaration *d = o1->s ? o1->s->isDeclaration() : NULL; + Type *t; + + t = d ? d->type : o1->ptype; + while (1) + { + switch (tok_value) + { +#if 0 + case TKarrow: + if (++o1->indirect > 1) + { + BAD_OPERAND: + asmerr(EM_bad_operand); + } + if (s->Sclass != SCregister) + goto BAD_OPERAND; + if (!typtr(t->Tty)) + { + asmerr(EM_pointer,t,(type *) NULL); + } + else + t = t->Tnext; + case TKcolcol: + if (tybasic(t->Tty) != TYstruct) + asmerr(EM_not_struct); // not a struct or union type + goto L1; + + case TOKdot: + for (; t && tybasic(t->Tty) != TYstruct; + t = t->Tnext) + ; + if (!t) + asmerr(EM_not_struct); + L1: + /* try to find the symbol */ + asm_token(); + if (tok_value != TOKidentifier) + asmerr(EM_ident_exp); + s = n2_searchmember(t->Ttag,tok.TKid); + if (!s) + { + err_notamember(tok.TKid,t->Ttag); + } + else + { + asm_merge_symbol(o1,s); + t = s->Stype; + asm_token(); + } + break; +#endif + + case TOKlbracket: + asm_token(); + asm_TKlbra_seen++; + o2 = asm_cond_exp(); + asm_chktok(TOKrbracket,EM_rbra); + asm_TKlbra_seen--; + return asm_merge_opnds(o1, o2); + + default: + return o1; + } + } +} +#endif + +/******************************* + */ + +void iasm_term() +{ + if (asmstate.bInit) + { + asmstate.psDollar = NULL; + asmstate.psLocalsize = NULL; + asmstate.bInit = 0; + } +} + +/********************************** + * Return mask of registers used by block bp. + */ + +regm_t iasm_regs(block *bp) +{ +#ifdef DEBUG + if (debuga) + printf("Block iasm regs = 0x%X\n", bp->usIasmregs); +#endif + + refparam |= bp->bIasmrefparam; + return bp->usIasmregs; +} + + +/************************ AsmStatement ***************************************/ + +Statement *AsmStatement::semantic(Scope *sc) +{ + //printf("AsmStatement::semantic()\n"); + + assert(sc->func); +#if DMDV2 + if (sc->func->setUnsafe()) + error("inline assembler not allowed in @safe function %s", sc->func->toChars()); +#endif + + OP *o; + OPND *o1 = NULL,*o2 = NULL, *o3 = NULL, *o4 = NULL; + PTRNTAB ptb; + unsigned usNumops; + unsigned char uchPrefix = 0; + char *pszLabel = NULL; + FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + + assert(fd); +#if DMDV1 + fd->inlineAsm = 1; +#endif + + if (!tokens) + return NULL; + + memset(&asmstate, 0, sizeof(asmstate)); + + asmstate.statement = this; + asmstate.sc = sc; + +#if 0 // don't use bReturnax anymore, and will fail anyway if we use return type inference + // Scalar return values will always be in AX. So if it is a scalar + // then asm block sets return value if it modifies AX, if it is non-scalar + // then always assume that the ASM block sets up an appropriate return + // value. + + asmstate.bReturnax = 1; + if (sc->func->type->nextOf()->isscalar()) + asmstate.bReturnax = 0; +#endif + + // Assume assembler code takes care of setting the return value + sc->func->hasReturnExp |= 8; + + if (!asmstate.bInit) + { + asmstate.bInit = TRUE; + init_optab(); + asmstate.psDollar = new LabelDsymbol(Id::__dollar); + asmstate.psLocalsize = new Dsymbol(Id::__LOCAL_SIZE); + } + + asmstate.loc = loc; + + asmtok = tokens; + asm_token_trans(asmtok); + if (setjmp(asmstate.env)) + { asmtok = NULL; // skip rest of line + tok_value = TOKeof; + exit(EXIT_FAILURE); + goto AFTER_EMIT; + } + + switch (tok_value) + { + case ASMTKnaked: + naked = TRUE; + sc->func->naked = TRUE; + asm_token(); + break; + + case ASMTKeven: + asm_token(); + asmalign = 2; + break; + + case TOKalign: + { unsigned align; + + asm_token(); + align = asm_getnum(); + if (ispow2(align) == -1) + asmerr(EM_align, align); // power of 2 expected + else + asmalign = align; + break; + } + + // The following three convert the keywords 'int', 'in', 'out' + // to identifiers, since they are x86 instructions. + case TOKint32: + o = asm_op_lookup(Id::__int->toChars()); + goto Lopcode; + + case TOKin: + o = asm_op_lookup(Id::___in->toChars()); + goto Lopcode; + + case TOKout: + o = asm_op_lookup(Id::___out->toChars()); + goto Lopcode; + + case TOKidentifier: + o = asm_op_lookup(asmtok->ident->toChars()); + if (!o) + goto OPCODE_EXPECTED; + + Lopcode: + asmstate.ucItype = o->usNumops & ITMASK; + asm_token(); + if (o->usNumops > 4) + { + switch (asmstate.ucItype) + { + case ITdata: + asmcode = asm_db_parse(o); + goto AFTER_EMIT; + + case ITaddr: + asmcode = asm_da_parse(o); + goto AFTER_EMIT; + } + } + // get the first part of an expr + o1 = asm_cond_exp(); + if (tok_value == TOKcomma) + { + asm_token(); + o2 = asm_cond_exp(); + } + if (tok_value == TOKcomma) + { + asm_token(); + o3 = asm_cond_exp(); + } + if (tok_value == TOKcomma) + { + asm_token(); + o4 = asm_cond_exp(); + } + // match opcode and operands in ptrntab to verify legal inst and + // generate + + ptb = asm_classify(o, o1, o2, o3, o4, &usNumops); + assert(ptb.pptb0); + + // + // The Multiply instruction takes 3 operands, but if only 2 are seen + // then the third should be the second and the second should + // be a duplicate of the first. + // + + if (asmstate.ucItype == ITopt && + (usNumops == 2) && + (ASM_GET_aopty(o2->usFlags) == _imm) && + ((o->usNumops & ITSIZE) == 3)) + { + o3 = o2; + o2 = opnd_calloc(); + *o2 = *o1; + + // Re-classify the opcode because the first classification + // assumed 2 operands. + + ptb = asm_classify(o, o1, o2, o3, o4, &usNumops); + } +#if 0 + else + if (asmstate.ucItype == ITshift && (ptb.pptb2->usOp2 == 0 || + (ptb.pptb2->usOp2 & _cl))) { + opnd_free(o2); + o2 = NULL; + usNumops = 1; + } +#endif + asmcode = asm_emit(loc, usNumops, ptb, o, o1, o2, o3, o4); + break; + + default: + OPCODE_EXPECTED: + asmerr(EM_opcode_exp, asmtok->toChars()); // assembler opcode expected + break; + } + +AFTER_EMIT: + opnd_free(o1); + opnd_free(o2); + opnd_free(o3); + o1 = o2 = o3 = NULL; + + if (tok_value != TOKeof) + asmerr(EM_eol); // end of line expected + //return asmstate.bReturnax; + return this; +} + diff --git a/identifier.c b/identifier.c new file mode 100644 index 00000000..178ae12b --- /dev/null +++ b/identifier.c @@ -0,0 +1,102 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "identifier.h" +#include "mars.h" +#include "lexer.h" +#include "id.h" + +Identifier::Identifier(const char *string, int value) +{ + //printf("Identifier('%s', %d)\n", string, value); + this->string = string; + this->value = value; + this->len = strlen(string); +} + +hash_t Identifier::hashCode() +{ + return String::calcHash(string); +} + +int Identifier::equals(Object *o) +{ + return this == o || memcmp(string,o->toChars(),len+1) == 0; +} + +int Identifier::compare(Object *o) +{ + return memcmp(string, o->toChars(), len + 1); +} + +char *Identifier::toChars() +{ + return (char *)string; +} + +const char *Identifier::toHChars2() +{ + const char *p = NULL; + + if (this == Id::ctor) p = "this"; + else if (this == Id::dtor) p = "~this"; + else if (this == Id::classInvariant) p = "invariant"; + else if (this == Id::unitTest) p = "unittest"; + else if (this == Id::dollar) p = "$"; + else if (this == Id::withSym) p = "with"; + else if (this == Id::result) p = "result"; + else if (this == Id::returnLabel) p = "return"; + else + { p = toChars(); + if (*p == '_') + { + if (memcmp(p, "_staticCtor", 11) == 0) + p = "static this"; + else if (memcmp(p, "_staticDtor", 11) == 0) + p = "static ~this"; + } + } + + return p; +} + +void Identifier::print() +{ + fprintf(stdmsg, "%s",string); +} + +int Identifier::dyncast() +{ + return DYNCAST_IDENTIFIER; +} + +// BUG: these are redundant with Lexer::uniqueId() + +Identifier *Identifier::generateId(const char *prefix) +{ + static size_t i; + + return generateId(prefix, ++i); +} + +Identifier *Identifier::generateId(const char *prefix, size_t i) +{ OutBuffer buf; + + buf.writestring(prefix); + buf.printf("%zu", i); + + char *id = buf.toChars(); + buf.data = NULL; + return Lexer::idPool(id); +} diff --git a/identifier.h b/identifier.h new file mode 100644 index 00000000..b786fca9 --- /dev/null +++ b/identifier.h @@ -0,0 +1,40 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_IDENTIFIER_H +#define DMD_IDENTIFIER_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" + +struct Identifier : Object +{ + int value; + const char *string; + unsigned len; + + Identifier(const char *string, int value); + int equals(Object *o); + hash_t hashCode(); + int compare(Object *o); + void print(); + char *toChars(); + char *toHChars(); + const char *toHChars2(); + int dyncast(); + + static Identifier *generateId(const char *prefix); + static Identifier *generateId(const char *prefix, size_t i); +}; + +#endif /* DMD_IDENTIFIER_H */ diff --git a/idgen.c b/idgen.c new file mode 100644 index 00000000..075c73d0 --- /dev/null +++ b/idgen.c @@ -0,0 +1,412 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// http://www.dsource.org/projects/dmd/browser/trunk/src/idgen.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Program to generate string files in d data structures. +// Saves much tedious typing, and eliminates typo problems. +// Generates: +// id.h +// id.c + +#include +#include +#include +#include + +struct Msgtable +{ + const char *ident; // name to use in DMD source + const char *name; // name in D executable +}; + +Msgtable msgtable[] = +{ + { "IUnknown" }, + { "Object" }, + { "object" }, + { "max" }, + { "min" }, + { "This", "this" }, + { "super" }, + { "ctor", "__ctor" }, + { "dtor", "__dtor" }, + { "cpctor", "__cpctor" }, + { "_postblit", "__postblit" }, + { "classInvariant", "__invariant" }, + { "unitTest", "__unitTest" }, + { "require", "__require" }, + { "ensure", "__ensure" }, + { "init" }, + { "size" }, + { "__sizeof", "sizeof" }, + { "__xalignof", "alignof" }, + { "mangleof" }, + { "stringof" }, + { "tupleof" }, + { "length" }, + { "remove" }, + { "ptr" }, + { "array" }, + { "funcptr" }, + { "dollar", "__dollar" }, + { "ctfe", "__ctfe" }, + { "offset" }, + { "offsetof" }, + { "ModuleInfo" }, + { "ClassInfo" }, + { "classinfo" }, + { "typeinfo" }, + { "outer" }, + { "Exception" }, + { "AssociativeArray" }, + { "Throwable" }, + { "Error" }, + { "withSym", "__withSym" }, + { "result", "__result" }, + { "returnLabel", "__returnLabel" }, + { "delegate" }, + { "line" }, + { "empty", "" }, + { "p" }, + { "q" }, + { "coverage", "__coverage" }, + { "__vptr" }, + { "__monitor" }, + + { "TypeInfo" }, + { "TypeInfo_Class" }, + { "TypeInfo_Interface" }, + { "TypeInfo_Struct" }, + { "TypeInfo_Enum" }, + { "TypeInfo_Typedef" }, + { "TypeInfo_Pointer" }, + { "TypeInfo_Vector" }, + { "TypeInfo_Array" }, + { "TypeInfo_StaticArray" }, + { "TypeInfo_AssociativeArray" }, + { "TypeInfo_Function" }, + { "TypeInfo_Delegate" }, + { "TypeInfo_Tuple" }, + { "TypeInfo_Const" }, + { "TypeInfo_Invariant" }, + { "TypeInfo_Shared" }, + { "TypeInfo_Wild", "TypeInfo_Inout" }, + { "elements" }, + { "_arguments_typeinfo" }, + { "_arguments" }, + { "_argptr" }, + { "_match" }, + { "destroy" }, + { "postblit" }, + + { "LINE", "__LINE__" }, + { "FILE", "__FILE__" }, + { "DATE", "__DATE__" }, + { "TIME", "__TIME__" }, + { "TIMESTAMP", "__TIMESTAMP__" }, + { "VENDOR", "__VENDOR__" }, + { "VERSIONX", "__VERSION__" }, + { "EOFX", "__EOF__" }, + + { "nan" }, + { "infinity" }, + { "dig" }, + { "epsilon" }, + { "mant_dig" }, + { "max_10_exp" }, + { "max_exp" }, + { "min_10_exp" }, + { "min_exp" }, + { "min_normal" }, + { "re" }, + { "im" }, + + { "C" }, + { "D" }, + { "Windows" }, + { "Pascal" }, + { "System" }, + + { "exit" }, + { "success" }, + { "failure" }, + + { "keys" }, + { "values" }, + { "rehash" }, + + { "sort" }, + { "reverse" }, + { "dup" }, + { "idup" }, + + { "property" }, + { "safe" }, + { "trusted" }, + { "system" }, + { "disable" }, + + // For inline assembler + { "___out", "out" }, + { "___in", "in" }, + { "__int", "int" }, + { "__dollar", "$" }, + { "__LOCAL_SIZE" }, + + // For operator overloads + { "uadd", "opPos" }, + { "neg", "opNeg" }, + { "com", "opCom" }, + { "add", "opAdd" }, + { "add_r", "opAdd_r" }, + { "sub", "opSub" }, + { "sub_r", "opSub_r" }, + { "mul", "opMul" }, + { "mul_r", "opMul_r" }, + { "div", "opDiv" }, + { "div_r", "opDiv_r" }, + { "mod", "opMod" }, + { "mod_r", "opMod_r" }, + { "eq", "opEquals" }, + { "cmp", "opCmp" }, + { "iand", "opAnd" }, + { "iand_r", "opAnd_r" }, + { "ior", "opOr" }, + { "ior_r", "opOr_r" }, + { "ixor", "opXor" }, + { "ixor_r", "opXor_r" }, + { "shl", "opShl" }, + { "shl_r", "opShl_r" }, + { "shr", "opShr" }, + { "shr_r", "opShr_r" }, + { "ushr", "opUShr" }, + { "ushr_r", "opUShr_r" }, + { "cat", "opCat" }, + { "cat_r", "opCat_r" }, + { "assign", "opAssign" }, + { "addass", "opAddAssign" }, + { "subass", "opSubAssign" }, + { "mulass", "opMulAssign" }, + { "divass", "opDivAssign" }, + { "modass", "opModAssign" }, + { "andass", "opAndAssign" }, + { "orass", "opOrAssign" }, + { "xorass", "opXorAssign" }, + { "shlass", "opShlAssign" }, + { "shrass", "opShrAssign" }, + { "ushrass", "opUShrAssign" }, + { "catass", "opCatAssign" }, + { "postinc", "opPostInc" }, + { "postdec", "opPostDec" }, + { "index", "opIndex" }, + { "indexass", "opIndexAssign" }, + { "slice", "opSlice" }, + { "sliceass", "opSliceAssign" }, + { "call", "opCall" }, + { "cast", "opCast" }, + { "match", "opMatch" }, + { "next", "opNext" }, + { "opIn" }, + { "opIn_r" }, + { "opStar" }, + { "opDot" }, + { "opDispatch" }, + { "opDollar" }, + { "opUnary" }, + { "opIndexUnary" }, + { "opSliceUnary" }, + { "opBinary" }, + { "opBinaryRight" }, + { "opOpAssign" }, + { "opIndexOpAssign" }, + { "opSliceOpAssign" }, + { "pow", "opPow" }, + { "pow_r", "opPow_r" }, + { "powass", "opPowAssign" }, + + { "classNew", "new" }, + { "classDelete", "delete" }, + + // For foreach + { "apply", "opApply" }, + { "applyReverse", "opApplyReverse" }, + + // Ranges + { "Fempty", "empty" }, + { "Ffront", "front" }, + { "Fback", "back" }, + { "FpopFront", "popFront" }, + { "FpopBack", "popBack" }, + + { "adDup", "_adDupT" }, + { "adReverse", "_adReverse" }, + + // For internal functions + { "aaLen", "_aaLen" }, + { "aaKeys", "_aaKeys" }, + { "aaValues", "_aaValues" }, + { "aaRehash", "_aaRehash" }, + { "monitorenter", "_d_monitorenter" }, + { "monitorexit", "_d_monitorexit" }, + { "criticalenter", "_d_criticalenter" }, + { "criticalexit", "_d_criticalexit" }, + { "_ArrayEq" }, + + // For pragma's + { "GNU_asm" }, + { "lib" }, + { "msg" }, + { "startaddress" }, + + // For special functions + { "tohash", "toHash" }, + { "tostring", "toString" }, + { "getmembers", "getMembers" }, + + // Special functions + { "alloca" }, + { "main" }, + { "WinMain" }, + { "DllMain" }, + { "tls_get_addr", "___tls_get_addr" }, + + // varargs implementation + { "va_argsave_t", "__va_argsave_t" }, + { "va_argsave", "__va_argsave" }, + + // Builtin functions + { "std" }, + { "core" }, + { "math" }, + { "sin" }, + { "cos" }, + { "tan" }, + { "_sqrt", "sqrt" }, + { "_pow", "pow" }, + { "atan2" }, + { "rndtol" }, + { "expm1" }, + { "exp2" }, + { "yl2x" }, + { "yl2xp1" }, + { "fabs" }, + { "bitop" }, + { "bsf" }, + { "bsr" }, + { "bswap" }, + + // Traits + { "isAbstractClass" }, + { "isArithmetic" }, + { "isAssociativeArray" }, + { "isFinalClass" }, + { "isFloating" }, + { "isIntegral" }, + { "isScalar" }, + { "isStaticArray" }, + { "isUnsigned" }, + { "isVirtualFunction" }, + { "isVirtualMethod" }, + { "isAbstractFunction" }, + { "isFinalFunction" }, + { "isStaticFunction" }, + { "isRef" }, + { "isOut" }, + { "isLazy" }, + { "hasMember" }, + { "identifier" }, + { "parent" }, + { "getMember" }, + { "getOverloads" }, + { "getVirtualFunctions" }, + { "getVirtualMethods" }, + { "classInstanceSize" }, + { "allMembers" }, + { "derivedMembers" }, + { "isSame" }, + { "compiles" }, +}; + + +int main() +{ + FILE *fp; + unsigned i; + + { + fp = fopen("id.h","w"); + if (!fp) + { printf("can't open id.h\n"); + exit(EXIT_FAILURE); + } + + fprintf(fp, "// File generated by idgen.c\n"); +#if __DMC__ + fprintf(fp, "#pragma once\n"); +#endif + fprintf(fp, "#ifndef DMD_ID_H\n"); + fprintf(fp, "#define DMD_ID_H 1\n"); + fprintf(fp, "struct Identifier;\n"); + fprintf(fp, "struct Id\n"); + fprintf(fp, "{\n"); + + for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) + { const char *id = msgtable[i].ident; + + fprintf(fp," static Identifier *%s;\n", id); + } + + fprintf(fp, " static void initialize();\n"); + fprintf(fp, "};\n"); + fprintf(fp, "#endif\n"); + + fclose(fp); + } + + { + fp = fopen("id.c","w"); + if (!fp) + { printf("can't open id.c\n"); + exit(EXIT_FAILURE); + } + + fprintf(fp, "// File generated by idgen.c\n"); + fprintf(fp, "#include \"id.h\"\n"); + fprintf(fp, "#include \"identifier.h\"\n"); + fprintf(fp, "#include \"lexer.h\"\n"); + + for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) + { const char *id = msgtable[i].ident; + const char *p = msgtable[i].name; + + if (!p) + p = id; + fprintf(fp,"Identifier *Id::%s;\n", id); + } + + fprintf(fp, "void Id::initialize()\n"); + fprintf(fp, "{\n"); + + for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) + { const char *id = msgtable[i].ident; + const char *p = msgtable[i].name; + + if (!p) + p = id; + fprintf(fp," %s = Lexer::idPool(\"%s\");\n", id, p); + } + + fprintf(fp, "}\n"); + + fclose(fp); + } + + return EXIT_SUCCESS; +} diff --git a/impcnvgen.c b/impcnvgen.c new file mode 100644 index 00000000..8f182364 --- /dev/null +++ b/impcnvgen.c @@ -0,0 +1,427 @@ + +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mtype.h" + +TY impcnvResult[TMAX][TMAX]; +TY impcnvType1[TMAX][TMAX]; +TY impcnvType2[TMAX][TMAX]; +int impcnvWarn[TMAX][TMAX]; + +int integral_promotion(int t) +{ + switch (t) + { + case Tchar: + case Twchar: + case Tbool: + case Tint8: + case Tuns8: + case Tint16: + case Tuns16: return Tint32; + case Tdchar: return Tuns32; + default: return t; + } +} + +void init() +{ int i, j; + + // Set conversion tables + for (i = 0; i < TMAX; i++) + for (j = 0; j < TMAX; j++) + { impcnvResult[i][j] = Terror; + impcnvType1[i][j] = Terror; + impcnvType2[i][j] = Terror; + impcnvWarn[i][j] = 0; + } + +#define X(t1,t2, nt1,nt2, rt) \ + impcnvResult[t1][t2] = rt; \ + impcnvType1[t1][t2] = nt1; \ + impcnvType2[t1][t2] = nt2; + + + /* ======================= */ + + X(Tbool,Tbool, Tbool,Tbool, Tbool) + X(Tbool,Tint8, Tint32,Tint32, Tint32) + X(Tbool,Tuns8, Tint32,Tint32, Tint32) + X(Tbool,Tint16, Tint32,Tint32, Tint32) + X(Tbool,Tuns16, Tint32,Tint32, Tint32) + X(Tbool,Tint32, Tint32,Tint32, Tint32) + X(Tbool,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tbool,Tint64, Tint64,Tint64, Tint64) + X(Tbool,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tbool,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tbool,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tbool,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tbool,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tbool,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tbool,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tbool,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tbool,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tbool,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tint8,Tint8, Tint32,Tint32, Tint32) + X(Tint8,Tuns8, Tint32,Tint32, Tint32) + X(Tint8,Tint16, Tint32,Tint32, Tint32) + X(Tint8,Tuns16, Tint32,Tint32, Tint32) + X(Tint8,Tint32, Tint32,Tint32, Tint32) + X(Tint8,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tint8,Tint64, Tint64,Tint64, Tint64) + X(Tint8,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tint8,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tint8,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tint8,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tint8,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tint8,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tint8,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tint8,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tint8,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tint8,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tuns8,Tuns8, Tint32,Tint32, Tint32) + X(Tuns8,Tint16, Tint32,Tint32, Tint32) + X(Tuns8,Tuns16, Tint32,Tint32, Tint32) + X(Tuns8,Tint32, Tint32,Tint32, Tint32) + X(Tuns8,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tuns8,Tint64, Tint64,Tint64, Tint64) + X(Tuns8,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tuns8,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tuns8,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tuns8,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tuns8,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tuns8,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tuns8,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tuns8,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tuns8,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tuns8,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tint16,Tint16, Tint32,Tint32, Tint32) + X(Tint16,Tuns16, Tint32,Tint32, Tint32) + X(Tint16,Tint32, Tint32,Tint32, Tint32) + X(Tint16,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tint16,Tint64, Tint64,Tint64, Tint64) + X(Tint16,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tint16,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tint16,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tint16,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tint16,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tint16,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tint16,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tint16,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tint16,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tint16,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tuns16,Tuns16, Tint32,Tint32, Tint32) + X(Tuns16,Tint32, Tint32,Tint32, Tint32) + X(Tuns16,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tuns16,Tint64, Tint64,Tint64, Tint64) + X(Tuns16,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tuns16,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tuns16,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tuns16,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tuns16,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tuns16,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tuns16,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tuns16,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tuns16,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tuns16,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tint32,Tint32, Tint32,Tint32, Tint32) + X(Tint32,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tint32,Tint64, Tint64,Tint64, Tint64) + X(Tint32,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tint32,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tint32,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tint32,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tint32,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tint32,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tint32,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tint32,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tint32,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tint32,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tuns32,Tuns32, Tuns32,Tuns32, Tuns32) + X(Tuns32,Tint64, Tint64,Tint64, Tint64) + X(Tuns32,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tuns32,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tuns32,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tuns32,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tuns32,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tuns32,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tuns32,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tuns32,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tuns32,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tuns32,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tint64,Tint64, Tint64,Tint64, Tint64) + X(Tint64,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tint64,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tint64,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tint64,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tint64,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tint64,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tint64,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tint64,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tint64,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tint64,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tuns64,Tuns64, Tuns64,Tuns64, Tuns64) + + X(Tuns64,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tuns64,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tuns64,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + X(Tuns64,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tuns64,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tuns64,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + X(Tuns64,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tuns64,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tuns64,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tfloat32,Tfloat32, Tfloat32,Tfloat32, Tfloat32) + X(Tfloat32,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tfloat32,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + + X(Tfloat32,Timaginary32, Tfloat32,Timaginary32, Tfloat32) + X(Tfloat32,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tfloat32,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + + X(Tfloat32,Tcomplex32, Tfloat32,Tcomplex32, Tcomplex32) + X(Tfloat32,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tfloat32,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tfloat64,Tfloat64, Tfloat64,Tfloat64, Tfloat64) + X(Tfloat64,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + + X(Tfloat64,Timaginary32, Tfloat64,Timaginary64, Tfloat64) + X(Tfloat64,Timaginary64, Tfloat64,Timaginary64, Tfloat64) + X(Tfloat64,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + + X(Tfloat64,Tcomplex32, Tfloat64,Tcomplex64, Tcomplex64) + X(Tfloat64,Tcomplex64, Tfloat64,Tcomplex64, Tcomplex64) + X(Tfloat64,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tfloat80,Tfloat80, Tfloat80,Tfloat80, Tfloat80) + + X(Tfloat80,Timaginary32, Tfloat80,Timaginary80, Tfloat80) + X(Tfloat80,Timaginary64, Tfloat80,Timaginary80, Tfloat80) + X(Tfloat80,Timaginary80, Tfloat80,Timaginary80, Tfloat80) + + X(Tfloat80,Tcomplex32, Tfloat80,Tcomplex80, Tcomplex80) + X(Tfloat80,Tcomplex64, Tfloat80,Tcomplex80, Tcomplex80) + X(Tfloat80,Tcomplex80, Tfloat80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Timaginary32,Timaginary32, Timaginary32,Timaginary32, Timaginary32) + X(Timaginary32,Timaginary64, Timaginary64,Timaginary64, Timaginary64) + X(Timaginary32,Timaginary80, Timaginary80,Timaginary80, Timaginary80) + + X(Timaginary32,Tcomplex32, Timaginary32,Tcomplex32, Tcomplex32) + X(Timaginary32,Tcomplex64, Timaginary64,Tcomplex64, Tcomplex64) + X(Timaginary32,Tcomplex80, Timaginary80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Timaginary64,Timaginary64, Timaginary64,Timaginary64, Timaginary64) + X(Timaginary64,Timaginary80, Timaginary80,Timaginary80, Timaginary80) + + X(Timaginary64,Tcomplex32, Timaginary64,Tcomplex64, Tcomplex64) + X(Timaginary64,Tcomplex64, Timaginary64,Tcomplex64, Tcomplex64) + X(Timaginary64,Tcomplex80, Timaginary80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Timaginary80,Timaginary80, Timaginary80,Timaginary80, Timaginary80) + + X(Timaginary80,Tcomplex32, Timaginary80,Tcomplex80, Tcomplex80) + X(Timaginary80,Tcomplex64, Timaginary80,Tcomplex80, Tcomplex80) + X(Timaginary80,Tcomplex80, Timaginary80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tcomplex32,Tcomplex32, Tcomplex32,Tcomplex32, Tcomplex32) + X(Tcomplex32,Tcomplex64, Tcomplex64,Tcomplex64, Tcomplex64) + X(Tcomplex32,Tcomplex80, Tcomplex80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tcomplex64,Tcomplex64, Tcomplex64,Tcomplex64, Tcomplex64) + X(Tcomplex64,Tcomplex80, Tcomplex80,Tcomplex80, Tcomplex80) + + /* ======================= */ + + X(Tcomplex80,Tcomplex80, Tcomplex80,Tcomplex80, Tcomplex80) + +#undef X + +#define Y(t1,t2) impcnvWarn[t1][t2] = 1; + + Y(Tuns8, Tint8) + Y(Tint16, Tint8) + Y(Tuns16, Tint8) + Y(Tint32, Tint8) + Y(Tuns32, Tint8) + Y(Tint64, Tint8) + Y(Tuns64, Tint8) + + Y(Tint8, Tuns8) + Y(Tint16, Tuns8) + Y(Tuns16, Tuns8) + Y(Tint32, Tuns8) + Y(Tuns32, Tuns8) + Y(Tint64, Tuns8) + Y(Tuns64, Tuns8) + + Y(Tint8, Tchar) + Y(Tint16, Tchar) + Y(Tuns16, Tchar) + Y(Tint32, Tchar) + Y(Tuns32, Tchar) + Y(Tint64, Tchar) + Y(Tuns64, Tchar) + + Y(Tuns16, Tint16) + Y(Tint32, Tint16) + Y(Tuns32, Tint16) + Y(Tint64, Tint16) + Y(Tuns64, Tint16) + + Y(Tint16, Tuns16) + Y(Tint32, Tuns16) + Y(Tuns32, Tuns16) + Y(Tint64, Tuns16) + Y(Tuns64, Tuns16) + + Y(Tint16, Twchar) + Y(Tint32, Twchar) + Y(Tuns32, Twchar) + Y(Tint64, Twchar) + Y(Tuns64, Twchar) + +// Y(Tuns32, Tint32) + Y(Tint64, Tint32) + Y(Tuns64, Tint32) + +// Y(Tint32, Tuns32) + Y(Tint64, Tuns32) + Y(Tuns64, Tuns32) + + Y(Tint64, Tdchar) + Y(Tuns64, Tdchar) + +// Y(Tint64, Tuns64) +// Y(Tuns64, Tint64) + + for (i = 0; i < TMAX; i++) + for (j = 0; j < TMAX; j++) + { + if (impcnvResult[i][j] == Terror) + { + impcnvResult[i][j] = impcnvResult[j][i]; + impcnvType1[i][j] = impcnvType2[j][i]; + impcnvType2[i][j] = impcnvType1[j][i]; + } + } +} + +int main() +{ FILE *fp; + int i; + int j; + + init(); + + fp = fopen("impcnvtab.c","w"); + + fprintf(fp,"// This file is generated by impcnvgen.c\n"); + fprintf(fp,"#include \"mtype.h\"\n"); + + fprintf(fp,"unsigned char Type::impcnvResult[TMAX][TMAX] =\n{\n"); + for (i = 0; i < TMAX; i++) + { + for (j = 0; j < TMAX; j++) + { + fprintf(fp, "%d,",impcnvResult[i][j]); + } + fprintf(fp, "\n"); + } + fprintf(fp,"};\n"); + + fprintf(fp,"unsigned char Type::impcnvType1[TMAX][TMAX] =\n{\n"); + for (i = 0; i < TMAX; i++) + { + for (j = 0; j < TMAX; j++) + { + fprintf(fp, "%d,",impcnvType1[i][j]); + } + fprintf(fp, "\n"); + } + fprintf(fp,"};\n"); + + fprintf(fp,"unsigned char Type::impcnvType2[TMAX][TMAX] =\n{\n"); + for (i = 0; i < TMAX; i++) + { + for (j = 0; j < TMAX; j++) + { + fprintf(fp, "%d,",impcnvType2[i][j]); + } + fprintf(fp, "\n"); + } + fprintf(fp,"};\n"); + + fprintf(fp,"unsigned char Type::impcnvWarn[TMAX][TMAX] =\n{\n"); + for (i = 0; i < TMAX; i++) + { + for (j = 0; j < TMAX; j++) + { + fprintf(fp, "%d,",impcnvWarn[i][j]); + } + fprintf(fp, "\n"); + } + fprintf(fp,"};\n"); + + fclose(fp); + return EXIT_SUCCESS; +} diff --git a/imphint.c b/imphint.c new file mode 100644 index 00000000..09b057d8 --- /dev/null +++ b/imphint.c @@ -0,0 +1,88 @@ + + +// Compiler implementation of the D programming language +// Copyright (c) 2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include + +#include "mars.h" + +/****************************************** + * Looks for undefined identifier s to see + * if it might be undefined because an import + * was not specified. + * Not meant to be a comprehensive list of names in each module, + * just the most common ones. + */ + +const char *importHint(const char *s) +{ +#if DMDV1 + static const char *modules[] = + { "std.c.stdio", + "std.stdio", + "std.math", + "std.c.stdarg", + }; + static const char *names[] = + { + "printf", NULL, + "writefln", NULL, + "sin", "cos", "sqrt", "fabs", NULL, + "__va_argsave_t", NULL, + }; +#else + static const char *modules[] = + { "core.stdc.stdio", + "std.stdio", + "std.math", + "core.vararg", + }; + static const char *names[] = + { + "printf", NULL, + "writeln", NULL, + "sin", "cos", "sqrt", "fabs", NULL, + "__va_argsave_t", NULL, + }; +#endif + int m = 0; + for (int n = 0; n < sizeof(names)/sizeof(names[0]); n++) + { + const char *p = names[n]; + if (p == NULL) + { m++; + continue; + } + assert(m < sizeof(modules)/sizeof(modules[0])); + if (strcmp(s, p) == 0) + return modules[m]; + } + return NULL; // didn't find it +} + +#if UNITTEST + +void unittest_importHint() +{ + const char *p; + + p = importHint("printf"); + assert(p); + p = importHint("fabs"); + assert(p); + p = importHint("xxxxx"); + assert(!p); +} + +#endif diff --git a/import.c b/import.c new file mode 100644 index 00000000..bd43af90 --- /dev/null +++ b/import.c @@ -0,0 +1,397 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "dsymbol.h" +#include "import.h" +#include "identifier.h" +#include "module.h" +#include "scope.h" +#include "hdrgen.h" +#include "mtype.h" +#include "declaration.h" +#include "id.h" +#include "attrib.h" + +/********************************* Import ****************************/ + +Import::Import(Loc loc, Identifiers *packages, Identifier *id, Identifier *aliasId, + int isstatic) + : Dsymbol(NULL) +{ + assert(id); + this->loc = loc; + this->packages = packages; + this->id = id; + this->aliasId = aliasId; + this->isstatic = isstatic; + this->protection = PROTprivate; // default to private + this->pkg = NULL; + this->mod = NULL; + + // Set symbol name (bracketed) + // import [cstdio] = std.stdio; + if (aliasId) + this->ident = aliasId; + // import [std].stdio; + else if (packages && packages->dim) + this->ident = packages->tdata()[0]; + // import [foo]; + else + this->ident = id; +} + +void Import::addAlias(Identifier *name, Identifier *alias) +{ + if (isstatic) + error("cannot have an import bind list"); + + if (!aliasId) + this->ident = NULL; // make it an anonymous import + + names.push(name); + aliases.push(alias); +} + +const char *Import::kind() +{ + return isstatic ? (char *)"static import" : (char *)"import"; +} + +enum PROT Import::prot() +{ + return protection; +} + +Dsymbol *Import::syntaxCopy(Dsymbol *s) +{ + assert(!s); + + Import *si; + + si = new Import(loc, packages, id, aliasId, isstatic); + + for (size_t i = 0; i < names.dim; i++) + { + si->addAlias(names.tdata()[i], aliases.tdata()[i]); + } + + return si; +} + +void Import::load(Scope *sc) +{ + //printf("Import::load('%s')\n", toChars()); + + // See if existing module + DsymbolTable *dst = Package::resolve(packages, NULL, &pkg); + + Dsymbol *s = dst->lookup(id); + if (s) + { +#if TARGET_NET + mod = (Module *)s; +#else + if (s->isModule()) + mod = (Module *)s; + else + error("package and module have the same name"); +#endif + } + + if (!mod) + { + // Load module + mod = Module::load(loc, packages, id); + dst->insert(id, mod); // id may be different from mod->ident, + // if so then insert alias + if (!mod->importedFrom) + mod->importedFrom = sc ? sc->module->importedFrom : Module::rootModule; + } + if (!pkg) + pkg = mod; + + //printf("-Import::load('%s'), pkg = %p\n", toChars(), pkg); +} + +void escapePath(OutBuffer *buf, const char *fname) +{ + while (1) + { + switch (*fname) + { + case 0: + return; + case '(': + case ')': + case '\\': + buf->writebyte('\\'); + default: + buf->writebyte(*fname); + break; + } + fname++; + } +} + +void Import::importAll(Scope *sc) +{ + if (!mod) + { + load(sc); + mod->importAll(0); + + if (!isstatic && !aliasId && !names.dim) + { + if (sc->explicitProtection) + protection = sc->protection; + sc->scopesym->importScope(mod, protection); + } + } +} + +void Import::semantic(Scope *sc) +{ + //printf("Import::semantic('%s')\n", toChars()); + + // Load if not already done so + if (!mod) + { load(sc); + mod->importAll(0); + } + + if (mod) + { +#if 0 + if (mod->loc.linnum != 0) + { /* If the line number is not 0, then this is not + * a 'root' module, i.e. it was not specified on the command line. + */ + mod->importedFrom = sc->module->importedFrom; + assert(mod->importedFrom); + } +#endif + + // Modules need a list of each imported module + //printf("%s imports %s\n", sc->module->toChars(), mod->toChars()); + sc->module->aimports.push(mod); + + if (!isstatic && !aliasId && !names.dim) + { + if (sc->explicitProtection) + protection = sc->protection; + for (Scope *scd = sc; scd; scd = scd->enclosing) + { + if (scd->scopesym) + { + scd->scopesym->importScope(mod, protection); + break; + } + } + } + + mod->semantic(); + + if (mod->needmoduleinfo) + { //printf("module4 %s because of %s\n", sc->module->toChars(), mod->toChars()); + sc->module->needmoduleinfo = 1; + } + + sc = sc->push(mod); + /* BUG: Protection checks can't be enabled yet. The issue is + * that Dsymbol::search errors before overload resolution. + */ +#if 0 + sc->protection = protection; +#else + sc->protection = PROTpublic; +#endif + for (size_t i = 0; i < aliasdecls.dim; i++) + { Dsymbol *s = aliasdecls.tdata()[i]; + + //printf("\tImport alias semantic('%s')\n", s->toChars()); + if (!mod->search(loc, names.tdata()[i], 0)) + error("%s not found", (names.tdata()[i])->toChars()); + + s->semantic(sc); + } + sc = sc->pop(); + } + + if (global.params.moduleDeps != NULL) + { + /* The grammar of the file is: + * ImportDeclaration + * ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> " + * ModuleAliasIdentifier ] "\n" + * + * BasicImportDeclaration + * ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection + * " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")" + * + * FilePath + * - any string with '(', ')' and '\' escaped with the '\' character + */ + + OutBuffer *ob = global.params.moduleDeps; + + ob->writestring(sc->module->toPrettyChars()); + ob->writestring(" ("); + escapePath(ob, sc->module->srcfile->toChars()); + ob->writestring(") : "); + + ProtDeclaration::protectionToCBuffer(ob, sc->protection); + if (isstatic) + StorageClassDeclaration::stcToCBuffer(ob, STCstatic); + ob->writestring(": "); + + if (packages) + { + for (size_t i = 0; i < packages->dim; i++) + { + Identifier *pid = packages->tdata()[i]; + ob->printf("%s.", pid->toChars()); + } + } + + ob->writestring(id->toChars()); + ob->writestring(" ("); + if (mod) + escapePath(ob, mod->srcfile->toChars()); + else + ob->writestring("???"); + ob->writebyte(')'); + + for (size_t i = 0; i < names.dim; i++) + { + if (i == 0) + ob->writebyte(':'); + else + ob->writebyte(','); + + Identifier *name = names.tdata()[i]; + Identifier *alias = aliases.tdata()[i]; + + if (!alias) + { + ob->printf("%s", name->toChars()); + alias = name; + } + else + ob->printf("%s=%s", alias->toChars(), name->toChars()); + } + + if (aliasId) + ob->printf(" -> %s", aliasId->toChars()); + + ob->writenl(); + } + + //printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg); +} + +void Import::semantic2(Scope *sc) +{ + //printf("Import::semantic2('%s')\n", toChars()); + mod->semantic2(); + if (mod->needmoduleinfo) + { //printf("module5 %s because of %s\n", sc->module->toChars(), mod->toChars()); + sc->module->needmoduleinfo = 1; + } +} + +Dsymbol *Import::toAlias() +{ + if (aliasId) + return mod; + return this; +} + +/***************************** + * Add import to sd's symbol table. + */ + +int Import::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + int result = 0; + + if (names.dim == 0) + return Dsymbol::addMember(sc, sd, memnum); + + if (aliasId) + result = Dsymbol::addMember(sc, sd, memnum); + + /* Instead of adding the import to sd's symbol table, + * add each of the alias=name pairs + */ + for (size_t i = 0; i < names.dim; i++) + { + Identifier *name = names.tdata()[i]; + Identifier *alias = aliases.tdata()[i]; + + if (!alias) + alias = name; + + TypeIdentifier *tname = new TypeIdentifier(loc, name); + AliasDeclaration *ad = new AliasDeclaration(loc, alias, tname); + result |= ad->addMember(sc, sd, memnum); + + aliasdecls.push(ad); + } + + return result; +} + +Dsymbol *Import::search(Loc loc, Identifier *ident, int flags) +{ + //printf("%s.Import::search(ident = '%s', flags = x%x)\n", toChars(), ident->toChars(), flags); + + if (!pkg) + { load(NULL); + mod->semantic(); + } + + // Forward it to the package/module + return pkg->search(loc, ident, flags); +} + +int Import::overloadInsert(Dsymbol *s) +{ + // Allow multiple imports of the same name + return s->isImport() != NULL; +} + +void Import::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (hgs->hdrgen && id == Id::object) + return; // object is imported by default + + if (isstatic) + buf->writestring("static "); + buf->writestring("import "); + if (aliasId) + { + buf->printf("%s = ", aliasId->toChars()); + } + if (packages && packages->dim) + { + for (size_t i = 0; i < packages->dim; i++) + { Identifier *pid = packages->tdata()[i]; + + buf->printf("%s.", pid->toChars()); + } + } + buf->printf("%s;", id->toChars()); + buf->writenl(); +} + diff --git a/import.h b/import.h new file mode 100644 index 00000000..a3ef1a55 --- /dev/null +++ b/import.h @@ -0,0 +1,66 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2007 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_IMPORT_H +#define DMD_IMPORT_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "dsymbol.h" + + +struct Identifier; +struct Scope; +struct OutBuffer; +struct Module; +struct Package; +struct AliasDeclaration; +struct HdrGenState; + +struct Import : Dsymbol +{ + Identifiers *packages; // array of Identifier's representing packages + Identifier *id; // module Identifier + Identifier *aliasId; + int isstatic; // !=0 if static import + enum PROT protection; + + // Pairs of alias=name to bind into current namespace + Identifiers names; + Identifiers aliases; + + AliasDeclarations aliasdecls; // AliasDeclarations for names/aliases + + Module *mod; + Package *pkg; // leftmost package/module + + Import(Loc loc, Identifiers *packages, Identifier *id, Identifier *aliasId, + int isstatic); + void addAlias(Identifier *name, Identifier *alias); + + const char *kind(); + enum PROT prot(); + Dsymbol *syntaxCopy(Dsymbol *s); // copy only syntax trees + void load(Scope *sc); + void importAll(Scope *sc); + void semantic(Scope *sc); + void semantic2(Scope *sc); + Dsymbol *toAlias(); + int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + Dsymbol *search(Loc loc, Identifier *ident, int flags); + int overloadInsert(Dsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Import *isImport() { return this; } +}; + +#endif /* DMD_IMPORT_H */ diff --git a/inifile.c b/inifile.c new file mode 100644 index 00000000..7343c124 --- /dev/null +++ b/inifile.c @@ -0,0 +1,332 @@ +/* + * Some portions copyright (c) 1994-1995 by Symantec + * Copyright (c) 1999-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * Written by Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include +#include +#include +#include + +#if _WIN32 +#include +#endif + +#if __APPLE__ +#include +#endif + +#if __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +// for PATH_MAX +#include +#endif + +#if __sun&&__SVR4 +#include +#endif + +#include "root.h" +#include "rmem.h" + +#define LOG 0 + +char *skipspace(const char *p); + +#if __GNUC__ +char *strupr(char *s) +{ + char *t = s; + + while (*s) + { + *s = toupper(*s); + s++; + } + + return t; +} +#endif + +/***************************** + * Read and analyze .ini file. + * Input: + * argv0 program name (argv[0]) + * inifile .ini file name + * Returns: + * file name of ini file + * Note: this is a memory leak + */ + +const char *inifile(const char *argv0x, const char *inifilex) +{ + char *argv0 = (char *)argv0x; + char *inifile = (char *)inifilex; // do const-correct later + char *path; // need path for @P macro + char *filename; + OutBuffer buf; + int envsection = 0; + +#if LOG + printf("inifile(argv0 = '%s', inifile = '%s')\n", argv0, inifile); +#endif + if (FileName::absolute(inifile)) + { + filename = inifile; + } + else + { + /* Look for inifile in the following sequence of places: + * o current directory + * o home directory + * o directory off of argv0 + * o /etc/ + */ + if (FileName::exists(inifile)) + { + filename = inifile; + } + else + { + filename = FileName::combine(getenv("HOME"), inifile); + if (!FileName::exists(filename)) + { +#if _WIN32 // This fix by Tim Matthews + char resolved_name[MAX_PATH + 1]; + if(GetModuleFileName(NULL, resolved_name, MAX_PATH + 1) && FileName::exists(resolved_name)) + { + filename = (char *)FileName::replaceName(resolved_name, inifile); + if(FileName::exists(filename)) + goto Ldone; + } +#endif + filename = (char *)FileName::replaceName(argv0, inifile); + if (!FileName::exists(filename)) + { +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#if __GLIBC__ || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 // This fix by Thomas Kuehne + /* argv0 might be a symbolic link, + * so try again looking past it to the real path + */ +#if __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + char resolved_name[PATH_MAX + 1]; + char* real_argv0 = realpath(argv0, resolved_name); +#else + char* real_argv0 = realpath(argv0, NULL); +#endif + //printf("argv0 = %s, real_argv0 = %p\n", argv0, real_argv0); + if (real_argv0) + { + filename = (char *)FileName::replaceName(real_argv0, inifile); +#if linux + free(real_argv0); +#endif + if (FileName::exists(filename)) + goto Ldone; + } +#else +#error use of glibc non-standard extension realpath(char*, NULL) +#endif + if (1){ + // Search PATH for argv0 + const char *p = getenv("PATH"); +#if LOG + printf("\tPATH='%s'\n", p); +#endif + Strings *paths = FileName::splitPath(p); + filename = FileName::searchPath(paths, argv0, 0); + if (!filename) + goto Letc; // argv0 not found on path + filename = (char *)FileName::replaceName(filename, inifile); + if (FileName::exists(filename)) + goto Ldone; + } + // Search /etc/ for inifile + Letc: +#endif + filename = FileName::combine((char *)"/etc/", inifile); + + Ldone: + ; + } + } + } + } + path = FileName::path(filename); +#if LOG + printf("\tpath = '%s', filename = '%s'\n", path, filename); +#endif + + File file(filename); + + if (file.read()) + return filename; // error reading file + + // Parse into lines + int eof = 0; + for (size_t i = 0; i < file.len && !eof; i++) + { + size_t linestart = i; + + for (; i < file.len; i++) + { + switch (file.buffer[i]) + { + case '\r': + break; + + case '\n': + // Skip if it was preceded by '\r' + if (i && file.buffer[i - 1] == '\r') + goto Lskip; + break; + + case 0: + case 0x1A: + eof = 1; + break; + + default: + continue; + } + break; + } + + // The line is file.buffer[linestart..i] + char *line; + size_t len; + char *p; + char *pn; + + line = (char *)&file.buffer[linestart]; + len = i - linestart; + + buf.reset(); + + // First, expand the macros. + // Macros are bracketed by % characters. + + for (size_t k = 0; k < len; k++) + { + if (line[k] == '%') + { + for (size_t j = k + 1; j < len; j++) + { + if (line[j] == '%') + { + if (j - k == 3 && memicmp(&line[k + 1], "@P", 2) == 0) + { + // %@P% is special meaning the path to the .ini file + p = path; + if (!*p) + p = (char *)"."; + } + else + { size_t len2 = j - k; + char tmp[10]; // big enough most of the time + + if (len2 <= sizeof(tmp)) + p = tmp; + else + p = (char *)alloca(len2); + len2--; + memcpy(p, &line[k + 1], len2); + p[len2] = 0; + strupr(p); + p = getenv(p); + if (!p) + p = (char *)""; + } + buf.writestring(p); + k = j; + goto L1; + } + } + } + buf.writeByte(line[k]); + L1: + ; + } + + // Remove trailing spaces + while (buf.offset && isspace(buf.data[buf.offset - 1])) + buf.offset--; + + p = buf.toChars(); + + // The expanded line is in p. + // Now parse it for meaning. + + p = skipspace(p); + switch (*p) + { + case ';': // comment + case 0: // blank + break; + + case '[': // look for [Environment] + p = skipspace(p + 1); + for (pn = p; isalnum((unsigned char)*pn); pn++) + ; + if (pn - p == 11 && + memicmp(p, "Environment", 11) == 0 && + *skipspace(pn) == ']' + ) + envsection = 1; + else + envsection = 0; + break; + + default: + if (envsection) + { + pn = p; + + // Convert name to upper case; + // remove spaces bracketing = + for (p = pn; *p; p++) + { if (islower((unsigned char)*p)) + *p &= ~0x20; + else if (isspace((unsigned char)*p)) + memmove(p, p + 1, strlen(p)); + else if (*p == '=') + { + p++; + while (isspace((unsigned char)*p)) + memmove(p, p + 1, strlen(p)); + break; + } + } + + putenv(strdup(pn)); +#if LOG + printf("\tputenv('%s')\n", pn); + //printf("getenv(\"TEST\") = '%s'\n",getenv("TEST")); +#endif + } + break; + } + + Lskip: + ; + } + return filename; +} + +/******************** + * Skip spaces. + */ + +char *skipspace(const char *p) +{ + while (isspace((unsigned char)*p)) + p++; + return (char *)p; +} + diff --git a/init.c b/init.c new file mode 100644 index 00000000..d18c434c --- /dev/null +++ b/init.c @@ -0,0 +1,897 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "init.h" +#include "expression.h" +#include "statement.h" +#include "identifier.h" +#include "declaration.h" +#include "aggregate.h" +#include "scope.h" +#include "mtype.h" +#include "hdrgen.h" + +/********************************** Initializer *******************************/ + +Initializer::Initializer(Loc loc) +{ + this->loc = loc; +} + +Initializer *Initializer::syntaxCopy() +{ + return this; +} + +Initializer *Initializer::semantic(Scope *sc, Type *t, int needInterpret) +{ + return this; +} + +Type *Initializer::inferType(Scope *sc) +{ + error(loc, "cannot infer type from initializer"); + return Type::terror; +} + +Initializers *Initializer::arraySyntaxCopy(Initializers *ai) +{ Initializers *a = NULL; + + if (ai) + { + a = new Initializers(); + a->setDim(ai->dim); + for (size_t i = 0; i < a->dim; i++) + { Initializer *e = ai->tdata()[i]; + + e = e->syntaxCopy(); + a->tdata()[i] = e; + } + } + return a; +} + +char *Initializer::toChars() +{ OutBuffer *buf; + HdrGenState hgs; + + memset(&hgs, 0, sizeof(hgs)); + buf = new OutBuffer(); + toCBuffer(buf, &hgs); + return buf->toChars(); +} + +/********************************** VoidInitializer ***************************/ + +VoidInitializer::VoidInitializer(Loc loc) + : Initializer(loc) +{ + type = NULL; +} + + +Initializer *VoidInitializer::syntaxCopy() +{ + return new VoidInitializer(loc); +} + + +Initializer *VoidInitializer::semantic(Scope *sc, Type *t, int needInterpret) +{ + //printf("VoidInitializer::semantic(t = %p)\n", t); + type = t; + return this; +} + + +Expression *VoidInitializer::toExpression() +{ + error(loc, "void initializer has no value"); + return new IntegerExp(0); +} + + +void VoidInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("void"); +} + + +/********************************** StructInitializer *************************/ + +StructInitializer::StructInitializer(Loc loc) + : Initializer(loc) +{ + ad = NULL; +} + +Initializer *StructInitializer::syntaxCopy() +{ + StructInitializer *ai = new StructInitializer(loc); + + assert(field.dim == value.dim); + ai->field.setDim(field.dim); + ai->value.setDim(value.dim); + for (size_t i = 0; i < field.dim; i++) + { + ai->field.tdata()[i] = field.tdata()[i]; + + Initializer *init = value.tdata()[i]; + init = init->syntaxCopy(); + ai->value.tdata()[i] = init; + } + return ai; +} + +void StructInitializer::addInit(Identifier *field, Initializer *value) +{ + //printf("StructInitializer::addInit(field = %p, value = %p)\n", field, value); + this->field.push(field); + this->value.push(value); +} + +Initializer *StructInitializer::semantic(Scope *sc, Type *t, int needInterpret) +{ + int errors = 0; + + //printf("StructInitializer::semantic(t = %s) %s\n", t->toChars(), toChars()); + vars.setDim(field.dim); + t = t->toBasetype(); + if (t->ty == Tstruct) + { + unsigned fieldi = 0; + + TypeStruct *ts = (TypeStruct *)t; + ad = ts->sym; + if (ad->ctor) + error(loc, "%s %s has constructors, cannot use { initializers }, use %s( initializers ) instead", + ad->kind(), ad->toChars(), ad->toChars()); + size_t nfields = ad->fields.dim; + if (((StructDeclaration *)ad)->isnested) nfields--; + for (size_t i = 0; i < field.dim; i++) + { + Identifier *id = field.tdata()[i]; + Initializer *val = value.tdata()[i]; + Dsymbol *s; + VarDeclaration *v; + + if (id == NULL) + { + if (fieldi >= nfields) + { error(loc, "too many initializers for %s", ad->toChars()); + errors = 1; + field.remove(i); + i--; + continue; + } + else + { + s = ad->fields.tdata()[fieldi]; + } + } + else + { + //s = ad->symtab->lookup(id); + s = ad->search(loc, id, 0); + if (!s) + { + error(loc, "'%s' is not a member of '%s'", id->toChars(), t->toChars()); + errors = 1; + continue; + } + s = s->toAlias(); + + // Find out which field index it is + for (fieldi = 0; 1; fieldi++) + { + if (fieldi >= nfields) + { + error(loc, "%s.%s is not a per-instance initializable field", + t->toChars(), s->toChars()); + errors = 1; + break; + } + if (s == ad->fields.tdata()[fieldi]) + break; + } + } + if (s && (v = s->isVarDeclaration()) != NULL) + { + val = val->semantic(sc, v->type, needInterpret); + value.tdata()[i] = val; + vars.tdata()[i] = v; + } + else + { error(loc, "%s is not a field of %s", id ? id->toChars() : s->toChars(), ad->toChars()); + errors = 1; + } + fieldi++; + } + } + else if (t->ty == Tdelegate && value.dim == 0) + { /* Rewrite as empty delegate literal { } + */ + Parameters *arguments = new Parameters; + Type *tf = new TypeFunction(arguments, NULL, 0, LINKd); + FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(loc, 0, tf, TOKdelegate, NULL); + fd->fbody = new CompoundStatement(loc, new Statements()); + fd->endloc = loc; + Expression *e = new FuncExp(loc, fd); + ExpInitializer *ie = new ExpInitializer(loc, e); + return ie->semantic(sc, t, needInterpret); + } + else + { + error(loc, "a struct is not a valid initializer for a %s", t->toChars()); + errors = 1; + } + if (errors) + { + field.setDim(0); + value.setDim(0); + vars.setDim(0); + } + return this; +} + +/*************************************** + * This works by transforming a struct initializer into + * a struct literal. In the future, the two should be the + * same thing. + */ +Expression *StructInitializer::toExpression() +{ Expression *e; + size_t offset; + + //printf("StructInitializer::toExpression() %s\n", toChars()); + if (!ad) // if fwd referenced + { + return NULL; + } + StructDeclaration *sd = ad->isStructDeclaration(); + if (!sd) + return NULL; + Expressions *elements = new Expressions(); + size_t nfields = ad->fields.dim; +#if DMDV2 + if (sd->isnested) + nfields--; +#endif + elements->setDim(nfields); + for (size_t i = 0; i < elements->dim; i++) + { + elements->tdata()[i] = NULL; + } + unsigned fieldi = 0; + for (size_t i = 0; i < value.dim; i++) + { + Identifier *id = field.tdata()[i]; + if (id) + { + Dsymbol * s = ad->search(loc, id, 0); + if (!s) + { + error(loc, "'%s' is not a member of '%s'", id->toChars(), sd->toChars()); + goto Lno; + } + s = s->toAlias(); + + // Find out which field index it is + for (fieldi = 0; 1; fieldi++) + { + if (fieldi >= nfields) + { + s->error("is not a per-instance initializable field"); + goto Lno; + } + if (s == ad->fields.tdata()[fieldi]) + break; + } + } + else if (fieldi >= nfields) + { error(loc, "too many initializers for '%s'", ad->toChars()); + goto Lno; + } + Initializer *iz = value.tdata()[i]; + if (!iz) + goto Lno; + Expression *ex = iz->toExpression(); + if (!ex) + goto Lno; + if (elements->tdata()[fieldi]) + { error(loc, "duplicate initializer for field '%s'", + ad->fields.tdata()[fieldi]->toChars()); + goto Lno; + } + elements->tdata()[fieldi] = ex; + ++fieldi; + } + // Now, fill in any missing elements with default initializers. + // We also need to validate any anonymous unions + offset = 0; + for (size_t i = 0; i < elements->dim; ) + { + VarDeclaration * vd = ad->fields.tdata()[i]->isVarDeclaration(); + + //printf("test2 [%d] : %s %d %d\n", i, vd->toChars(), (int)offset, (int)vd->offset); + if (vd->offset < offset) + { + // Only the first field of a union can have an initializer + if (elements->tdata()[i]) + goto Lno; + } + else + { + if (!elements->tdata()[i]) + // Default initialize + elements->tdata()[i] = vd->type->defaultInit(); + } + offset = vd->offset + vd->type->size(); + i++; +#if 0 + int unionSize = ad->numFieldsInUnion(i); + if (unionSize == 1) + { // Not a union -- default initialize if missing + if (!elements->tdata()[i]) + elements->tdata()[i] = vd->type->defaultInit(); + } + else + { // anonymous union -- check for errors + int found = -1; // index of the first field with an initializer + for (int j = i; j < i + unionSize; ++j) + { + if (!elements->tdata()[j]) + continue; + if (found >= 0) + { + VarDeclaration * v1 = ((Dsymbol *)ad->fields.data[found])->isVarDeclaration(); + VarDeclaration * v = ((Dsymbol *)ad->fields.data[j])->isVarDeclaration(); + error(loc, "%s cannot have initializers for fields %s and %s in same union", + ad->toChars(), + v1->toChars(), v->toChars()); + goto Lno; + } + found = j; + } + if (found == -1) + { + error(loc, "no initializer for union that contains field %s", + vd->toChars()); + goto Lno; + } + } + i += unionSize; +#endif + } + e = new StructLiteralExp(loc, sd, elements); + e->type = sd->type; + return e; + +Lno: + delete elements; + return NULL; +} + + +void StructInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + //printf("StructInitializer::toCBuffer()\n"); + buf->writebyte('{'); + for (size_t i = 0; i < field.dim; i++) + { + if (i > 0) + buf->writebyte(','); + Identifier *id = field.tdata()[i]; + if (id) + { + buf->writestring(id->toChars()); + buf->writebyte(':'); + } + Initializer *iz = value.tdata()[i]; + if (iz) + iz->toCBuffer(buf, hgs); + } + buf->writebyte('}'); +} + +/********************************** ArrayInitializer ************************************/ + +ArrayInitializer::ArrayInitializer(Loc loc) + : Initializer(loc) +{ + dim = 0; + type = NULL; + sem = 0; +} + +Initializer *ArrayInitializer::syntaxCopy() +{ + //printf("ArrayInitializer::syntaxCopy()\n"); + + ArrayInitializer *ai = new ArrayInitializer(loc); + + assert(index.dim == value.dim); + ai->index.setDim(index.dim); + ai->value.setDim(value.dim); + for (size_t i = 0; i < ai->value.dim; i++) + { Expression *e = index.tdata()[i]; + if (e) + e = e->syntaxCopy(); + ai->index.tdata()[i] = e; + + Initializer *init = value.tdata()[i]; + init = init->syntaxCopy(); + ai->value.tdata()[i] = init; + } + return ai; +} + +void ArrayInitializer::addInit(Expression *index, Initializer *value) +{ + this->index.push(index); + this->value.push(value); + dim = 0; + type = NULL; +} + +Initializer *ArrayInitializer::semantic(Scope *sc, Type *t, int needInterpret) +{ unsigned i; + unsigned length; + const unsigned amax = 0x80000000; + + //printf("ArrayInitializer::semantic(%s)\n", t->toChars()); + if (sem) // if semantic() already run + return this; + sem = 1; + type = t; + t = t->toBasetype(); + switch (t->ty) + { + case Tpointer: + case Tsarray: + case Tarray: + break; + + default: + error(loc, "cannot use array to initialize %s", type->toChars()); + goto Lerr; + } + + length = 0; + for (i = 0; i < index.dim; i++) + { + Expression *idx = index.tdata()[i]; + if (idx) + { idx = idx->semantic(sc); + idx = idx->optimize(WANTvalue | WANTinterpret); + index.tdata()[i] = idx; + length = idx->toInteger(); + } + + Initializer *val = value.tdata()[i]; + val = val->semantic(sc, t->nextOf(), needInterpret); + value.tdata()[i] = val; + length++; + if (length == 0) + { error(loc, "array dimension overflow"); + goto Lerr; + } + if (length > dim) + dim = length; + } + if (t->ty == Tsarray) + { + dinteger_t edim = ((TypeSArray *)t)->dim->toInteger(); + if (dim > edim) + { + error(loc, "array initializer has %u elements, but array length is %jd", dim, edim); + goto Lerr; + } + } + + if ((unsigned long) dim * t->nextOf()->size() >= amax) + { error(loc, "array dimension %u exceeds max of %u", dim, amax / t->nextOf()->size()); + goto Lerr; + } + return this; + +Lerr: + return new ExpInitializer(loc, new ErrorExp()); +} + +/******************************** + * If possible, convert array initializer to array literal. + * Otherwise return NULL. + */ + +Expression *ArrayInitializer::toExpression() +{ Expressions *elements; + + //printf("ArrayInitializer::toExpression(), dim = %d\n", dim); + //static int i; if (++i == 2) halt(); + + size_t edim; + Type *t = NULL; + if (type) + { + if (type == Type::terror) + return new ErrorExp(); + + t = type->toBasetype(); + switch (t->ty) + { + case Tsarray: + edim = ((TypeSArray *)t)->dim->toInteger(); + break; + + case Tpointer: + case Tarray: + edim = dim; + break; + + default: + assert(0); + } + } + else + { + edim = value.dim; + for (size_t i = 0, j = 0; i < value.dim; i++, j++) + { + if (index.tdata()[i]) + j = index.tdata()[i]->toInteger(); + if (j >= edim) + edim = j + 1; + } + } + + elements = new Expressions(); + elements->setDim(edim); + elements->zero(); + for (size_t i = 0, j = 0; i < value.dim; i++, j++) + { + if (index.tdata()[i]) + j = (index.tdata()[i])->toInteger(); + assert(j < edim); + Initializer *iz = value.tdata()[i]; + if (!iz) + goto Lno; + Expression *ex = iz->toExpression(); + if (!ex) + { + goto Lno; + } + elements->tdata()[j] = ex; + } + + /* Fill in any missing elements with the default initializer + */ + { + Expression *init = NULL; + for (size_t i = 0; i < edim; i++) + { + if (!elements->tdata()[i]) + { + if (!type) + goto Lno; + if (!init) + init = ((TypeNext *)t)->next->defaultInit(); + elements->tdata()[i] = init; + } + } + + Expression *e = new ArrayLiteralExp(loc, elements); + e->type = type; + return e; + } + +Lno: + return NULL; +} + + +/******************************** + * If possible, convert array initializer to associative array initializer. + */ + +Expression *ArrayInitializer::toAssocArrayLiteral() +{ + Expression *e; + + //printf("ArrayInitializer::toAssocArrayInitializer()\n"); + //static int i; if (++i == 2) halt(); + Expressions *keys = new Expressions(); + keys->setDim(value.dim); + Expressions *values = new Expressions(); + values->setDim(value.dim); + + for (size_t i = 0; i < value.dim; i++) + { + e = index.tdata()[i]; + if (!e) + goto Lno; + keys->tdata()[i] = e; + + Initializer *iz = value.tdata()[i]; + if (!iz) + goto Lno; + e = iz->toExpression(); + if (!e) + goto Lno; + values->tdata()[i] = e; + } + e = new AssocArrayLiteralExp(loc, keys, values); + return e; + +Lno: + delete keys; + delete values; + error(loc, "not an associative array initializer"); + return new ErrorExp(); +} + +int ArrayInitializer::isAssociativeArray() +{ + for (size_t i = 0; i < value.dim; i++) + { + if (index.tdata()[i]) + return 1; + } + return 0; +} + +Type *ArrayInitializer::inferType(Scope *sc) +{ + //printf("ArrayInitializer::inferType() %s\n", toChars()); + assert(0); + return NULL; +#if 0 + type = Type::terror; + for (size_t i = 0; i < value.dim; i++) + { + if (index.data[i]) + goto Laa; + } + for (size_t i = 0; i < value.dim; i++) + { + Initializer *iz = (Initializer *)value.data[i]; + if (iz) + { Type *t = iz->inferType(sc); + if (i == 0) + { /* BUG: This gets the type from the first element. + * Fix to use all the elements to figure out the type. + */ + t = new TypeSArray(t, new IntegerExp(value.dim)); + t = t->semantic(loc, sc); + type = t; + } + } + } + return type; + +Laa: + /* It's possibly an associative array initializer. + * BUG: inferring type from first member. + */ + Initializer *iz = (Initializer *)value.data[0]; + Expression *indexinit = (Expression *)index.data[0]; + if (iz && indexinit) + { Type *t = iz->inferType(sc); + indexinit = indexinit->semantic(sc); + Type *indext = indexinit->type; + t = new TypeAArray(t, indext); + type = t->semantic(loc, sc); + } + else + error(loc, "cannot infer type from this array initializer"); + return type; +#endif +} + + +void ArrayInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writebyte('['); + for (size_t i = 0; i < index.dim; i++) + { + if (i > 0) + buf->writebyte(','); + Expression *ex = index.tdata()[i]; + if (ex) + { + ex->toCBuffer(buf, hgs); + buf->writebyte(':'); + } + Initializer *iz = value.tdata()[i]; + if (iz) + iz->toCBuffer(buf, hgs); + } + buf->writebyte(']'); +} + + +/********************************** ExpInitializer ************************************/ + +ExpInitializer::ExpInitializer(Loc loc, Expression *exp) + : Initializer(loc) +{ + this->exp = exp; +} + +Initializer *ExpInitializer::syntaxCopy() +{ + return new ExpInitializer(loc, exp->syntaxCopy()); +} + +bool arrayHasNonConstPointers(Expressions *elems); + +bool hasNonConstPointers(Expression *e) +{ + if (e->op == TOKnull) + return false; + if (e->op == TOKstructliteral) + { + StructLiteralExp *se = (StructLiteralExp *)e; + return arrayHasNonConstPointers(se->elements); + } + if (e->op == TOKarrayliteral) + { + if (!e->type->nextOf()->hasPointers()) + return false; + ArrayLiteralExp *ae = (ArrayLiteralExp *)e; + return arrayHasNonConstPointers(ae->elements); + } + if (e->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e; + if (ae->type->nextOf()->hasPointers() && + arrayHasNonConstPointers(ae->values)) + return true; + if (((TypeAArray *)ae->type)->index->hasPointers()) + return arrayHasNonConstPointers(ae->keys); + return false; + } + if (e->type->ty== Tpointer && e->type->nextOf()->ty != Tfunction) + { + if (e->op == TOKsymoff) // address of a global is OK + return false; + if (e->op == TOKint64) // cast(void *)int is OK + return false; + if (e->op == TOKstring) // "abc".ptr is OK + return false; + return true; + } + return false; +} + +bool arrayHasNonConstPointers(Expressions *elems) +{ + for (size_t i = 0; i < elems->dim; i++) + { + if (!elems->tdata()[i]) + continue; + if (hasNonConstPointers(elems->tdata()[i])) + return true; + } + return false; +} + + + +Initializer *ExpInitializer::semantic(Scope *sc, Type *t, int needInterpret) +{ + //printf("ExpInitializer::semantic(%s), type = %s\n", exp->toChars(), t->toChars()); + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + int wantOptimize = needInterpret ? WANTinterpret|WANTvalue : WANTvalue; + + int olderrors = global.errors; + exp = exp->optimize(wantOptimize); + if (!global.gag && olderrors != global.errors) + return this; // Failed, suppress duplicate error messages + + if (exp->op == TOKtype) + error("initializer must be an expression, not '%s'", exp->toChars()); + + // Make sure all pointers are constants + if (needInterpret && hasNonConstPointers(exp)) + { + exp->error("cannot use non-constant CTFE pointer in an initializer '%s'", exp->toChars()); + return this; + } + + Type *tb = t->toBasetype(); + + /* Look for case of initializing a static array with a too-short + * string literal, such as: + * char[5] foo = "abc"; + * Allow this by doing an explicit cast, which will lengthen the string + * literal. + */ + if (exp->op == TOKstring && tb->ty == Tsarray && exp->type->ty == Tsarray) + { StringExp *se = (StringExp *)exp; + + if (!se->committed && se->type->ty == Tsarray && + ((TypeSArray *)se->type)->dim->toInteger() < + ((TypeSArray *)t)->dim->toInteger()) + { + exp = se->castTo(sc, t); + goto L1; + } + } + + // Look for the case of statically initializing an array + // with a single member. + if (tb->ty == Tsarray && + !tb->nextOf()->equals(exp->type->toBasetype()->nextOf()) && + exp->implicitConvTo(tb->nextOf()) + ) + { + t = tb->nextOf(); + } + + exp = exp->implicitCastTo(sc, t); +L1: + exp = exp->optimize(wantOptimize); + //printf("-ExpInitializer::semantic(): "); exp->print(); + return this; +} + +Type *ExpInitializer::inferType(Scope *sc) +{ + //printf("ExpInitializer::inferType() %s\n", toChars()); + if (exp->op == TOKfunction && ((FuncExp *)exp)->td) + { + exp->error("cannot infer type from ambiguous function literal %s", exp->toChars()); + return Type::terror; + } + + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + + // Give error for overloaded function addresses + if (exp->op == TOKsymoff) + { SymOffExp *se = (SymOffExp *)exp; + if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique()) + exp->error("cannot infer type from overloaded function symbol %s", exp->toChars()); + } + + // Give error for overloaded function addresses + if (exp->op == TOKdelegate) + { DelegateExp *se = (DelegateExp *)exp; + if ( + se->func->isFuncDeclaration() && + !se->func->isFuncDeclaration()->isUnique()) + exp->error("cannot infer type from overloaded function symbol %s", exp->toChars()); + } + + Type *t = exp->type; + if (!t) + t = Initializer::inferType(sc); + return t; +} + +Expression *ExpInitializer::toExpression() +{ + return exp; +} + + +void ExpInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + exp->toCBuffer(buf, hgs); +} + + + diff --git a/init.h b/init.h new file mode 100644 index 00000000..aed6cca4 --- /dev/null +++ b/init.h @@ -0,0 +1,130 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2007 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef INIT_H +#define INIT_H + +#include "root.h" + +#include "mars.h" +#include "arraytypes.h" + +struct Identifier; +struct Expression; +struct Scope; +struct Type; +struct dt_t; +struct AggregateDeclaration; +struct VoidInitializer; +struct StructInitializer; +struct ArrayInitializer; +struct ExpInitializer; +struct HdrGenState; + + +struct Initializer : Object +{ + Loc loc; + + Initializer(Loc loc); + virtual Initializer *syntaxCopy(); + // needInterpret is WANTinterpret if must be a manifest constant, 0 if not. + virtual Initializer *semantic(Scope *sc, Type *t, int needInterpret); + virtual Type *inferType(Scope *sc); + virtual Expression *toExpression() = 0; + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs) = 0; + char *toChars(); + + static Initializers *arraySyntaxCopy(Initializers *ai); + + virtual dt_t *toDt(); + + virtual VoidInitializer *isVoidInitializer() { return NULL; } + virtual StructInitializer *isStructInitializer() { return NULL; } + virtual ArrayInitializer *isArrayInitializer() { return NULL; } + virtual ExpInitializer *isExpInitializer() { return NULL; } +}; + +struct VoidInitializer : Initializer +{ + Type *type; // type that this will initialize to + + VoidInitializer(Loc loc); + Initializer *syntaxCopy(); + Initializer *semantic(Scope *sc, Type *t, int needInterpret); + Expression *toExpression(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + dt_t *toDt(); + + virtual VoidInitializer *isVoidInitializer() { return this; } +}; + +struct StructInitializer : Initializer +{ + Identifiers field; // of Identifier *'s + Initializers value; // parallel array of Initializer *'s + + VarDeclarations vars; // parallel array of VarDeclaration *'s + AggregateDeclaration *ad; // which aggregate this is for + + StructInitializer(Loc loc); + Initializer *syntaxCopy(); + void addInit(Identifier *field, Initializer *value); + Initializer *semantic(Scope *sc, Type *t, int needInterpret); + Expression *toExpression(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + dt_t *toDt(); + + StructInitializer *isStructInitializer() { return this; } +}; + +struct ArrayInitializer : Initializer +{ + Expressions index; // indices + Initializers value; // of Initializer *'s + unsigned dim; // length of array being initialized + Type *type; // type that array will be used to initialize + int sem; // !=0 if semantic() is run + + ArrayInitializer(Loc loc); + Initializer *syntaxCopy(); + void addInit(Expression *index, Initializer *value); + Initializer *semantic(Scope *sc, Type *t, int needInterpret); + int isAssociativeArray(); + Type *inferType(Scope *sc); + Expression *toExpression(); + Expression *toAssocArrayLiteral(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + dt_t *toDt(); + dt_t *toDtBit(); // for bit arrays + + ArrayInitializer *isArrayInitializer() { return this; } +}; + +struct ExpInitializer : Initializer +{ + Expression *exp; + + ExpInitializer(Loc loc, Expression *exp); + Initializer *syntaxCopy(); + Initializer *semantic(Scope *sc, Type *t, int needInterpret); + Type *inferType(Scope *sc); + Expression *toExpression(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + dt_t *toDt(); + + virtual ExpInitializer *isExpInitializer() { return this; } +}; + +#endif diff --git a/inline.c b/inline.c new file mode 100644 index 00000000..e0ebe6c1 --- /dev/null +++ b/inline.c @@ -0,0 +1,1797 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Routines to perform function inlining + +#define LOG 0 + +#include +#include +#include + +#include "id.h" +#include "init.h" +#include "declaration.h" +#include "aggregate.h" +#include "expression.h" +#include "statement.h" +#include "mtype.h" +#include "scope.h" + +/* ========== Compute cost of inlining =============== */ + +/* Walk trees to determine if inlining can be done, and if so, + * if it is too complex to be worth inlining or not. + */ + +struct InlineCostState +{ + int nested; + int hasthis; + int hdrscan; // !=0 if inline scan for 'header' content + FuncDeclaration *fd; +}; + +const int COST_MAX = 250; +const int STATEMENT_COST = 0x1000; +const int STATEMENT_COST_MAX = 250 * 0x1000; + +// STATEMENT_COST be power of 2 and greater than COST_MAX +//static assert((STATEMENT_COST & (STATEMENT_COST - 1)) == 0); +//static assert(STATEMENT_COST > COST_MAX); + +bool tooCostly(int cost) { return ((cost & (STATEMENT_COST - 1)) >= COST_MAX); } + +int expressionInlineCost(Expression *e, InlineCostState *ics); + +int Statement::inlineCost(InlineCostState *ics) +{ + //printf("Statement::inlineCost = %d\n", COST_MAX); + //printf("%p\n", isScopeStatement()); + //printf("%s\n", toChars()); + return COST_MAX; // default is we can't inline it +} + +int ExpStatement::inlineCost(InlineCostState *ics) +{ + return expressionInlineCost(exp, ics); + //return exp ? exp->inlineCost(ics) : 0; +} + +int CompoundStatement::inlineCost(InlineCostState *ics) +{ int cost = 0; + + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + cost += s->inlineCost(ics); + if (tooCostly(cost)) + break; + } + } + //printf("CompoundStatement::inlineCost = %d\n", cost); + return cost; +} + +int UnrolledLoopStatement::inlineCost(InlineCostState *ics) +{ int cost = 0; + + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + cost += s->inlineCost(ics); + if (tooCostly(cost)) + break; + } + } + return cost; +} + +int ScopeStatement::inlineCost(InlineCostState *ics) +{ + return statement ? 1 + statement->inlineCost(ics) : 1; +} + +int IfStatement::inlineCost(InlineCostState *ics) +{ + int cost; + + /* Can't declare variables inside ?: expressions, so + * we cannot inline if a variable is declared. + */ + if (arg) + return COST_MAX; + + cost = expressionInlineCost(condition, ics); + + /* Specifically allow: + * if (condition) + * return exp1; + * else + * return exp2; + * Otherwise, we can't handle return statements nested in if's. + */ + + if (elsebody && ifbody && + ifbody->isReturnStatement() && + elsebody->isReturnStatement()) + { + cost += ifbody->inlineCost(ics); + cost += elsebody->inlineCost(ics); + //printf("cost = %d\n", cost); + } + else + { + ics->nested += 1; + if (ifbody) + cost += ifbody->inlineCost(ics); + if (elsebody) + cost += elsebody->inlineCost(ics); + ics->nested -= 1; + } + //printf("IfStatement::inlineCost = %d\n", cost); + return cost; +} + +int ReturnStatement::inlineCost(InlineCostState *ics) +{ + // Can't handle return statements nested in if's + if (ics->nested) + return COST_MAX; + return expressionInlineCost(exp, ics); +} + +#if DMDV2 +int ImportStatement::inlineCost(InlineCostState *ics) +{ + return 0; +} +#endif + +int ForStatement::inlineCost(InlineCostState *ics) +{ + //return COST_MAX; + int cost = STATEMENT_COST; + if (init) + cost += init->inlineCost(ics); + if (condition) + cost += expressionInlineCost(condition, ics); + if (increment) + cost += expressionInlineCost(increment, ics); + if (body) + cost += body->inlineCost(ics); + //printf("ForStatement: inlineCost = %d\n", cost); + return cost; +} + + +/* -------------------------- */ + +struct ICS2 +{ + int cost; + InlineCostState *ics; +}; + +int lambdaInlineCost(Expression *e, void *param) +{ + ICS2 *ics2 = (ICS2 *)param; + ics2->cost += e->inlineCost3(ics2->ics); + return (ics2->cost >= COST_MAX); +} + +int expressionInlineCost(Expression *e, InlineCostState *ics) +{ + //printf("expressionInlineCost()\n"); + //e->dump(0); + ICS2 ics2; + ics2.cost = 0; + ics2.ics = ics; + if (e) + e->apply(&lambdaInlineCost, &ics2); + return ics2.cost; +} + +int Expression::inlineCost3(InlineCostState *ics) +{ + return 1; +} + +int VarExp::inlineCost3(InlineCostState *ics) +{ + //printf("VarExp::inlineCost3() %s\n", toChars()); + Type *tb = type->toBasetype(); + if (tb->ty == Tstruct) + { + StructDeclaration *sd = ((TypeStruct *)tb)->sym; + if (sd->isnested) + /* An inner struct will be nested inside another function hierarchy than where + * we're inlining into, so don't inline it. + * At least not until we figure out how to 'move' the struct to be nested + * locally. Example: + * struct S(alias pred) { void unused_func(); } + * void abc() { int w; S!(w) m; } + * void bar() { abc(); } + */ + return COST_MAX; + } + FuncDeclaration *fd = var->isFuncDeclaration(); + if (fd && fd->isNested()) // see Bugzilla 7199 for test case + return COST_MAX; + return 1; +} + +int ThisExp::inlineCost3(InlineCostState *ics) +{ + //printf("ThisExp::inlineCost3() %s\n", toChars()); + FuncDeclaration *fd = ics->fd; + if (!fd) + return COST_MAX; + if (!ics->hdrscan) + if (fd->isNested() || !ics->hasthis) + return COST_MAX; + return 1; +} + +int StructLiteralExp::inlineCost3(InlineCostState *ics) +{ + //printf("StructLiteralExp::inlineCost3() %s\n", toChars()); +#if DMDV2 + if (sd->isnested) + return COST_MAX; +#endif + return 1; +} + +int FuncExp::inlineCost3(InlineCostState *ics) +{ + //printf("FuncExp::inlineCost3()\n"); + // Right now, this makes the function be output to the .obj file twice. + return COST_MAX; +} + +int DelegateExp::inlineCost3(InlineCostState *ics) +{ + //printf("DelegateExp::inlineCost3()\n"); + return COST_MAX; +} + +int DeclarationExp::inlineCost3(InlineCostState *ics) +{ int cost = 0; + VarDeclaration *vd; + + //printf("DeclarationExp::inlineCost3()\n"); + vd = declaration->isVarDeclaration(); + if (vd) + { + TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); + if (td) + { +#if 1 + return COST_MAX; // finish DeclarationExp::doInline +#else + for (size_t i = 0; i < td->objects->dim; i++) + { Object *o = (*td->objects)[i]; + if (o->dyncast() != DYNCAST_EXPRESSION) + return COST_MAX; + Expression *eo = (Expression *)o; + if (eo->op != TOKdsymbol) + return COST_MAX; + } + return td->objects->dim; +#endif + } + if (!ics->hdrscan && vd->isDataseg()) + return COST_MAX; + cost += 1; + +#if DMDV2 + if (vd->edtor) // if destructor required + return COST_MAX; // needs work to make this work +#endif + // Scan initializer (vd->init) + if (vd->init) + { + ExpInitializer *ie = vd->init->isExpInitializer(); + + if (ie) + { + cost += expressionInlineCost(ie->exp, ics); + } + } + } + + // These can contain functions, which when copied, get output twice. + if (declaration->isStructDeclaration() || + declaration->isClassDeclaration() || + declaration->isFuncDeclaration() || + declaration->isTypedefDeclaration() || +#if DMDV2 + declaration->isAttribDeclaration() || +#endif + declaration->isTemplateMixin()) + return COST_MAX; + + //printf("DeclarationExp::inlineCost3('%s')\n", toChars()); + return cost; +} + +int CallExp::inlineCost3(InlineCostState *ics) +{ + //printf("CallExp::inlineCost3() %s\n", toChars()); + // Bugzilla 3500: super.func() calls must be devirtualized, and the inliner + // can't handle that at present. + if (e1->op == TOKdotvar && ((DotVarExp *)e1)->e1->op == TOKsuper) + return COST_MAX; + + return 1; +} + + +/* ======================== Perform the inlining ============================== */ + +/* Inlining is done by: + * o Converting to an Expression + * o Copying the trees of the function to be inlined + * o Renaming the variables + */ + +struct InlineDoState +{ + VarDeclaration *vthis; + Dsymbols from; // old Dsymbols + Dsymbols to; // parallel array of new Dsymbols + Dsymbol *parent; // new parent + FuncDeclaration *fd; // function being inlined (old parent) +}; + +/* -------------------------------------------------------------------- */ + +Statement *Statement::doInlineStatement(InlineDoState *ids) +{ + assert(0); + return NULL; // default is we can't inline it +} + +Statement *ExpStatement::doInlineStatement(InlineDoState *ids) +{ +#if LOG + if (exp) printf("ExpStatement::doInlineStatement() '%s'\n", exp->toChars()); +#endif + return new ExpStatement(loc, exp ? exp->doInline(ids) : NULL); +} + +Statement *CompoundStatement::doInlineStatement(InlineDoState *ids) +{ + //printf("CompoundStatement::doInlineStatement() %d\n", statements->dim); + Statements *as = new Statements(); + as->reserve(statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + as->push(s->doInlineStatement(ids)); + if (s->isReturnStatement()) + break; + + /* Check for: + * if (condition) + * return exp1; + * else + * return exp2; + */ + IfStatement *ifs = s->isIfStatement(); + if (ifs && ifs->elsebody && ifs->ifbody && + ifs->ifbody->isReturnStatement() && + ifs->elsebody->isReturnStatement() + ) + break; + } + else + as->push(NULL); + } + return new CompoundStatement(loc, as); +} + +Statement *UnrolledLoopStatement::doInlineStatement(InlineDoState *ids) +{ + //printf("UnrolledLoopStatement::doInlineStatement() %d\n", statements->dim); + Statements *as = new Statements(); + as->reserve(statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + as->push(s->doInlineStatement(ids)); + if (s->isReturnStatement()) + break; + } + else + as->push(NULL); + } + return new UnrolledLoopStatement(loc, as); +} + +Statement *ScopeStatement::doInlineStatement(InlineDoState *ids) +{ + //printf("ScopeStatement::doInlineStatement() %d\n", statements->dim); + return statement ? new ScopeStatement(loc, statement->doInlineStatement(ids)) : this; +} + +Statement *IfStatement::doInlineStatement(InlineDoState *ids) +{ + assert(!arg); + + Expression *condition = this->condition ? this->condition->doInline(ids) : NULL; + Statement *ifbody = this->ifbody ? this->ifbody->doInlineStatement(ids) : NULL; + Statement *elsebody = this->elsebody ? this->elsebody->doInlineStatement(ids) : NULL; + + return new IfStatement(loc, arg, condition, ifbody, elsebody); +} + +Statement *ReturnStatement::doInlineStatement(InlineDoState *ids) +{ + //printf("ReturnStatement::doInlineStatement() '%s'\n", exp ? exp->toChars() : ""); + return new ReturnStatement(loc, exp ? exp->doInline(ids) : NULL); +} + +#if DMDV2 +Statement *ImportStatement::doInlineStatement(InlineDoState *ids) +{ + return NULL; +} +#endif + +Statement *ForStatement::doInlineStatement(InlineDoState *ids) +{ + //printf("ForStatement::doInlineStatement()\n"); + Statement *init = this->init ? this->init->doInlineStatement(ids) : NULL; + Expression *condition = this->condition ? this->condition->doInline(ids) : NULL; + Expression *increment = this->increment ? this->increment->doInline(ids) : NULL; + Statement *body = this->body ? this->body->doInlineStatement(ids) : NULL; + return new ForStatement(loc, init, condition, increment, body); +} + +/* -------------------------------------------------------------------- */ + +Expression *Statement::doInline(InlineDoState *ids) +{ + printf("Statement::doInline()\n%s\n", toChars()); + fflush(stdout); + assert(0); + return NULL; // default is we can't inline it +} + +Expression *ExpStatement::doInline(InlineDoState *ids) +{ +#if LOG + if (exp) printf("ExpStatement::doInline() '%s'\n", exp->toChars()); +#endif + return exp ? exp->doInline(ids) : NULL; +} + +Expression *CompoundStatement::doInline(InlineDoState *ids) +{ + Expression *e = NULL; + + //printf("CompoundStatement::doInline() %d\n", statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + Expression *e2 = s->doInline(ids); + e = Expression::combine(e, e2); + if (s->isReturnStatement()) + break; + + /* Check for: + * if (condition) + * return exp1; + * else + * return exp2; + */ + IfStatement *ifs = s->isIfStatement(); + if (ifs && ifs->elsebody && ifs->ifbody && + ifs->ifbody->isReturnStatement() && + ifs->elsebody->isReturnStatement() + ) + break; + + } + } + return e; +} + +Expression *UnrolledLoopStatement::doInline(InlineDoState *ids) +{ + Expression *e = NULL; + + //printf("UnrolledLoopStatement::doInline() %d\n", statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + Expression *e2 = s->doInline(ids); + e = Expression::combine(e, e2); + if (s->isReturnStatement()) + break; + } + } + return e; +} + +Expression *ScopeStatement::doInline(InlineDoState *ids) +{ + return statement ? statement->doInline(ids) : NULL; +} + +Expression *IfStatement::doInline(InlineDoState *ids) +{ + Expression *econd; + Expression *e1; + Expression *e2; + Expression *e; + + assert(!arg); + econd = condition->doInline(ids); + assert(econd); + if (ifbody) + e1 = ifbody->doInline(ids); + else + e1 = NULL; + if (elsebody) + e2 = elsebody->doInline(ids); + else + e2 = NULL; + if (e1 && e2) + { + e = new CondExp(econd->loc, econd, e1, e2); + e->type = e1->type; + } + else if (e1) + { + e = new AndAndExp(econd->loc, econd, e1); + e->type = Type::tvoid; + } + else if (e2) + { + e = new OrOrExp(econd->loc, econd, e2); + e->type = Type::tvoid; + } + else + { + e = econd; + } + return e; +} + +Expression *ReturnStatement::doInline(InlineDoState *ids) +{ + //printf("ReturnStatement::doInline() '%s'\n", exp ? exp->toChars() : ""); + return exp ? exp->doInline(ids) : 0; +} + +#if DMDV2 +Expression *ImportStatement::doInline(InlineDoState *ids) +{ + return NULL; +} +#endif + +/* --------------------------------------------------------------- */ + +/****************************** + * Perform doInline() on an array of Expressions. + */ + +Expressions *arrayExpressiondoInline(Expressions *a, InlineDoState *ids) +{ Expressions *newa = NULL; + + if (a) + { + newa = new Expressions(); + newa->setDim(a->dim); + + for (size_t i = 0; i < a->dim; i++) + { Expression *e = a->tdata()[i]; + + if (e) + e = e->doInline(ids); + newa->tdata()[i] = e; + } + } + return newa; +} + +Expression *Expression::doInline(InlineDoState *ids) +{ + //printf("Expression::doInline(%s): %s\n", Token::toChars(op), toChars()); + return copy(); +} + +Expression *SymOffExp::doInline(InlineDoState *ids) +{ + //printf("SymOffExp::doInline(%s)\n", toChars()); + for (size_t i = 0; i < ids->from.dim; i++) + { + if (var == ids->from.tdata()[i]) + { + SymOffExp *se = (SymOffExp *)copy(); + + se->var = (Declaration *)ids->to.tdata()[i]; + return se; + } + } + return this; +} + +Expression *VarExp::doInline(InlineDoState *ids) +{ + //printf("VarExp::doInline(%s)\n", toChars()); + for (size_t i = 0; i < ids->from.dim; i++) + { + if (var == ids->from.tdata()[i]) + { + VarExp *ve = (VarExp *)copy(); + + ve->var = (Declaration *)ids->to.tdata()[i]; + return ve; + } + } + if (ids->fd && var == ids->fd->vthis) + { VarExp *ve = new VarExp(loc, ids->vthis); + ve->type = type; + return ve; + } + + return this; +} + +Expression *ThisExp::doInline(InlineDoState *ids) +{ + //if (!ids->vthis) + //error("no 'this' when inlining %s", ids->parent->toChars()); + if (!ids->vthis) + { + return this; + } + + VarExp *ve = new VarExp(loc, ids->vthis); + ve->type = type; + return ve; +} + +Expression *SuperExp::doInline(InlineDoState *ids) +{ + assert(ids->vthis); + + VarExp *ve = new VarExp(loc, ids->vthis); + ve->type = type; + return ve; +} + +Expression *DeclarationExp::doInline(InlineDoState *ids) +{ DeclarationExp *de = (DeclarationExp *)copy(); + VarDeclaration *vd; + + //printf("DeclarationExp::doInline(%s)\n", toChars()); + vd = declaration->isVarDeclaration(); + if (vd) + { +#if 0 + // Need to figure this out before inlining can work for tuples + TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); + if (td) + { + for (size_t i = 0; i < td->objects->dim; i++) + { DsymbolExp *se = td->objects->tdata()[i]; + assert(se->op == TOKdsymbol); + se->s; + } + return st->objects->dim; + } +#endif + if (vd->isStatic()) + ; + else + { + VarDeclaration *vto; + + vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); + *vto = *vd; + vto->parent = ids->parent; + vto->csym = NULL; + vto->isym = NULL; + + ids->from.push(vd); + ids->to.push(vto); + + if (vd->init) + { + if (vd->init->isVoidInitializer()) + { + vto->init = new VoidInitializer(vd->init->loc); + } + else + { + Expression *e = vd->init->toExpression(); + assert(e); + vto->init = new ExpInitializer(e->loc, e->doInline(ids)); + } + } + de->declaration = (Dsymbol *) (void *)vto; + } + } + /* This needs work, like DeclarationExp::toElem(), if we are + * to handle TemplateMixin's. For now, we just don't inline them. + */ + return de; +} + +Expression *NewExp::doInline(InlineDoState *ids) +{ + //printf("NewExp::doInline(): %s\n", toChars()); + NewExp *ne = (NewExp *)copy(); + + if (thisexp) + ne->thisexp = thisexp->doInline(ids); + ne->newargs = arrayExpressiondoInline(ne->newargs, ids); + ne->arguments = arrayExpressiondoInline(ne->arguments, ids); + return ne; +} + +Expression *UnaExp::doInline(InlineDoState *ids) +{ + UnaExp *ue = (UnaExp *)copy(); + + ue->e1 = e1->doInline(ids); + return ue; +} + +Expression *AssertExp::doInline(InlineDoState *ids) +{ + AssertExp *ae = (AssertExp *)copy(); + + ae->e1 = e1->doInline(ids); + if (msg) + ae->msg = msg->doInline(ids); + return ae; +} + +Expression *BinExp::doInline(InlineDoState *ids) +{ + BinExp *be = (BinExp *)copy(); + + be->e1 = e1->doInline(ids); + be->e2 = e2->doInline(ids); + return be; +} + +Expression *CallExp::doInline(InlineDoState *ids) +{ + CallExp *ce; + + ce = (CallExp *)copy(); + ce->e1 = e1->doInline(ids); + ce->arguments = arrayExpressiondoInline(arguments, ids); + return ce; +} + + +Expression *IndexExp::doInline(InlineDoState *ids) +{ + IndexExp *are = (IndexExp *)copy(); + + are->e1 = e1->doInline(ids); + + if (lengthVar) + { //printf("lengthVar\n"); + VarDeclaration *vd = lengthVar; + ExpInitializer *ie; + ExpInitializer *ieto; + VarDeclaration *vto; + + vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); + *vto = *vd; + vto->parent = ids->parent; + vto->csym = NULL; + vto->isym = NULL; + + ids->from.push(vd); + ids->to.push(vto); + + if (vd->init && !vd->init->isVoidInitializer()) + { + ie = vd->init->isExpInitializer(); + assert(ie); + ieto = new ExpInitializer(ie->loc, ie->exp->doInline(ids)); + vto->init = ieto; + } + + are->lengthVar = (VarDeclaration *) (void *)vto; + } + are->e2 = e2->doInline(ids); + return are; +} + + +Expression *SliceExp::doInline(InlineDoState *ids) +{ + SliceExp *are = (SliceExp *)copy(); + + are->e1 = e1->doInline(ids); + + if (lengthVar) + { //printf("lengthVar\n"); + VarDeclaration *vd = lengthVar; + ExpInitializer *ie; + ExpInitializer *ieto; + VarDeclaration *vto; + + vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); + *vto = *vd; + vto->parent = ids->parent; + vto->csym = NULL; + vto->isym = NULL; + + ids->from.push(vd); + ids->to.push(vto); + + if (vd->init && !vd->init->isVoidInitializer()) + { + ie = vd->init->isExpInitializer(); + assert(ie); + ieto = new ExpInitializer(ie->loc, ie->exp->doInline(ids)); + vto->init = ieto; + } + + are->lengthVar = (VarDeclaration *) (void *)vto; + } + if (lwr) + are->lwr = lwr->doInline(ids); + if (upr) + are->upr = upr->doInline(ids); + return are; +} + + +Expression *TupleExp::doInline(InlineDoState *ids) +{ + TupleExp *ce; + + ce = (TupleExp *)copy(); + ce->exps = arrayExpressiondoInline(exps, ids); + return ce; +} + + +Expression *ArrayLiteralExp::doInline(InlineDoState *ids) +{ + ArrayLiteralExp *ce; + + ce = (ArrayLiteralExp *)copy(); + ce->elements = arrayExpressiondoInline(elements, ids); + return ce; +} + + +Expression *AssocArrayLiteralExp::doInline(InlineDoState *ids) +{ + AssocArrayLiteralExp *ce; + + ce = (AssocArrayLiteralExp *)copy(); + ce->keys = arrayExpressiondoInline(keys, ids); + ce->values = arrayExpressiondoInline(values, ids); + return ce; +} + + +Expression *StructLiteralExp::doInline(InlineDoState *ids) +{ + StructLiteralExp *ce; + + ce = (StructLiteralExp *)copy(); + ce->elements = arrayExpressiondoInline(elements, ids); + return ce; +} + + +Expression *ArrayExp::doInline(InlineDoState *ids) +{ + ArrayExp *ce; + + ce = (ArrayExp *)copy(); + ce->e1 = e1->doInline(ids); + ce->arguments = arrayExpressiondoInline(arguments, ids); + return ce; +} + + +Expression *CondExp::doInline(InlineDoState *ids) +{ + CondExp *ce = (CondExp *)copy(); + + ce->econd = econd->doInline(ids); + ce->e1 = e1->doInline(ids); + ce->e2 = e2->doInline(ids); + return ce; +} + + +/* ========== Walk the parse trees, and inline expand functions ============= */ + +/* Walk the trees, looking for functions to inline. + * Inline any that can be. + */ + +struct InlineScanState +{ + FuncDeclaration *fd; // function being scanned +}; + +Statement *Statement::inlineScan(InlineScanState *iss) +{ + return this; +} + +Statement *ExpStatement::inlineScan(InlineScanState *iss) +{ +#if LOG + printf("ExpStatement::inlineScan(%s)\n", toChars()); +#endif + if (exp) + { + exp = exp->inlineScan(iss); + + /* See if we can inline as a statement rather than as + * an Expression. + */ + if (exp && exp->op == TOKcall) + { + CallExp *ce = (CallExp *)exp; + if (ce->e1->op == TOKvar) + { + VarExp *ve = (VarExp *)ce->e1; + FuncDeclaration *fd = ve->var->isFuncDeclaration(); + + if (fd && fd != iss->fd && fd->canInline(0, 0, 1)) + { + Statement *s; + fd->expandInline(iss, NULL, ce->arguments, &s); + return s; + } + } + } + } + return this; +} + +Statement *CompoundStatement::inlineScan(InlineScanState *iss) +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + (*statements)[i] = s->inlineScan(iss); + } + return this; +} + +Statement *UnrolledLoopStatement::inlineScan(InlineScanState *iss) +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + (*statements)[i] = s->inlineScan(iss); + } + return this; +} + +Statement *ScopeStatement::inlineScan(InlineScanState *iss) +{ + if (statement) + statement = statement->inlineScan(iss); + return this; +} + +Statement *WhileStatement::inlineScan(InlineScanState *iss) +{ + condition = condition->inlineScan(iss); + body = body ? body->inlineScan(iss) : NULL; + return this; +} + + +Statement *DoStatement::inlineScan(InlineScanState *iss) +{ + body = body ? body->inlineScan(iss) : NULL; + condition = condition->inlineScan(iss); + return this; +} + + +Statement *ForStatement::inlineScan(InlineScanState *iss) +{ + if (init) + init = init->inlineScan(iss); + if (condition) + condition = condition->inlineScan(iss); + if (increment) + increment = increment->inlineScan(iss); + if (body) + body = body->inlineScan(iss); + return this; +} + + +Statement *ForeachStatement::inlineScan(InlineScanState *iss) +{ + aggr = aggr->inlineScan(iss); + if (body) + body = body->inlineScan(iss); + return this; +} + + +#if DMDV2 +Statement *ForeachRangeStatement::inlineScan(InlineScanState *iss) +{ + lwr = lwr->inlineScan(iss); + upr = upr->inlineScan(iss); + if (body) + body = body->inlineScan(iss); + return this; +} +#endif + + +Statement *IfStatement::inlineScan(InlineScanState *iss) +{ + condition = condition->inlineScan(iss); + if (ifbody) + ifbody = ifbody->inlineScan(iss); + if (elsebody) + elsebody = elsebody->inlineScan(iss); + return this; +} + + +Statement *SwitchStatement::inlineScan(InlineScanState *iss) +{ + //printf("SwitchStatement::inlineScan()\n"); + condition = condition->inlineScan(iss); + body = body ? body->inlineScan(iss) : NULL; + if (sdefault) + sdefault = (DefaultStatement *)sdefault->inlineScan(iss); + if (cases) + { + for (size_t i = 0; i < cases->dim; i++) + { CaseStatement *s; + + s = cases->tdata()[i]; + cases->tdata()[i] = (CaseStatement *)s->inlineScan(iss); + } + } + return this; +} + + +Statement *CaseStatement::inlineScan(InlineScanState *iss) +{ + //printf("CaseStatement::inlineScan()\n"); + exp = exp->inlineScan(iss); + if (statement) + statement = statement->inlineScan(iss); + return this; +} + + +Statement *DefaultStatement::inlineScan(InlineScanState *iss) +{ + if (statement) + statement = statement->inlineScan(iss); + return this; +} + + +Statement *ReturnStatement::inlineScan(InlineScanState *iss) +{ + //printf("ReturnStatement::inlineScan()\n"); + if (exp) + { + exp = exp->inlineScan(iss); + } + return this; +} + + +Statement *SynchronizedStatement::inlineScan(InlineScanState *iss) +{ + if (exp) + exp = exp->inlineScan(iss); + if (body) + body = body->inlineScan(iss); + return this; +} + + +Statement *WithStatement::inlineScan(InlineScanState *iss) +{ + if (exp) + exp = exp->inlineScan(iss); + if (body) + body = body->inlineScan(iss); + return this; +} + + +Statement *TryCatchStatement::inlineScan(InlineScanState *iss) +{ + if (body) + body = body->inlineScan(iss); + if (catches) + { + for (size_t i = 0; i < catches->dim; i++) + { Catch *c = catches->tdata()[i]; + + if (c->handler) + c->handler = c->handler->inlineScan(iss); + } + } + return this; +} + + +Statement *TryFinallyStatement::inlineScan(InlineScanState *iss) +{ + if (body) + body = body->inlineScan(iss); + if (finalbody) + finalbody = finalbody->inlineScan(iss); + return this; +} + + +Statement *ThrowStatement::inlineScan(InlineScanState *iss) +{ + if (exp) + exp = exp->inlineScan(iss); + return this; +} + + +Statement *VolatileStatement::inlineScan(InlineScanState *iss) +{ + if (statement) + statement = statement->inlineScan(iss); + return this; +} + + +Statement *LabelStatement::inlineScan(InlineScanState *iss) +{ + if (statement) + statement = statement->inlineScan(iss); + return this; +} + +/* -------------------------- */ + +void arrayInlineScan(InlineScanState *iss, Expressions *arguments) +{ + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { Expression *e = arguments->tdata()[i]; + + if (e) + { + e = e->inlineScan(iss); + arguments->tdata()[i] = e; + } + } + } +} + +Expression *Expression::inlineScan(InlineScanState *iss) +{ + return this; +} + +void scanVar(Dsymbol *s, InlineScanState *iss) +{ + VarDeclaration *vd = s->isVarDeclaration(); + if (vd) + { + TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); + if (td) + { + for (size_t i = 0; i < td->objects->dim; i++) + { DsymbolExp *se = (DsymbolExp *)td->objects->tdata()[i]; + assert(se->op == TOKdsymbol); + scanVar(se->s, iss); + } + } + else + { + // Scan initializer (vd->init) + if (vd->init) + { + ExpInitializer *ie = vd->init->isExpInitializer(); + + if (ie) + { +#if DMDV2 + if (vd->type) + { Type *tb = vd->type->toBasetype(); + if (tb->ty == Tstruct) + { StructDeclaration *sd = ((TypeStruct *)tb)->sym; + if (sd->cpctor) + { /* The problem here is that if the initializer is a + * function call that returns a struct S with a cpctor: + * S s = foo(); + * the postblit is done by the return statement in foo() + * in s2ir.c, the intermediate code generator. + * But, if foo() is inlined and now the code looks like: + * S s = x; + * the postblit is not there, because such assignments + * are rewritten as s.cpctor(&x) by the front end. + * So, the inlining won't get the postblit called. + * Work around by not inlining these cases. + * A proper fix would be to move all the postblit + * additions to the front end. + */ + return; + } + } + } +#endif + ie->exp = ie->exp->inlineScan(iss); + } + } + } + } +} + +Expression *DeclarationExp::inlineScan(InlineScanState *iss) +{ + //printf("DeclarationExp::inlineScan()\n"); + scanVar(declaration, iss); + return this; +} + +Expression *UnaExp::inlineScan(InlineScanState *iss) +{ + e1 = e1->inlineScan(iss); + return this; +} + +Expression *AssertExp::inlineScan(InlineScanState *iss) +{ + e1 = e1->inlineScan(iss); + if (msg) + msg = msg->inlineScan(iss); + return this; +} + +Expression *BinExp::inlineScan(InlineScanState *iss) +{ + e1 = e1->inlineScan(iss); + e2 = e2->inlineScan(iss); + return this; +} + + +Expression *CallExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("CallExp::inlineScan()\n"); + e1 = e1->inlineScan(iss); + arrayInlineScan(iss, arguments); + + if (e1->op == TOKvar) + { + VarExp *ve = (VarExp *)e1; + FuncDeclaration *fd = ve->var->isFuncDeclaration(); + + if (fd && fd != iss->fd && fd->canInline(0, 0, 0)) + { + e = fd->expandInline(iss, NULL, arguments, NULL); + } + } + else if (e1->op == TOKdotvar) + { + DotVarExp *dve = (DotVarExp *)e1; + FuncDeclaration *fd = dve->var->isFuncDeclaration(); + + if (fd && fd != iss->fd && fd->canInline(1, 0, 0)) + { + if (dve->e1->op == TOKcall && + dve->e1->type->toBasetype()->ty == Tstruct) + { + /* To create ethis, we'll need to take the address + * of dve->e1, but this won't work if dve->e1 is + * a function call. + */ + ; + } + else + e = fd->expandInline(iss, dve->e1, arguments, NULL); + } + } + + return e; +} + + +Expression *SliceExp::inlineScan(InlineScanState *iss) +{ + e1 = e1->inlineScan(iss); + if (lwr) + lwr = lwr->inlineScan(iss); + if (upr) + upr = upr->inlineScan(iss); + return this; +} + + +Expression *TupleExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("TupleExp::inlineScan()\n"); + arrayInlineScan(iss, exps); + + return e; +} + + +Expression *ArrayLiteralExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("ArrayLiteralExp::inlineScan()\n"); + arrayInlineScan(iss, elements); + + return e; +} + + +Expression *AssocArrayLiteralExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("AssocArrayLiteralExp::inlineScan()\n"); + arrayInlineScan(iss, keys); + arrayInlineScan(iss, values); + + return e; +} + + +Expression *StructLiteralExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("StructLiteralExp::inlineScan()\n"); + arrayInlineScan(iss, elements); + + return e; +} + + +Expression *ArrayExp::inlineScan(InlineScanState *iss) +{ Expression *e = this; + + //printf("ArrayExp::inlineScan()\n"); + e1 = e1->inlineScan(iss); + arrayInlineScan(iss, arguments); + + return e; +} + + +Expression *CondExp::inlineScan(InlineScanState *iss) +{ + econd = econd->inlineScan(iss); + e1 = e1->inlineScan(iss); + e2 = e2->inlineScan(iss); + return this; +} + + +/* ========== =============== */ + +void FuncDeclaration::inlineScan() +{ + InlineScanState iss; + +#if LOG + printf("FuncDeclaration::inlineScan('%s')\n", toChars()); +#endif + memset(&iss, 0, sizeof(iss)); + iss.fd = this; + if (fbody && !naked) + { + inlineNest++; + fbody = fbody->inlineScan(&iss); + inlineNest--; + } +} + +int FuncDeclaration::canInline(int hasthis, int hdrscan, int statementsToo) +{ + InlineCostState ics; + int cost; + +#define CANINLINE_LOG 0 + +#if CANINLINE_LOG + printf("FuncDeclaration::canInline(hasthis = %d, statementsToo = %d, '%s')\n", hasthis, statementsToo, toChars()); +#endif + + if (needThis() && !hasthis) + return 0; + + if (inlineNest || (semanticRun < PASSsemantic3 && !hdrscan)) + { +#if CANINLINE_LOG + printf("\t1: no, inlineNest = %d, semanticRun = %d\n", inlineNest, semanticRun); +#endif + return 0; + } + +#if 1 + switch (statementsToo ? inlineStatusStmt : inlineStatusExp) + { + case ILSyes: +#if CANINLINE_LOG + printf("\t1: yes %s\n", toChars()); +#endif + return 1; + + case ILSno: +#if CANINLINE_LOG + printf("\t1: no %s\n", toChars()); +#endif + return 0; + + case ILSuninitialized: + break; + + default: + assert(0); + } +#endif + + if (type) + { assert(type->ty == Tfunction); + TypeFunction *tf = (TypeFunction *)(type); + if (tf->varargs == 1) // no variadic parameter lists + goto Lno; + + /* Don't inline a function that returns non-void, but has + * no return expression. + * No statement inlining for non-voids. + */ + if (tf->next && tf->next->ty != Tvoid && + (!(hasReturnExp & 1) || statementsToo) && + !hdrscan) + goto Lno; + } + + if ( + !fbody || + ident == Id::ensure || // ensure() has magic properties the inliner loses + !hdrscan && + ( +#if 0 + isCtorDeclaration() || // cannot because need to convert: + // return; + // to: + // return this; +#endif + isSynchronized() || + isImportedSymbol() || + hasNestedFrameRefs() || // no nested references to this frame + (isVirtual() && !isFinal()) + )) + { + goto Lno; + } + +#if 0 + /* If any parameters are Tsarray's (which are passed by reference) + * or out parameters (also passed by reference), don't do inlining. + */ + if (parameters) + { + for (size_t i = 0; i < parameters->dim; i++) + { + VarDeclaration *v = parameters->tdata()[i]; + if (v->type->toBasetype()->ty == Tsarray) + goto Lno; + } + } +#endif + + memset(&ics, 0, sizeof(ics)); + ics.hasthis = hasthis; + ics.fd = this; + ics.hdrscan = hdrscan; + cost = fbody->inlineCost(&ics); +#if CANINLINE_LOG + printf("cost = %d for %s\n", cost, toChars()); +#endif + if (tooCostly(cost)) + goto Lno; + if (!statementsToo && cost > COST_MAX) + goto Lno; + + if (!hdrscan) + { + // Don't modify inlineStatus for header content scan + if (statementsToo) + inlineStatusStmt = ILSyes; + else + inlineStatusExp = ILSyes; + + inlineScan(); // Don't scan recursively for header content scan + + if (inlineStatusExp == ILSuninitialized) + { + // Need to redo cost computation, as some statements or expressions have been inlined + memset(&ics, 0, sizeof(ics)); + ics.hasthis = hasthis; + ics.fd = this; + ics.hdrscan = hdrscan; + cost = fbody->inlineCost(&ics); + #if CANINLINE_LOG + printf("recomputed cost = %d for %s\n", cost, toChars()); + #endif + if (tooCostly(cost)) + goto Lno; + if (!statementsToo && cost > COST_MAX) + goto Lno; + + if (statementsToo) + inlineStatusStmt = ILSyes; + else + inlineStatusExp = ILSyes; + } + } +#if CANINLINE_LOG + printf("\t2: yes %s\n", toChars()); +#endif + return 1; + +Lno: + if (!hdrscan) // Don't modify inlineStatus for header content scan + { if (statementsToo) + inlineStatusStmt = ILSno; + else + inlineStatusExp = ILSno; + } +#if CANINLINE_LOG + printf("\t2: no %s\n", toChars()); +#endif + return 0; +} + +Expression *FuncDeclaration::expandInline(InlineScanState *iss, Expression *ethis, Expressions *arguments, Statement **ps) +{ + InlineDoState ids; + DeclarationExp *de; + Expression *e = NULL; + Statements *as = NULL; + +#if LOG || CANINLINE_LOG + printf("FuncDeclaration::expandInline('%s')\n", toChars()); +#endif + + memset(&ids, 0, sizeof(ids)); + ids.parent = iss->fd; + ids.fd = this; + + if (ps) + as = new Statements(); + + // Set up vthis + if (ethis) + { + VarDeclaration *vthis; + ExpInitializer *ei; + VarExp *ve; + +#if STRUCTTHISREF + if (ethis->type->ty == Tpointer) + { Type *t = ethis->type->nextOf(); + ethis = new PtrExp(ethis->loc, ethis); + ethis->type = t; + } + ei = new ExpInitializer(ethis->loc, ethis); + + vthis = new VarDeclaration(ethis->loc, ethis->type, Id::This, ei); + if (ethis->type->ty != Tclass) + vthis->storage_class = STCref; + else + vthis->storage_class = STCin; +#else + if (ethis->type->ty != Tclass && ethis->type->ty != Tpointer) + { + ethis = ethis->addressOf(NULL); + } + + ei = new ExpInitializer(ethis->loc, ethis); + + vthis = new VarDeclaration(ethis->loc, ethis->type, Id::This, ei); + vthis->storage_class = STCin; +#endif + vthis->linkage = LINKd; + vthis->parent = iss->fd; + + ve = new VarExp(vthis->loc, vthis); + ve->type = vthis->type; + + ei->exp = new AssignExp(vthis->loc, ve, ethis); + ei->exp->type = ve->type; +#if STRUCTTHISREF + if (ethis->type->ty != Tclass) + { /* This is a reference initialization, not a simple assignment. + */ + ei->exp->op = TOKconstruct; + } +#endif + + ids.vthis = vthis; + } + + // Set up parameters + if (ethis) + { + e = new DeclarationExp(0, ids.vthis); + e->type = Type::tvoid; + if (as) + as->push(new ExpStatement(e->loc, e)); + } + + if (arguments && arguments->dim) + { + assert(parameters->dim == arguments->dim); + + for (size_t i = 0; i < arguments->dim; i++) + { + VarDeclaration *vfrom = parameters->tdata()[i]; + VarDeclaration *vto; + Expression *arg = arguments->tdata()[i]; + ExpInitializer *ei; + VarExp *ve; + + ei = new ExpInitializer(arg->loc, arg); + + vto = new VarDeclaration(vfrom->loc, vfrom->type, vfrom->ident, ei); + vto->storage_class |= vfrom->storage_class & (STCin | STCout | STClazy | STCref); + vto->linkage = vfrom->linkage; + vto->parent = iss->fd; + //printf("vto = '%s', vto->storage_class = x%x\n", vto->toChars(), vto->storage_class); + //printf("vto->parent = '%s'\n", iss->fd->toChars()); + + ve = new VarExp(vto->loc, vto); + //ve->type = vto->type; + ve->type = arg->type; + + ei->exp = new ConstructExp(vto->loc, ve, arg); + ei->exp->type = ve->type; +//ve->type->print(); +//arg->type->print(); +//ei->exp->print(); + + ids.from.push(vfrom); + ids.to.push(vto); + + de = new DeclarationExp(0, vto); + de->type = Type::tvoid; + + if (as) + as->push(new ExpStatement(0, de)); + else + e = Expression::combine(e, de); + } + } + + if (ps) + { + inlineNest++; + Statement *s = fbody->doInlineStatement(&ids); + as->push(s); + *ps = new ScopeStatement(0, new CompoundStatement(0, as)); + inlineNest--; + } + else + { + inlineNest++; + Expression *eb = fbody->doInline(&ids); + e = Expression::combine(e, eb); + inlineNest--; + //eb->type->print(); + //eb->print(); + //eb->dump(0); + } + + /* There's a problem if what the function returns is used subsequently as an + * lvalue, as in a struct return that is then used as a 'this'. + * If we take the address of the return value, we will be taking the address + * of the original, not the copy. Fix this by assigning the return value to + * a temporary, then returning the temporary. If the temporary is used as an + * lvalue, it will work. + * This only happens with struct returns. + * See Bugzilla 2127 for an example. + */ + TypeFunction *tf = (TypeFunction*)type; + if (!ps && tf->next->ty == Tstruct) + { + /* Generate a new variable to hold the result and initialize it with the + * inlined body of the function: + * tret __inlineretval = e; + */ + ExpInitializer* ei = new ExpInitializer(loc, e); + + Identifier* tmp = Identifier::generateId("__inlineretval"); + VarDeclaration* vd = new VarDeclaration(loc, tf->next, tmp, ei); + vd->storage_class = tf->isref ? STCref : 0; + vd->linkage = tf->linkage; + vd->parent = iss->fd; + + VarExp *ve = new VarExp(loc, vd); + ve->type = tf->next; + + ei->exp = new ConstructExp(loc, ve, e); + ei->exp->type = ve->type; + + DeclarationExp* de = new DeclarationExp(0, vd); + de->type = Type::tvoid; + + // Chain the two together: + // ( typeof(return) __inlineretval = ( inlined body )) , __inlineretval + e = Expression::combine(de, ve); + + //fprintf(stderr, "CallExp::inlineScan: e = "); e->print(); + } + + // Need to reevaluate whether parent can now be inlined + // in expressions, as we might have inlined statements + iss->fd->inlineStatusExp = ILSuninitialized; + return e; +} + + +/**************************************************** + * Perform the "inline copying" of a default argument for a function parameter. + */ + +Expression *Expression::inlineCopy(Scope *sc) +{ +#if 0 + /* See Bugzilla 2935 for explanation of why just a copy() is broken + */ + return copy(); +#else + InlineCostState ics; + + memset(&ics, 0, sizeof(ics)); + ics.hdrscan = 1; // so DeclarationExp:: will work on 'statics' which are not + int cost = expressionInlineCost(this, &ics); + if (cost >= COST_MAX) + { error("cannot inline default argument %s", toChars()); + return new ErrorExp(); + } + InlineDoState ids; + memset(&ids, 0, sizeof(ids)); + ids.parent = sc->parent; + Expression *e = doInline(&ids); + return e; +#endif +} diff --git a/interpret.c b/interpret.c new file mode 100644 index 00000000..3258566a --- /dev/null +++ b/interpret.c @@ -0,0 +1,6496 @@ +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "rmem.h" + +#include "statement.h" +#include "expression.h" +#include "cond.h" +#include "init.h" +#include "staticassert.h" +#include "mtype.h" +#include "scope.h" +#include "declaration.h" +#include "aggregate.h" +#include "id.h" +#include "utf.h" +#include "attrib.h" // for AttribDeclaration + +#include "template.h" +TemplateInstance *isSpeculativeFunction(FuncDeclaration *fd); + + +#define LOG 0 +#define LOGASSIGN 0 +#define SHOWPERFORMANCE 0 + +// Maximum allowable recursive function calls in CTFE +#define CTFE_RECURSION_LIMIT 1000 + +// The values of all CTFE variables. +struct CtfeStack +{ +private: + /* The stack. Every declaration we encounter is pushed here, + together with the VarDeclaration, and the previous + stack address of that variable, so that we can restore it + when we leave the stack frame. + Ctfe Stack addresses are just 0-based integers, but we save + them as 'void *' because ArrayBase can only do pointers. + */ + Expressions values; // values on the stack + VarDeclarations vars; // corresponding variables + ArrayBase savedId; // id of the previous state of that var + + /* Global constants get saved here after evaluation, so we never + * have to redo them. This saves a lot of time and memory. + */ + Expressions globalValues; // values of global constants + size_t framepointer; // current frame pointer + size_t maxStackPointer; // most stack we've ever used +public: + CtfeStack() : framepointer(0) + { + } + size_t stackPointer() + { + return values.dim; + } + // Largest number of stack positions we've used + size_t maxStackUsage() + { + return maxStackPointer; + } + // return the previous frame + size_t startFrame() + { + size_t oldframe = framepointer; + framepointer = stackPointer(); + return oldframe; + } + void endFrame(size_t oldframe) + { + popAll(framepointer); + framepointer = oldframe; + } + Expression *getValue(VarDeclaration *v) + { + if (v->isDataseg() && !v->isCTFE()) + { + assert(v->ctfeAdrOnStack >= 0 && + v->ctfeAdrOnStack < globalValues.dim); + return globalValues.tdata()[v->ctfeAdrOnStack]; + } + assert(v->ctfeAdrOnStack >= 0 && v->ctfeAdrOnStack < stackPointer()); + return values.tdata()[v->ctfeAdrOnStack]; + } + void setValue(VarDeclaration *v, Expression *e) + { + assert(!v->isDataseg() || v->isCTFE()); + assert(v->ctfeAdrOnStack >= 0 && v->ctfeAdrOnStack < stackPointer()); + values.tdata()[v->ctfeAdrOnStack] = e; + } + void push(VarDeclaration *v) + { + assert(!v->isDataseg() || v->isCTFE()); + if (v->ctfeAdrOnStack!= (size_t)-1 + && v->ctfeAdrOnStack >= framepointer) + { // Already exists in this frame, reuse it. + values.tdata()[v->ctfeAdrOnStack] = NULL; + return; + } + savedId.push((void *)(v->ctfeAdrOnStack)); + v->ctfeAdrOnStack = values.dim; + vars.push(v); + values.push(NULL); + } + void pop(VarDeclaration *v) + { + assert(!v->isDataseg() || v->isCTFE()); + assert(!(v->storage_class & (STCref | STCout))); + int oldid = v->ctfeAdrOnStack; + v->ctfeAdrOnStack = (size_t)(savedId.tdata()[oldid]); + if (v->ctfeAdrOnStack == values.dim - 1) + { + values.pop(); + vars.pop(); + savedId.pop(); + } + } + void popAll(size_t stackpointer) + { + if (stackPointer() > maxStackPointer) + maxStackPointer = stackPointer(); + assert(values.dim >= stackpointer && stackpointer >= 0); + for (size_t i = stackpointer; i < values.dim; ++i) + { + VarDeclaration *v = vars.tdata()[i]; + v->ctfeAdrOnStack = (size_t)(savedId.tdata()[i]); + } + values.setDim(stackpointer); + vars.setDim(stackpointer); + savedId.setDim(stackpointer); + } + void saveGlobalConstant(VarDeclaration *v, Expression *e) + { + assert(v->isDataseg() && !v->isCTFE()); + v->ctfeAdrOnStack = globalValues.dim; + globalValues.push(e); + } +}; + +CtfeStack ctfeStack; + + +struct InterState +{ + InterState *caller; // calling function's InterState + FuncDeclaration *fd; // function being interpreted + size_t framepointer; // frame pointer of previous frame + Statement *start; // if !=NULL, start execution at this statement + Statement *gotoTarget; /* target of EXP_GOTO_INTERPRET result; also + * target of labelled EXP_BREAK_INTERPRET or + * EXP_CONTINUE_INTERPRET. (NULL if no label). + */ + Expression *localThis; // value of 'this', or NULL if none + bool awaitingLvalueReturn; // Support for ref return values: + // Any return to this function should return an lvalue. + InterState(); +}; + +InterState::InterState() +{ + memset(this, 0, sizeof(InterState)); +} + +// Global status of the CTFE engine +struct CtfeStatus +{ + static int callDepth; // current number of recursive calls + static int stackTraceCallsToSuppress; /* When printing a stack trace, + * suppress this number of calls + */ + static int maxCallDepth; // highest number of recursive calls + static int numArrayAllocs; // Number of allocated arrays + static int numAssignments; // total number of assignments executed +}; + +int CtfeStatus::callDepth = 0; +int CtfeStatus::stackTraceCallsToSuppress = 0; +int CtfeStatus::maxCallDepth = 0; +int CtfeStatus::numArrayAllocs = 0; +int CtfeStatus::numAssignments = 0; + +// CTFE diagnostic information +void printCtfePerformanceStats() +{ +#if SHOWPERFORMANCE + printf(" ---- CTFE Performance ----\n"); + printf("max call depth = %d\tmax stack = %d\n", CtfeStatus::maxCallDepth, ctfeStack.maxStackUsage()); + printf("array allocs = %d\tassignments = %d\n\n", CtfeStatus::numArrayAllocs, CtfeStatus::numAssignments); +#endif +} + + +Expression * resolveReferences(Expression *e, Expression *thisval); +Expression *getVarExp(Loc loc, InterState *istate, Declaration *d, CtfeGoal goal); +VarDeclaration *findParentVar(Expression *e, Expression *thisval); +bool needToCopyLiteral(Expression *expr); +Expression *copyLiteral(Expression *e); +Expression *paintTypeOntoLiteral(Type *type, Expression *lit); +Expression *findKeyInAA(AssocArrayLiteralExp *ae, Expression *e2); +Expression *evaluateIfBuiltin(InterState *istate, Loc loc, + FuncDeclaration *fd, Expressions *arguments, Expression *pthis); +Expression *scrubReturnValue(Loc loc, Expression *e); +bool isAssocArray(Type *t); +bool isPointer(Type *t); + +// CTFE only expressions +#define TOKclassreference ((TOK)(TOKMAX+1)) +#define TOKthrownexception ((TOK)(TOKMAX+2)) + +// Reference to a class, or an interface. We need this when we +// point to a base class (we must record what the type is). +struct ClassReferenceExp : Expression +{ + StructLiteralExp *value; + ClassReferenceExp(Loc loc, StructLiteralExp *lit, Type *type) : Expression(loc, TOKclassreference, sizeof(ClassReferenceExp)) + { + assert(lit && lit->sd && lit->sd->isClassDeclaration()); + this->value = lit; + this->type = type; + } + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue) + { + //printf("ClassReferenceExp::interpret() %s\n", value->toChars()); + return this; + } + char *toChars() + { + return value->toChars(); + } + ClassDeclaration *originalClass() + { + return value->sd->isClassDeclaration(); + } + // Return index of the field, or -1 if not found + int getFieldIndex(Type *fieldtype, size_t fieldoffset) + { + ClassDeclaration *cd = originalClass(); + size_t fieldsSoFar = 0; + for (size_t j = 0; j < value->elements->dim; j++) + { while (j - fieldsSoFar >= cd->fields.dim) + { fieldsSoFar += cd->fields.dim; + cd = cd->baseClass; + } + Dsymbol *s = cd->fields.tdata()[j - fieldsSoFar]; + VarDeclaration *v2 = s->isVarDeclaration(); + if (fieldoffset == v2->offset && + fieldtype->size() == v2->type->size()) + { return value->elements->dim - fieldsSoFar - cd->fields.dim + (j-fieldsSoFar); + } + } + return -1; + } + // Return index of the field, or -1 if not found + // Same as getFieldIndex, but checks for a direct match with the VarDeclaration + int findFieldIndexByName(VarDeclaration *v) + { + ClassDeclaration *cd = originalClass(); + size_t fieldsSoFar = 0; + for (size_t j = 0; j < value->elements->dim; j++) + { while (j - fieldsSoFar >= cd->fields.dim) + { fieldsSoFar += cd->fields.dim; + cd = cd->baseClass; + } + Dsymbol *s = cd->fields.tdata()[j - fieldsSoFar]; + VarDeclaration *v2 = s->isVarDeclaration(); + if (v == v2) + { return value->elements->dim - fieldsSoFar - cd->fields.dim + (j-fieldsSoFar); + } + } + return -1; + } +}; + +// Return index of the field, or -1 if not found +// Same as getFieldIndex, but checks for a direct match with the VarDeclaration +int findFieldIndexByName(StructDeclaration *sd, VarDeclaration *v) +{ + for (int i = 0; i < sd->fields.dim; ++i) + { + if (sd->fields.tdata()[i] == v) + return i; + } + return -1; +} + +// Fake class which holds the thrown exception. Used for implementing exception handling. +struct ThrownExceptionExp : Expression +{ + ClassReferenceExp *thrown; // the thing being tossed + ThrownExceptionExp(Loc loc, ClassReferenceExp *victim) : Expression(loc, TOKthrownexception, sizeof(ThrownExceptionExp)) + { + this->thrown = victim; + this->type = type; + } + Expression *interpret(InterState *istate, CtfeGoal goal = ctfeNeedRvalue) + { + assert(0); // This should never be interpreted + return this; + } + char *toChars() + { + return (char *)"CTFE ThrownException"; + } + // Generate an error message when this exception is not caught + void generateUncaughtError() + { + thrown->error("Uncaught CTFE exception %s(%s)", thrown->type->toChars(), + thrown->value->elements->tdata()[0]->toChars()); + /* Also give the line where the throw statement was. We won't have it + * in the case where the ThrowStatement is generated internally + * (eg, in ScopeStatement) + */ + if (loc.filename && !loc.equals(thrown->loc)) + errorSupplemental(loc, "thrown from here"); + } +}; + +// True if 'e' is EXP_CANT_INTERPRET, or an exception +bool exceptionOrCantInterpret(Expression *e) +{ + if (e == EXP_CANT_INTERPRET) return true; + if (!e || e == EXP_GOTO_INTERPRET || e == EXP_VOID_INTERPRET + || e == EXP_BREAK_INTERPRET || e == EXP_CONTINUE_INTERPRET) + return false; + return e->op == TOKthrownexception; +} + + +// Used for debugging only +void showCtfeExpr(Expression *e, int level = 0) +{ + for (int i = level; i>0; --i) printf(" "); + Expressions *elements = NULL; + // We need the struct definition to detect block assignment + StructDeclaration *sd = NULL; + ClassDeclaration *cd = NULL; + if (e->op == TOKstructliteral) + { elements = ((StructLiteralExp *)e)->elements; + sd = ((StructLiteralExp *)e)->sd; + printf("STRUCT type = %s %p:\n", e->type->toChars(), + e); + } + else if (e->op == TOKclassreference) + { elements = ((ClassReferenceExp *)e)->value->elements; + cd = ((ClassReferenceExp *)e)->originalClass(); + printf("CLASS type = %s %p:\n", e->type->toChars(), + ((ClassReferenceExp *)e)->value); + } + else if (e->op == TOKarrayliteral) + { + elements = ((ArrayLiteralExp *)e)->elements; + printf("ARRAY LITERAL type=%s %p:\n", e->type->toChars(), + e); + } + else if (e->op == TOKassocarrayliteral) + { + printf("AA LITERAL type=%s %p:\n", e->type->toChars(), + e); + } + else if (e->op == TOKstring) + { + printf("STRING %s %p\n", e->toChars(), + ((StringExp *)e)->string); + } + else if (e->op == TOKslice) + { + printf("SLICE %p: %s\n", e, e->toChars()); + showCtfeExpr(((SliceExp *)e)->e1, level + 1); + } + else if (e->op == TOKvar) + { + printf("VAR %p %s\n", e, e->toChars()); + VarDeclaration *v = ((VarExp *)e)->var->isVarDeclaration(); + if (v && v->getValue()) + showCtfeExpr(v->getValue(), level + 1); + } + else if (isPointer(e->type)) + { + // This is potentially recursive. We mustn't try to print the thing we're pointing to. + if (e->op == TOKindex) + printf("POINTER %p into %p [%s]\n", e, ((IndexExp *)e)->e1, ((IndexExp *)e)->e2->toChars()); + else if (e->op == TOKdotvar) + printf("POINTER %p to %p .%s\n", e, ((DotVarExp *)e)->e1, ((DotVarExp *)e)->var->toChars()); + else + printf("POINTER %p: %s\n", e, e->toChars()); + } + else + printf("VALUE %p: %s\n", e, e->toChars()); + + if (elements) + { + size_t fieldsSoFar = 0; + for (size_t i = 0; i < elements->dim; i++) + { Expression *z = NULL; + Dsymbol *s = NULL; + if (i > 15) { + printf("...(total %d elements)\n", elements->dim); + return; + } + if (sd) + { s = sd->fields.tdata()[i]; + z = elements->tdata()[i]; + } + else if (cd) + { while (i - fieldsSoFar >= cd->fields.dim) + { fieldsSoFar += cd->fields.dim; + cd = cd->baseClass; + for (int j = level; j>0; --j) printf(" "); + printf(" BASE CLASS: %s\n", cd->toChars()); + } + s = cd->fields.tdata()[i - fieldsSoFar]; + size_t indx = (elements->dim - fieldsSoFar)- cd->fields.dim + i; + assert(indx >= 0); + assert(indx < elements->dim); + z = elements->tdata()[indx]; + } + if (!z) { + for (int j = level; j>0; --j) printf(" "); + printf(" void\n"); + continue; + } + + if (s) + { + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + // If it is a void assignment, use the default initializer + if ((v->type->ty != z->type->ty) && v->type->ty == Tsarray) + { + for (int j = level; --j;) printf(" "); + printf(" field: block initalized static array\n"); + continue; + } + } + showCtfeExpr(z, level + 1); + } + } +} + +/************************************* + * Attempt to interpret a function given the arguments. + * Input: + * istate state for calling function (NULL if none) + * arguments function arguments + * thisarg 'this', if a needThis() function, NULL if not. + * + * Return result expression if successful, EXP_CANT_INTERPRET if not. + */ + +Expression *FuncDeclaration::interpret(InterState *istate, Expressions *arguments, Expression *thisarg) +{ +#if LOG + printf("\n********\nFuncDeclaration::interpret(istate = %p) %s\n", istate, toChars()); +#endif + if (semanticRun == PASSsemantic3) + return EXP_CANT_INTERPRET; + + if (semanticRun < PASSsemantic3 && scope) + { + /* Forward reference - we need to run semantic3 on this function. + * If errors are gagged, and it's not part of a speculative + * template instance, we need to temporarily ungag errors. + */ + int olderrors = global.errors; + int oldgag = global.gag; + TemplateInstance *spec = isSpeculativeFunction(this); + if (global.gag && !spec) + global.gag = 0; + semantic3(scope); + global.gag = oldgag; // regag errors + + // If it is a speculatively-instantiated template, and errors occur, + // we need to mark the template as having errors. + if (spec && global.errors != olderrors) + spec->errors = global.errors - olderrors; + if (olderrors != global.errors) // if errors compiling this function + return EXP_CANT_INTERPRET; + } + if (semanticRun < PASSsemantic3done) + return EXP_CANT_INTERPRET; + + Type *tb = type->toBasetype(); + assert(tb->ty == Tfunction); + TypeFunction *tf = (TypeFunction *)tb; + Type *tret = tf->next->toBasetype(); + if (tf->varargs && arguments && + ((parameters && arguments->dim != parameters->dim) || (!parameters && arguments->dim))) + { + error("C-style variadic functions are not yet implemented in CTFE"); + return EXP_CANT_INTERPRET; + } + + // Nested functions always inherit the 'this' pointer from the parent, + // except for delegates. (Note that the 'this' pointer may be null). + // Func literals report isNested() even if they are in global scope, + // so we need to check that the parent is a function. + if (isNested() && toParent2()->isFuncDeclaration() && !thisarg && istate) + thisarg = istate->localThis; + + InterState istatex; + istatex.caller = istate; + istatex.fd = this; + istatex.localThis = thisarg; + istatex.framepointer = ctfeStack.startFrame(); + + Expressions vsave; // place to save previous parameter values + size_t dim = 0; + if (needThis() && !thisarg) + { // error, no this. Prevent segfault. + error("need 'this' to access member %s", toChars()); + return EXP_CANT_INTERPRET; + } + if (thisarg && !istate) + { // Check that 'this' aleady has a value + if (thisarg->interpret(istate) == EXP_CANT_INTERPRET) + return EXP_CANT_INTERPRET; + } + static int evaluatingArgs = 0; + if (arguments) + { + dim = arguments->dim; + assert(!dim || (parameters && (parameters->dim == dim))); + vsave.setDim(dim); + + /* Evaluate all the arguments to the function, + * store the results in eargs[] + */ + Expressions eargs; + eargs.setDim(dim); + for (size_t i = 0; i < dim; i++) + { Expression *earg = arguments->tdata()[i]; + Parameter *arg = Parameter::getNth(tf->parameters, i); + + if (arg->storageClass & (STCout | STCref)) + { + if (!istate && (arg->storageClass & STCout)) + { // initializing an out parameter involves writing to it. + earg->error("global %s cannot be passed as an 'out' parameter at compile time", earg->toChars()); + return EXP_CANT_INTERPRET; + } + // Convert all reference arguments into lvalue references + ++evaluatingArgs; + earg = earg->interpret(istate, ctfeNeedLvalueRef); + --evaluatingArgs; + if (earg == EXP_CANT_INTERPRET) + return earg; + } + else if (arg->storageClass & STClazy) + { + } + else + { /* Value parameters + */ + Type *ta = arg->type->toBasetype(); + if (ta->ty == Tsarray && earg->op == TOKaddress) + { + /* Static arrays are passed by a simple pointer. + * Skip past this to get at the actual arg. + */ + earg = ((AddrExp *)earg)->e1; + } + ++evaluatingArgs; + earg = earg->interpret(istate); + --evaluatingArgs; + if (earg == EXP_CANT_INTERPRET) + return earg; + } + if (earg->op == TOKthrownexception) + { + if (istate) + return earg; + ((ThrownExceptionExp *)earg)->generateUncaughtError(); + return EXP_CANT_INTERPRET; + } + eargs.tdata()[i] = earg; + } + + for (size_t i = 0; i < dim; i++) + { Expression *earg = eargs.tdata()[i]; + Parameter *arg = Parameter::getNth(tf->parameters, i); + VarDeclaration *v = parameters->tdata()[i]; +#if LOG + printf("arg[%d] = %s\n", i, earg->toChars()); +#endif + if (arg->storageClass & (STCout | STCref) && earg->op == TOKvar) + { + VarExp *ve = (VarExp *)earg; + VarDeclaration *v2 = ve->var->isVarDeclaration(); + if (!v2) + { + error("cannot interpret %s as a ref parameter", ve->toChars()); + return EXP_CANT_INTERPRET; + } + /* The push() isn't a variable we'll use, it's just a place + * to save the old value of v. + * Note that v might be v2! So we need to save v2's index + * before pushing. + */ + size_t oldadr = v2->ctfeAdrOnStack; + ctfeStack.push(v); + v->ctfeAdrOnStack = oldadr; + assert(v2->hasValue()); + } + else + { // Value parameters and non-trivial references + ctfeStack.push(v); + v->setValueWithoutChecking(earg); + } +#if LOG || LOGASSIGN + printf("interpreted arg[%d] = %s\n", i, earg->toChars()); + showCtfeExpr(earg); +#endif + } + } + + if (vresult) + ctfeStack.push(vresult); + + // Enter the function + ++CtfeStatus::callDepth; + if (CtfeStatus::callDepth > CtfeStatus::maxCallDepth) + CtfeStatus::maxCallDepth = CtfeStatus::callDepth; + + Expression *e = NULL; + while (1) + { + if (CtfeStatus::callDepth > CTFE_RECURSION_LIMIT) + { // This is a compiler error. It must not be suppressed. + global.gag = 0; + error("CTFE recursion limit exceeded"); + e = EXP_CANT_INTERPRET; + break; + } + e = fbody->interpret(&istatex); + if (e == EXP_CANT_INTERPRET) + { +#if LOG + printf("function body failed to interpret\n"); +#endif + } + + /* This is how we deal with a recursive statement AST + * that has arbitrary goto statements in it. + * Bubble up a 'result' which is the target of the goto + * statement, then go recursively down the AST looking + * for that statement, then execute starting there. + */ + if (e == EXP_GOTO_INTERPRET) + { + istatex.start = istatex.gotoTarget; // set starting statement + istatex.gotoTarget = NULL; + } + else + break; + } + assert(e != EXP_CONTINUE_INTERPRET && e != EXP_BREAK_INTERPRET); + + // Leave the function + --CtfeStatus::callDepth; + + ctfeStack.endFrame(istatex.framepointer); + + // If fell off the end of a void function, return void + if (!e && type->toBasetype()->nextOf()->ty == Tvoid) + return EXP_VOID_INTERPRET; + // If it generated an exception, return it + if (exceptionOrCantInterpret(e)) + { + if (istate || e == EXP_CANT_INTERPRET) + return e; + ((ThrownExceptionExp *)e)->generateUncaughtError(); + return EXP_CANT_INTERPRET; + } + if (!istate && !evaluatingArgs) + { + e = scrubReturnValue(loc, e); + } + return e; +} + +/******************************** Statement ***************************/ + +#define START() \ + if (istate->start) \ + { if (istate->start != this) \ + return NULL; \ + istate->start = NULL; \ + } + +/*********************************** + * Interpret the statement. + * Returns: + * NULL continue to next statement + * EXP_CANT_INTERPRET cannot interpret statement at compile time + * !NULL expression from return statement, or thrown exception + */ + +Expression *Statement::interpret(InterState *istate) +{ +#if LOG + printf("Statement::interpret()\n"); +#endif + START() + error("Statement %s cannot be interpreted at compile time", this->toChars()); + return EXP_CANT_INTERPRET; +} + +Expression *ExpStatement::interpret(InterState *istate) +{ +#if LOG + printf("ExpStatement::interpret(%s)\n", exp ? exp->toChars() : ""); +#endif + START() + if (exp) + { + Expression *e = exp->interpret(istate, ctfeNeedNothing); + if (e == EXP_CANT_INTERPRET) + { + //printf("-ExpStatement::interpret(): %p\n", e); + return EXP_CANT_INTERPRET; + } + if (e && e!= EXP_VOID_INTERPRET && e->op == TOKthrownexception) + return e; + } + return NULL; +} + +Expression *CompoundStatement::interpret(InterState *istate) +{ Expression *e = NULL; + +#if LOG + printf("CompoundStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + if (statements) + { + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = statements->tdata()[i]; + + if (s) + { + e = s->interpret(istate); + if (e) + break; + } + } + } +#if LOG + printf("-CompoundStatement::interpret() %p\n", e); +#endif + return e; +} + +Expression *UnrolledLoopStatement::interpret(InterState *istate) +{ Expression *e = NULL; + +#if LOG + printf("UnrolledLoopStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + if (statements) + { + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = statements->tdata()[i]; + + e = s->interpret(istate); + if (e == EXP_CANT_INTERPRET) + break; + if (e == EXP_CONTINUE_INTERPRET) + { + if (istate->gotoTarget && istate->gotoTarget != this) + break; // continue at higher level + istate->gotoTarget = NULL; + e = NULL; + continue; + } + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + e = NULL; + } // else break at a higher level + break; + } + if (e) + break; + } + } + return e; +} + +// For CTFE only. Returns true if 'e' is TRUE or a non-null pointer. +int isTrueBool(Expression *e) +{ + return e->isBool(TRUE) || ((e->type->ty == Tpointer || e->type->ty == Tclass) + && e->op != TOKnull); +} + +Expression *IfStatement::interpret(InterState *istate) +{ +#if LOG + printf("IfStatement::interpret(%s)\n", condition->toChars()); +#endif + + if (istate->start == this) + istate->start = NULL; + if (istate->start) + { + Expression *e = NULL; + if (ifbody) + e = ifbody->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (istate->start && elsebody) + e = elsebody->interpret(istate); + return e; + } + + Expression *e = condition->interpret(istate); + assert(e); + //if (e == EXP_CANT_INTERPRET) printf("cannot interpret\n"); + if (e != EXP_CANT_INTERPRET && (e && e->op != TOKthrownexception)) + { + if (isTrueBool(e)) + e = ifbody ? ifbody->interpret(istate) : NULL; + else if (e->isBool(FALSE)) + e = elsebody ? elsebody->interpret(istate) : NULL; + else + { + e = EXP_CANT_INTERPRET; + } + } + return e; +} + +Expression *ScopeStatement::interpret(InterState *istate) +{ +#if LOG + printf("ScopeStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + return statement ? statement->interpret(istate) : NULL; +} + +Expression *resolveSlice(Expression *e) +{ + if ( ((SliceExp *)e)->e1->op == TOKnull) + return ((SliceExp *)e)->e1; + return Slice(e->type, ((SliceExp *)e)->e1, + ((SliceExp *)e)->lwr, ((SliceExp *)e)->upr); +} + +/* Determine the array length, without interpreting it. + * e must be an array literal, or a slice + * It's very wasteful to resolve the slice when we only + * need the length. + */ +uinteger_t resolveArrayLength(Expression *e) +{ + if (e->op == TOKnull) + return 0; + if (e->op == TOKslice) + { uinteger_t ilo = ((SliceExp *)e)->lwr->toInteger(); + uinteger_t iup = ((SliceExp *)e)->upr->toInteger(); + return iup - ilo; + } + if (e->op == TOKstring) + { return ((StringExp *)e)->len; + } + if (e->op == TOKarrayliteral) + { ArrayLiteralExp *ale = (ArrayLiteralExp *)e; + return ale->elements ? ale->elements->dim : 0; + } + if (e->op == TOKassocarrayliteral) + { AssocArrayLiteralExp *ale = (AssocArrayLiteralExp *)e; + return ale->keys->dim; + } + assert(0); + return 0; +} + +// As Equal, but resolves slices before comparing +Expression *ctfeEqual(enum TOK op, Type *type, Expression *e1, Expression *e2) +{ + if (e1->op == TOKslice) + e1 = resolveSlice(e1); + if (e2->op == TOKslice) + e2 = resolveSlice(e2); + return Equal(op, type, e1, e2); +} + +Expression *ctfeCat(Type *type, Expression *e1, Expression *e2) +{ + Loc loc = e1->loc; + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + Expression *e; + if (e2->op == TOKstring && e1->op == TOKarrayliteral && + t1->nextOf()->isintegral()) + { + // [chars] ~ string => string (only valid for CTFE) + StringExp *es1 = (StringExp *)e2; + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e1; + size_t len = es1->len + es2->elements->dim; + int sz = es1->sz; + + void *s = mem.malloc((len + 1) * sz); + memcpy((char *)s + sz * es2->elements->dim, es1->string, es1->len * sz); + for (size_t i = 0; i < es2->elements->dim; i++) + { Expression *es2e = es2->elements->tdata()[i]; + if (es2e->op != TOKint64) + return EXP_CANT_INTERPRET; + dinteger_t v = es2e->toInteger(); + memcpy((unsigned char *)s + i * sz, &v, sz); + } + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + StringExp *es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = 0; + es->type = type; + e = es; + return e; + } + else if (e1->op == TOKstring && e2->op == TOKarrayliteral && + t2->nextOf()->isintegral()) + { + // string ~ [chars] => string (only valid for CTFE) + // Concatenate the strings + StringExp *es1 = (StringExp *)e1; + ArrayLiteralExp *es2 = (ArrayLiteralExp *)e2; + size_t len = es1->len + es2->elements->dim; + int sz = es1->sz; + + void *s = mem.malloc((len + 1) * sz); + memcpy(s, es1->string, es1->len * sz); + for (size_t i = 0; i < es2->elements->dim; i++) + { Expression *es2e = es2->elements->tdata()[i]; + if (es2e->op != TOKint64) + return EXP_CANT_INTERPRET; + dinteger_t v = es2e->toInteger(); + memcpy((unsigned char *)s + (es1->len + i) * sz, &v, sz); + } + + // Add terminating 0 + memset((unsigned char *)s + len * sz, 0, sz); + + StringExp *es = new StringExp(loc, s, len); + es->sz = sz; + es->committed = 0; //es1->committed; + es->type = type; + e = es; + return e; + } + return Cat(type, e1, e2); +} + +void scrubArray(Loc loc, Expressions *elems); + +/* All results destined for use outside of CTFE need to have their CTFE-specific + * features removed. + * In particular, all slices must be resolved. + */ +Expression *scrubReturnValue(Loc loc, Expression *e) +{ + if (e->op == TOKclassreference) + { + error(loc, "%s class literals cannot be returned from CTFE", ((ClassReferenceExp*)e)->originalClass()->toChars()); + return EXP_CANT_INTERPRET; + } + if (e->op == TOKslice) + { + e = resolveSlice(e); + } + if (e->op == TOKstructliteral) + { + StructLiteralExp *se = (StructLiteralExp *)e; + se->ownedByCtfe = false; + scrubArray(loc, se->elements); + } + if (e->op == TOKstring) + { + ((StringExp *)e)->ownedByCtfe = false; + } + if (e->op == TOKarrayliteral) + { + ((ArrayLiteralExp *)e)->ownedByCtfe = false; + scrubArray(loc, ((ArrayLiteralExp *)e)->elements); + } + if (e->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)e; + aae->ownedByCtfe = false; + scrubArray(loc, aae->keys); + scrubArray(loc, aae->values); + } + return e; +} + +// Scrub all members of an array +void scrubArray(Loc loc, Expressions *elems) +{ + for (size_t i = 0; i < elems->dim; i++) + { + Expression *m = elems->tdata()[i]; + if (!m) + continue; + m = scrubReturnValue(loc, m); + elems->tdata()[i] = m; + } +} + + +Expression *ReturnStatement::interpret(InterState *istate) +{ +#if LOG + printf("ReturnStatement::interpret(%s)\n", exp ? exp->toChars() : ""); +#endif + START() + if (!exp) + return EXP_VOID_INTERPRET; + assert(istate && istate->fd && istate->fd->type); +#if DMDV2 + /* If the function returns a ref AND it's been called from an assignment, + * we need to return an lvalue. Otherwise, just do an (rvalue) interpret. + */ + if (istate->fd->type && istate->fd->type->ty==Tfunction) + { + TypeFunction *tf = (TypeFunction *)istate->fd->type; + if (tf->isref && istate->caller && istate->caller->awaitingLvalueReturn) + { // We need to return an lvalue + Expression *e = exp->interpret(istate, ctfeNeedLvalue); + if (e == EXP_CANT_INTERPRET) + error("ref return %s is not yet supported in CTFE", exp->toChars()); + return e; + } + if (tf->next && (tf->next->ty == Tdelegate) && istate->fd->closureVars.dim > 0) + { + // To support this, we need to copy all the closure vars + // into the delegate literal. + error("closures are not yet supported in CTFE"); + return EXP_CANT_INTERPRET; + } + } +#endif + // We need to treat pointers specially, because TOKsymoff can be used to + // return a value OR a pointer + Expression *e; + if ( isPointer(exp->type) ) + e = exp->interpret(istate, ctfeNeedLvalue); + else + e = exp->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (needToCopyLiteral(e)) + e = copyLiteral(e); +#if LOGASSIGN + printf("RETURN %s\n", loc.toChars()); + showCtfeExpr(e); +#endif + return e; +} + +Expression *BreakStatement::interpret(InterState *istate) +{ +#if LOG + printf("BreakStatement::interpret()\n"); +#endif + START() + if (ident) + { LabelDsymbol *label = istate->fd->searchLabel(ident); + assert(label && label->statement); + Statement *s = label->statement; + if (s->isLabelStatement()) + s = s->isLabelStatement()->statement; + if (s->isScopeStatement()) + s = s->isScopeStatement()->statement; + istate->gotoTarget = s; + return EXP_BREAK_INTERPRET; + } + else + { + istate->gotoTarget = NULL; + return EXP_BREAK_INTERPRET; + } +} + +Expression *ContinueStatement::interpret(InterState *istate) +{ +#if LOG + printf("ContinueStatement::interpret()\n"); +#endif + START() + if (ident) + { LabelDsymbol *label = istate->fd->searchLabel(ident); + assert(label && label->statement); + Statement *s = label->statement; + if (s->isLabelStatement()) + s = s->isLabelStatement()->statement; + if (s->isScopeStatement()) + s = s->isScopeStatement()->statement; + istate->gotoTarget = s; + return EXP_CONTINUE_INTERPRET; + } + else + return EXP_CONTINUE_INTERPRET; +} + +Expression *WhileStatement::interpret(InterState *istate) +{ +#if LOG + printf("WhileStatement::interpret()\n"); +#endif + assert(0); // rewritten to ForStatement + return NULL; +} + +Expression *DoStatement::interpret(InterState *istate) +{ +#if LOG + printf("DoStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + Expression *e; + + if (istate->start) + { + e = body ? body->interpret(istate) : NULL; + if (istate->start) + return NULL; + if (e == EXP_CANT_INTERPRET) + return e; + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + e = NULL; + } // else break at a higher level + return e; + } + if (e == EXP_CONTINUE_INTERPRET) + if (!istate->gotoTarget || istate->gotoTarget == this) + { + goto Lcontinue; + } + else // else continue at a higher level + return e; + if (e) + return e; + } + + while (1) + { + e = body ? body->interpret(istate) : NULL; + if (e == EXP_CANT_INTERPRET) + break; + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + e = NULL; + } // else break at a higher level + break; + } + if (e && e != EXP_CONTINUE_INTERPRET) + break; + if (istate->gotoTarget && istate->gotoTarget != this) + break; // continue at a higher level + + Lcontinue: + istate->gotoTarget = NULL; + e = condition->interpret(istate); + if (exceptionOrCantInterpret(e)) + break; + if (!e->isConst()) + { e = EXP_CANT_INTERPRET; + break; + } + if (isTrueBool(e)) + { + } + else if (e->isBool(FALSE)) + { e = NULL; + break; + } + else + assert(0); + } + return e; +} + +Expression *ForStatement::interpret(InterState *istate) +{ +#if LOG + printf("ForStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + Expression *e; + + if (init) + { + e = init->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + assert(!e); + } + + if (istate->start) + { + e = body ? body->interpret(istate) : NULL; + if (istate->start) + return NULL; + if (e == EXP_CANT_INTERPRET) + return e; + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + return NULL; + } // else break at a higher level + } + if (e == EXP_CONTINUE_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + goto Lcontinue; + } // else continue at a higher level + } + if (e) + return e; + } + + while (1) + { + if (!condition) + goto Lhead; + e = condition->interpret(istate); + if (exceptionOrCantInterpret(e)) + break; + if (!e->isConst()) + { e = EXP_CANT_INTERPRET; + break; + } + if (isTrueBool(e)) + { + Lhead: + e = body ? body->interpret(istate) : NULL; + if (e == EXP_CANT_INTERPRET) + break; + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + e = NULL; + } // else break at a higher level + break; + } + if (e && e != EXP_CONTINUE_INTERPRET) + break; + if (istate->gotoTarget && istate->gotoTarget != this) + break; // continue at a higher level + Lcontinue: + istate->gotoTarget = NULL; + if (increment) + { + e = increment->interpret(istate); + if (e == EXP_CANT_INTERPRET) + break; + } + } + else if (e->isBool(FALSE)) + { e = NULL; + break; + } + else + assert(0); + } + return e; +} + +Expression *ForeachStatement::interpret(InterState *istate) +{ + assert(0); // rewritten to ForStatement + return NULL; +} + +#if DMDV2 +Expression *ForeachRangeStatement::interpret(InterState *istate) +{ + assert(0); // rewritten to ForStatement + return NULL; +} +#endif + +Expression *SwitchStatement::interpret(InterState *istate) +{ +#if LOG + printf("SwitchStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + Expression *e = NULL; + + if (istate->start) + { + e = body ? body->interpret(istate) : NULL; + if (istate->start) + return NULL; + if (e == EXP_CANT_INTERPRET) + return e; + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + return NULL; + } // else break at a higher level + } + return e; + } + + + Expression *econdition = condition->interpret(istate); + if (exceptionOrCantInterpret(econdition)) + return econdition; + if (econdition->op == TOKslice) + econdition = resolveSlice(econdition); + + Statement *s = NULL; + if (cases) + { + for (size_t i = 0; i < cases->dim; i++) + { + CaseStatement *cs = cases->tdata()[i]; + Expression * caseExp = cs->exp->interpret(istate); + if (exceptionOrCantInterpret(caseExp)) + return caseExp; + e = ctfeEqual(TOKequal, Type::tint32, econdition, caseExp); + if (exceptionOrCantInterpret(e)) + return e; + if (e->isBool(TRUE)) + { s = cs; + break; + } + } + } + if (!s) + { if (hasNoDefault) + error("no default or case for %s in switch statement", econdition->toChars()); + s = sdefault; + } + + assert(s); + istate->start = s; + e = body ? body->interpret(istate) : NULL; + assert(!istate->start); + if (e == EXP_BREAK_INTERPRET) + { + if (!istate->gotoTarget || istate->gotoTarget == this) + { + istate->gotoTarget = NULL; + e = NULL; + } // else break at a higher level + } + return e; +} + +Expression *CaseStatement::interpret(InterState *istate) +{ +#if LOG + printf("CaseStatement::interpret(%s) this = %p\n", exp->toChars(), this); +#endif + if (istate->start == this) + istate->start = NULL; + if (statement) + return statement->interpret(istate); + else + return NULL; +} + +Expression *DefaultStatement::interpret(InterState *istate) +{ +#if LOG + printf("DefaultStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + if (statement) + return statement->interpret(istate); + else + return NULL; +} + +Expression *GotoStatement::interpret(InterState *istate) +{ +#if LOG + printf("GotoStatement::interpret()\n"); +#endif + START() + assert(label && label->statement); + istate->gotoTarget = label->statement; + return EXP_GOTO_INTERPRET; +} + +Expression *GotoCaseStatement::interpret(InterState *istate) +{ +#if LOG + printf("GotoCaseStatement::interpret()\n"); +#endif + START() + assert(cs); + istate->gotoTarget = cs; + return EXP_GOTO_INTERPRET; +} + +Expression *GotoDefaultStatement::interpret(InterState *istate) +{ +#if LOG + printf("GotoDefaultStatement::interpret()\n"); +#endif + START() + assert(sw && sw->sdefault); + istate->gotoTarget = sw->sdefault; + return EXP_GOTO_INTERPRET; +} + +Expression *LabelStatement::interpret(InterState *istate) +{ +#if LOG + printf("LabelStatement::interpret()\n"); +#endif + if (istate->start == this) + istate->start = NULL; + return statement ? statement->interpret(istate) : NULL; +} + + +Expression *TryCatchStatement::interpret(InterState *istate) +{ +#if LOG + printf("TryCatchStatement::interpret()\n"); +#endif + START() + Expression *e = body ? body->interpret(istate) : NULL; + if (e == EXP_CANT_INTERPRET) + return e; + if (!exceptionOrCantInterpret(e)) + return e; + // An exception was thrown + ThrownExceptionExp *ex = (ThrownExceptionExp *)e; + Type *extype = ex->thrown->originalClass()->type; + // Search for an appropriate catch clause. + for (size_t i = 0; i < catches->dim; i++) + { +#if DMDV1 + Catch *ca = (Catch *)catches->data[i]; +#else + Catch *ca = catches->tdata()[i]; +#endif + Type *catype = ca->type; + + if (catype->equals(extype) || catype->isBaseOf(extype, NULL)) + { // Execute the handler + if (ca->var) + { + ctfeStack.push(ca->var); + ca->var->setValue(ex->thrown); + } + return ca->handler->interpret(istate); + } + } + return e; +} + +bool isAnErrorException(ClassDeclaration *cd) +{ + return cd == ClassDeclaration::errorException || ClassDeclaration::errorException->isBaseOf(cd, NULL); +} + +ThrownExceptionExp *chainExceptions(ThrownExceptionExp *oldest, ThrownExceptionExp *newest) +{ +#if LOG + printf("Collided exceptions %s %s\n", oldest->thrown->toChars(), newest->thrown->toChars()); +#endif +#if DMDV2 + // Little sanity check to make sure it's really a Throwable + ClassReferenceExp *boss = oldest->thrown; + assert(boss->value->elements->tdata()[4]->type->ty == Tclass); + ClassReferenceExp *collateral = newest->thrown; + if (isAnErrorException(collateral->originalClass()) + && !isAnErrorException(boss->originalClass())) + { // The new exception bypass the existing chain + assert(collateral->value->elements->tdata()[5]->type->ty == Tclass); + collateral->value->elements->tdata()[5] = boss; + return newest; + } + while (boss->value->elements->tdata()[4]->op == TOKclassreference) + { + boss = (ClassReferenceExp *)(boss->value->elements->tdata()[4]); + } + boss->value->elements->tdata()[4] = collateral; + return oldest; +#else + // for D1, the newest exception just clobbers the older one + return newest; +#endif +} + + +Expression *TryFinallyStatement::interpret(InterState *istate) +{ +#if LOG + printf("TryFinallyStatement::interpret()\n"); +#endif + START() + Expression *e = body ? body->interpret(istate) : NULL; + if (e == EXP_CANT_INTERPRET) + return e; + Expression *second = finalbody ? finalbody->interpret(istate) : NULL; + if (second == EXP_CANT_INTERPRET) + return second; + if (exceptionOrCantInterpret(second)) + { // Check for collided exceptions + if (exceptionOrCantInterpret(e)) + e = chainExceptions((ThrownExceptionExp *)e, (ThrownExceptionExp *)second); + else + e = second; + } + return e; +} + +Expression *ThrowStatement::interpret(InterState *istate) +{ +#if LOG + printf("ThrowStatement::interpret()\n"); +#endif + START() + Expression *e = exp->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + assert(e->op == TOKclassreference); + return new ThrownExceptionExp(loc, (ClassReferenceExp *)e); +} + +Expression *OnScopeStatement::interpret(InterState *istate) +{ + assert(0); + return EXP_CANT_INTERPRET; +} + +Expression *WithStatement::interpret(InterState *istate) +{ +#if LOG + printf("WithStatement::interpret()\n"); +#endif + START() + Expression *e = exp->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (wthis->type->ty == Tpointer && exp->type->ty != Tpointer) + { + e = new AddrExp(loc, e); + e->type = wthis->type; + } + ctfeStack.push(wthis); + wthis->setValue(e); + e = body ? body->interpret(istate) : EXP_VOID_INTERPRET; + ctfeStack.pop(wthis); + return e; +} + +Expression *AsmStatement::interpret(InterState *istate) +{ +#if LOG + printf("AsmStatement::interpret()\n"); +#endif + START() + error("asm statements cannot be interpreted at compile time"); + return EXP_CANT_INTERPRET; +} + +#if DMDV2 +Expression *ImportStatement::interpret(InterState *istate) +{ +#if LOG + printf("ImportStatement::interpret()\n"); +#endif + START(); + return NULL; +} +#endif + +/******************************** Expression ***************************/ + +Expression *Expression::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("Expression::interpret() %s\n", toChars()); + printf("type = %s\n", type->toChars()); + dump(0); +#endif + error("Cannot interpret %s at compile time", toChars()); + return EXP_CANT_INTERPRET; +} + +Expression *ThisExp::interpret(InterState *istate, CtfeGoal goal) +{ + while (istate && !istate->localThis) + istate = istate->caller; + if (istate && istate->localThis && istate->localThis->op == TOKstructliteral) + return istate->localThis; + if (istate && istate->localThis) + return istate->localThis->interpret(istate, goal); + error("value of 'this' is not known at compile time"); + return EXP_CANT_INTERPRET; +} + +Expression *NullExp::interpret(InterState *istate, CtfeGoal goal) +{ + return this; +} + +Expression *IntegerExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("IntegerExp::interpret() %s\n", toChars()); +#endif + return this; +} + +Expression *RealExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("RealExp::interpret() %s\n", toChars()); +#endif + return this; +} + +Expression *ComplexExp::interpret(InterState *istate, CtfeGoal goal) +{ + return this; +} + +Expression *StringExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("StringExp::interpret() %s\n", toChars()); +#endif + /* In both D1 and D2, attempts to modify string literals are prevented + * in BinExp::interpretAssignCommon. + * In D2, we also disallow casts of read-only literals to mutable, + * though it isn't strictly necessary. + */ +#if DMDV2 + // Fixed-length char arrays always get duped later anyway. + if (type->ty == Tsarray) + return this; + if (!(((TypeNext *)type)->next->mod & (MODconst | MODimmutable))) + { // It seems this happens only when there has been an explicit cast + error("cannot cast a read-only string literal to mutable in CTFE"); + return EXP_CANT_INTERPRET; + } +#endif + return this; +} + +Expression *FuncExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("FuncExp::interpret() %s\n", toChars()); +#endif + return this; +} + +/* Is it safe to convert from srcPointee* to destPointee* ? + * srcPointee is the genuine type (never void). + * destPointee may be void. + */ +bool isSafePointerCast(Type *srcPointee, Type *destPointee) +{ // It's OK if both are the same (modulo const) +#if DMDV2 + if (srcPointee->castMod(0) == destPointee->castMod(0)) + return true; +#else + if (srcPointee == destPointee) + return true; +#endif + // it's OK to cast to void* + if (destPointee->ty == Tvoid) + return true; + // It's OK if they are the same size integers, eg int* and uint* + return srcPointee->isintegral() && destPointee->isintegral() + && srcPointee->size() == destPointee->size(); +} + +Expression *SymOffExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("SymOffExp::interpret() %s\n", toChars()); +#endif + if (var->isFuncDeclaration() && offset == 0) + { + return this; + } + if (type->ty != Tpointer) + { // Probably impossible + error("Cannot interpret %s at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + Type *pointee = ((TypePointer *)type)->next; + Expression *val = getVarExp(loc, istate, var, goal); + if (val->type->ty == Tarray || val->type->ty == Tsarray) + { + // Check for unsupported type painting operations + Type *elemtype = ((TypeArray *)(val->type))->next; + + // It's OK to cast from fixed length to dynamic array, eg &int[3] to int[]* + if (val->type->ty == Tsarray && pointee->ty == Tarray + && elemtype->size() == pointee->nextOf()->size()) + { + Expression *e = new AddrExp(loc, val); + e->type = type; + return e; + } + if ( !isSafePointerCast(elemtype, pointee) ) + { // It's also OK to cast from &string to string*. + if ( offset == 0 && isSafePointerCast(var->type, pointee) ) + { + VarExp *ve = new VarExp(loc, var); + ve->type = type; + return ve; + } + error("reinterpreting cast from %s to %s is not supported in CTFE", + val->type->toChars(), type->toChars()); + return EXP_CANT_INTERPRET; + } + + TypeArray *tar = (TypeArray *)val->type; + dinteger_t sz = pointee->size(); + dinteger_t indx = offset/sz; + assert(sz * indx == offset); + Expression *aggregate = NULL; + if (val->op == TOKarrayliteral || val->op == TOKstring) + aggregate = val; + else if (val->op == TOKslice) + { + aggregate = ((SliceExp *)val)->e1; + Expression *lwr = ((SliceExp *)val)->lwr->interpret(istate); + indx += lwr->toInteger(); + } + if (aggregate) + { + IntegerExp *ofs = new IntegerExp(loc, indx, Type::tsize_t); + IndexExp *ie = new IndexExp(loc, aggregate, ofs); + ie->type = type; + return ie; + } + } + else if ( offset == 0 && isSafePointerCast(var->type, pointee) ) + { + VarExp *ve = new VarExp(loc, var); + ve->type = type; + return ve; + } + + error("Cannot convert &%s to %s at compile time", var->type->toChars(), type->toChars()); + return EXP_CANT_INTERPRET; +} + +Expression *AddrExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("AddrExp::interpret() %s\n", toChars()); +#endif + // For reference types, we need to return an lvalue ref. + TY tb = e1->type->toBasetype()->ty; + bool needRef = (tb == Tarray || tb == Taarray || tb == Tclass); + Expression *e = e1->interpret(istate, needRef ? ctfeNeedLvalueRef : ctfeNeedLvalue); + if (exceptionOrCantInterpret(e)) + return e; + // Return a simplified address expression + e = new AddrExp(loc, e); + e->type = type; + return e; +} + +Expression *DelegateExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("DelegateExp::interpret() %s\n", toChars()); +#endif + return this; +} + + +// ------------------------------------------------------------- +// Remove out, ref, and this +// ------------------------------------------------------------- +// The variable used in a dotvar, index, or slice expression, +// after 'out', 'ref', and 'this' have been removed. +Expression * resolveReferences(Expression *e, Expression *thisval) +{ + for(;;) + { + if (e->op == TOKthis) + { + assert(thisval); + assert(e != thisval); + e = thisval; + continue; + } + if (e->op == TOKvar) + { + VarExp *ve = (VarExp *)e; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v->type->ty == Tpointer) + break; + if (v->ctfeAdrOnStack == (size_t)-1) // If not on the stack, can't possibly be a ref. + break; + if (v && v->getValue() && (v->getValue()->op == TOKslice)) + { + SliceExp *se = (SliceExp *)v->getValue(); + if (se->e1->op == TOKarrayliteral || se->e1->op == TOKassocarrayliteral || se->e1->op == TOKstring) + break; + e = v->getValue(); + continue; + } + else if (v && v->getValue() && (v->getValue()->op==TOKindex || v->getValue()->op == TOKdotvar + || v->getValue()->op == TOKthis )) + { + e = v->getValue(); + continue; + } + } + break; + } + return e; +} + +Expression *getVarExp(Loc loc, InterState *istate, Declaration *d, CtfeGoal goal) +{ + Expression *e = EXP_CANT_INTERPRET; + VarDeclaration *v = d->isVarDeclaration(); + SymbolDeclaration *s = d->isSymbolDeclaration(); + if (v) + { +#if DMDV2 + /* Magic variable __ctfe always returns true when interpreting + */ + if (v->ident == Id::ctfe) + return new IntegerExp(loc, 1, Type::tbool); + if ((v->isConst() || v->isImmutable() || v->storage_class & STCmanifest) && v->init && !v->hasValue()) +#else + if (v->isConst() && v->init) +#endif + { e = v->init->toExpression(); + if (e && (e->op == TOKconstruct || e->op == TOKblit)) + { AssignExp *ae = (AssignExp *)e; + e = ae->e2; + v->inuse++; + e = e->interpret(istate, ctfeNeedAnyValue); + v->inuse--; + if (e == EXP_CANT_INTERPRET && !global.gag && !CtfeStatus::stackTraceCallsToSuppress) + errorSupplemental(loc, "while evaluating %s.init", v->toChars()); + if (exceptionOrCantInterpret(e)) + return e; + e->type = v->type; + } + else + { + if (e && !e->type) + e->type = v->type; + if (e) + e = e->interpret(istate, ctfeNeedAnyValue); + if (e == EXP_CANT_INTERPRET && !global.gag && !CtfeStatus::stackTraceCallsToSuppress) + errorSupplemental(loc, "while evaluating %s.init", v->toChars()); + } + if (e && e != EXP_CANT_INTERPRET && e->op != TOKthrownexception) + { + e = copyLiteral(e); + if (v->isDataseg()) + ctfeStack.saveGlobalConstant(v, e); + else + v->setValueWithoutChecking(e); + } + } + else if (v->isCTFE() && !v->hasValue()) + { + if (v->init && v->type->size() != 0) + { + if (v->init->isVoidInitializer()) + { + error(loc, "variable %s is used before initialization", v->toChars()); + return EXP_CANT_INTERPRET; + } + e = v->init->toExpression(); + e = e->interpret(istate); + } + else + e = v->type->defaultInitLiteral(loc); + } + else if (!v->isDataseg() && !v->isCTFE() && !istate) + { error(loc, "variable %s cannot be read at compile time", v->toChars()); + return EXP_CANT_INTERPRET; + } + else + { e = v->hasValue() ? v->getValue() : NULL; + if (!e && !v->isCTFE() && v->isDataseg()) + { error(loc, "static variable %s cannot be read at compile time", v->toChars()); + e = EXP_CANT_INTERPRET; + } + else if (!e) + error(loc, "variable %s is used before initialization", v->toChars()); + else if (exceptionOrCantInterpret(e)) + return e; + else if (goal == ctfeNeedLvalue && v->isRef() && e->op == TOKindex) + { // If it is a foreach ref, resolve the index into a constant + IndexExp *ie = (IndexExp *)e; + Expression *w = ie->e2->interpret(istate); + if (w != ie->e2) + { + e = new IndexExp(ie->loc, ie->e1, w); + e->type = ie->type; + } + return e; + } + else if ((goal == ctfeNeedLvalue) + || e->op == TOKstring || e->op == TOKstructliteral || e->op == TOKarrayliteral + || e->op == TOKassocarrayliteral || e->op == TOKslice + || e->type->toBasetype()->ty == Tpointer) + return e; // it's already an Lvalue + else + e = e->interpret(istate, goal); + } + if (!e) + e = EXP_CANT_INTERPRET; + } + else if (s) + { // Struct static initializers, for example + if (s->dsym->toInitializer() == s->sym) + { e = s->dsym->type->defaultInitLiteral(); + e = e->semantic(NULL); + if (e->op == TOKerror) + e = EXP_CANT_INTERPRET; + } + else + error(loc, "cannot interpret symbol %s at compile time", v->toChars()); + } + else + error(loc, "cannot interpret declaration %s at compile time", d->toChars()); + return e; +} + +Expression *VarExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("VarExp::interpret() %s\n", toChars()); +#endif + if (goal == ctfeNeedLvalueRef) + { + VarDeclaration *v = var->isVarDeclaration(); + if (v && !v->isDataseg() && !v->isCTFE() && !istate) + { error("variable %s cannot be referenced at compile time", v->toChars()); + return EXP_CANT_INTERPRET; + } + else if (v && !v->hasValue() && !v->isCTFE() && v->isDataseg()) + { error("static variable %s cannot be referenced at compile time", v->toChars()); + return EXP_CANT_INTERPRET; + } + return this; + } + Expression *e = getVarExp(loc, istate, var, goal); + // A VarExp may include an implicit cast. It must be done explicitly. + if (e != EXP_CANT_INTERPRET && e->op != TOKthrownexception) + e = paintTypeOntoLiteral(type, e); + return e; +} + +Expression *DeclarationExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("DeclarationExp::interpret() %s\n", toChars()); +#endif + Expression *e; + VarDeclaration *v = declaration->isVarDeclaration(); + if (v) + { + if (v->toAlias()->isTupleDeclaration()) + { // Reserve stack space for all tuple members + TupleDeclaration *td =v->toAlias()->isTupleDeclaration(); + if (!td->objects) + return NULL; + for(int i= 0; i < td->objects->dim; ++i) + { + Object * o = td->objects->tdata()[i]; + Expression *ex = isExpression(o); + DsymbolExp *s = (ex && ex->op == TOKdsymbol) ? (DsymbolExp *)ex : NULL; + VarDeclaration *v2 = s ? s->s->isVarDeclaration() : NULL; + assert(v2); + if (!v2->isDataseg() || v2->isCTFE()) + ctfeStack.push(v2); + } + } + if (!v->isDataseg() || v->isCTFE()) + ctfeStack.push(v); + Dsymbol *s = v->toAlias(); + if (s == v && !v->isStatic() && v->init) + { + ExpInitializer *ie = v->init->isExpInitializer(); + if (ie) + e = ie->exp->interpret(istate); + else if (v->init->isVoidInitializer()) + e = NULL; + else + { + error("Declaration %s is not yet implemented in CTFE", toChars()); + e = EXP_CANT_INTERPRET; + } + } + else if (s == v && !v->init && v->type->size()==0) + { // Zero-length arrays don't need an initializer + e = v->type->defaultInitLiteral(loc); + } +#if DMDV2 + else if (s == v && (v->isConst() || v->isImmutable()) && v->init) +#else + else if (s == v && v->isConst() && v->init) +#endif + { e = v->init->toExpression(); + if (!e) + e = EXP_CANT_INTERPRET; + else if (!e->type) + e->type = v->type; + } + else if (s->isTupleDeclaration() && !v->init) + e = NULL; + else if (v->isStatic() && !v->init) + e = NULL; // Just ignore static variables which aren't read or written yet + else + { + error("Static variable %s cannot be modified at compile time", v->toChars()); + e = EXP_CANT_INTERPRET; + } + } + else if (declaration->isAttribDeclaration() || + declaration->isTemplateMixin() || + declaration->isTupleDeclaration()) + { // Check for static struct declarations, which aren't executable + AttribDeclaration *ad = declaration->isAttribDeclaration(); + if (ad && ad->decl && ad->decl->dim == 1 + && ad->decl->tdata()[0]->isAggregateDeclaration()) + return NULL; // static struct declaration. Nothing to do. + + // These can be made to work, too lazy now + error("Declaration %s is not yet implemented in CTFE", toChars()); + e = EXP_CANT_INTERPRET; + } + else + { // Others should not contain executable code, so are trivial to evaluate + e = NULL; + } +#if LOG + printf("-DeclarationExp::interpret(%s): %p\n", toChars(), e); +#endif + return e; +} + +Expression *TupleExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("TupleExp::interpret() %s\n", toChars()); +#endif + Expressions *expsx = NULL; + + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = exps->tdata()[i]; + Expression *ex; + + ex = e->interpret(istate); + if (exceptionOrCantInterpret(ex)) + { delete expsx; + return ex; + } + + // A tuple of assignments can contain void (Bug 5676). + if (goal == ctfeNeedNothing) + continue; + if (ex == EXP_VOID_INTERPRET) + { + error("ICE: void element %s in tuple", e->toChars()); + assert(0); + } + + /* If any changes, do Copy On Write + */ + if (ex != e) + { + if (!expsx) + { expsx = new Expressions(); + ++CtfeStatus::numArrayAllocs; + expsx->setDim(exps->dim); + for (size_t j = 0; j < i; j++) + { + expsx->tdata()[j] = exps->tdata()[j]; + } + } + expsx->tdata()[i] = ex; + } + } + if (expsx) + { TupleExp *te = new TupleExp(loc, expsx); + expandTuples(te->exps); + te->type = new TypeTuple(te->exps); + return te; + } + return this; +} + +Expression *ArrayLiteralExp::interpret(InterState *istate, CtfeGoal goal) +{ Expressions *expsx = NULL; + +#if LOG + printf("ArrayLiteralExp::interpret() %s\n", toChars()); +#endif + if (ownedByCtfe) // We've already interpreted all the elements + return copyLiteral(this); + if (elements) + { + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = elements->tdata()[i]; + Expression *ex; + + if (e->op == TOKindex) // segfault bug 6250 + assert( ((IndexExp*)e)->e1 != this); + ex = e->interpret(istate); + if (ex == EXP_CANT_INTERPRET) + goto Lerror; + if (ex->op == TOKthrownexception) + return ex; + + /* If any changes, do Copy On Write + */ + if (ex != e) + { + if (!expsx) + { expsx = new Expressions(); + ++CtfeStatus::numArrayAllocs; + expsx->setDim(elements->dim); + for (size_t j = 0; j < elements->dim; j++) + { + expsx->tdata()[j] = elements->tdata()[j]; + } + } + expsx->tdata()[i] = ex; + } + } + } + if (elements && expsx) + { + expandTuples(expsx); + if (expsx->dim != elements->dim) + goto Lerror; + ArrayLiteralExp *ae = new ArrayLiteralExp(loc, expsx); + ae->type = type; + return copyLiteral(ae); + } +#if DMDV2 + if (((TypeNext *)type)->next->mod & (MODconst | MODimmutable)) + { // If it's immutable, we don't need to dup it + return this; + } +#endif + return copyLiteral(this); + +Lerror: + if (expsx) + delete expsx; + error("cannot interpret array literal"); + return EXP_CANT_INTERPRET; +} + +Expression *AssocArrayLiteralExp::interpret(InterState *istate, CtfeGoal goal) +{ Expressions *keysx = keys; + Expressions *valuesx = values; + +#if LOG + printf("AssocArrayLiteralExp::interpret() %s\n", toChars()); +#endif + if (ownedByCtfe) // We've already interpreted all the elements + return copyLiteral(this); + for (size_t i = 0; i < keys->dim; i++) + { Expression *ekey = keys->tdata()[i]; + Expression *evalue = values->tdata()[i]; + Expression *ex; + + ex = ekey->interpret(istate); + if (ex == EXP_CANT_INTERPRET) + goto Lerr; + if (ex->op == TOKthrownexception) + return ex; + + + /* If any changes, do Copy On Write + */ + if (ex != ekey) + { + if (keysx == keys) + keysx = (Expressions *)keys->copy(); + keysx->tdata()[i] = ex; + } + + ex = evalue->interpret(istate); + if (ex == EXP_CANT_INTERPRET) + goto Lerr; + if (ex->op == TOKthrownexception) + return ex; + + /* If any changes, do Copy On Write + */ + if (ex != evalue) + { + if (valuesx == values) + valuesx = (Expressions *)values->copy(); + valuesx->tdata()[i] = ex; + } + } + if (keysx != keys) + expandTuples(keysx); + if (valuesx != values) + expandTuples(valuesx); + if (keysx->dim != valuesx->dim) + goto Lerr; + + /* Remove duplicate keys + */ + for (size_t i = 1; i < keysx->dim; i++) + { Expression *ekey = keysx->tdata()[i - 1]; + if (ekey->op == TOKslice) + ekey = resolveSlice(ekey); + for (size_t j = i; j < keysx->dim; j++) + { Expression *ekey2 = keysx->tdata()[j]; + Expression *ex = ctfeEqual(TOKequal, Type::tbool, ekey, ekey2); + if (ex == EXP_CANT_INTERPRET) + goto Lerr; + if (ex->isBool(TRUE)) // if a match + { + // Remove ekey + if (keysx == keys) + keysx = (Expressions *)keys->copy(); + if (valuesx == values) + valuesx = (Expressions *)values->copy(); + keysx->remove(i - 1); + valuesx->remove(i - 1); + i -= 1; // redo the i'th iteration + break; + } + } + } + + if (keysx != keys || valuesx != values) + { + AssocArrayLiteralExp *ae; + ae = new AssocArrayLiteralExp(loc, keysx, valuesx); + ae->type = type; + ae->ownedByCtfe = true; + return ae; + } + return this; + +Lerr: + if (keysx != keys) + delete keysx; + if (valuesx != values) + delete values; + return EXP_CANT_INTERPRET; +} + +Expression *StructLiteralExp::interpret(InterState *istate, CtfeGoal goal) +{ Expressions *expsx = NULL; + +#if LOG + printf("StructLiteralExp::interpret() %s\n", toChars()); +#endif + /* We don't know how to deal with overlapping fields + */ + if (sd->hasUnions) + { error("Unions with overlapping fields are not yet supported in CTFE"); + return EXP_CANT_INTERPRET; + } + if (ownedByCtfe) + return copyLiteral(this); + + if (elements) + { + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = elements->tdata()[i]; + if (!e) + continue; + + Expression *ex = e->interpret(istate); + if (exceptionOrCantInterpret(ex)) + { delete expsx; + return ex; + } + + /* If any changes, do Copy On Write + */ + if (ex != e) + { + if (!expsx) + { expsx = new Expressions(); + ++CtfeStatus::numArrayAllocs; + expsx->setDim(elements->dim); + for (size_t j = 0; j < elements->dim; j++) + { + expsx->tdata()[j] = elements->tdata()[j]; + } + } + expsx->tdata()[i] = ex; + } + } + } + if (elements && expsx) + { + expandTuples(expsx); + if (expsx->dim != elements->dim) + { delete expsx; + return EXP_CANT_INTERPRET; + } + StructLiteralExp *se = new StructLiteralExp(loc, sd, expsx); + se->type = type; + se->ownedByCtfe = true; + return se; + } + return copyLiteral(this); +} + +/****************************** + * Helper for NewExp + * Create an array literal consisting of 'elem' duplicated 'dim' times. + */ +ArrayLiteralExp *createBlockDuplicatedArrayLiteral(Loc loc, Type *type, + Expression *elem, size_t dim) +{ + Expressions *elements = new Expressions(); + elements->setDim(dim); + bool mustCopy = needToCopyLiteral(elem); + for (size_t i = 0; i < dim; i++) + { if (mustCopy) + elem = copyLiteral(elem); + elements->tdata()[i] = elem; + } + ArrayLiteralExp *ae = new ArrayLiteralExp(loc, elements); + ae->type = type; + ae->ownedByCtfe = true; + return ae; +} + +/****************************** + * Helper for NewExp + * Create a string literal consisting of 'value' duplicated 'dim' times. + */ +StringExp *createBlockDuplicatedStringLiteral(Loc loc, Type *type, + unsigned value, size_t dim, int sz) +{ + unsigned char *s; + s = (unsigned char *)mem.calloc(dim + 1, sz); + for (size_t elemi=0; elemitype = type; + se->sz = sz; + se->committed = true; + se->ownedByCtfe = true; + return se; +} + +// Create an array literal of type 'newtype' with dimensions given by +// 'arguments'[argnum..$] +Expression *recursivelyCreateArrayLiteral(Loc loc, Type *newtype, InterState *istate, + Expressions *arguments, int argnum) +{ + Expression *lenExpr = ((arguments->tdata()[argnum]))->interpret(istate); + if (exceptionOrCantInterpret(lenExpr)) + return lenExpr; + size_t len = (size_t)(lenExpr->toInteger()); + Type *elemType = ((TypeArray *)newtype)->next; + if (elemType->ty == Tarray && argnum < arguments->dim - 1) + { + Expression *elem = recursivelyCreateArrayLiteral(loc, elemType, istate, + arguments, argnum + 1); + if (exceptionOrCantInterpret(elem)) + return elem; + + Expressions *elements = new Expressions(); + elements->setDim(len); + for (size_t i = 0; i < len; i++) + elements->tdata()[i] = copyLiteral(elem); + ArrayLiteralExp *ae = new ArrayLiteralExp(loc, elements); + ae->type = newtype; + ae->ownedByCtfe = true; + return ae; + } + assert(argnum == arguments->dim - 1); + if (elemType->ty == Tchar || elemType->ty == Twchar + || elemType->ty == Tdchar) + return createBlockDuplicatedStringLiteral(loc, newtype, + (unsigned)(elemType->defaultInitLiteral()->toInteger()), + len, elemType->size()); + return createBlockDuplicatedArrayLiteral(loc, newtype, + elemType->defaultInitLiteral(), + len); +} + +Expression *NewExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("NewExp::interpret() %s\n", toChars()); +#endif + if (newtype->ty == Tarray && arguments) + return recursivelyCreateArrayLiteral(loc, newtype, istate, arguments, 0); + + if (newtype->toBasetype()->ty == Tstruct) + { + Expression *se = newtype->defaultInitLiteral(); +#if DMDV2 + if (member) + { + int olderrors = global.errors; + member->interpret(istate, arguments, se); + if (olderrors != global.errors) + { + error("cannot evaluate %s at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + } +#else // The above code would fail on D1 because it doesn't use STRUCTTHISREF, + // but that's OK because D1 doesn't have struct constructors anyway. + assert(!member); +#endif + Expression *e = new AddrExp(loc, copyLiteral(se)); + e->type = type; + return e; + } + if (newtype->toBasetype()->ty == Tclass) + { + ClassDeclaration *cd = ((TypeClass *)newtype->toBasetype())->sym; + size_t totalFieldCount = 0; + for (ClassDeclaration *c = cd; c; c = c->baseClass) + totalFieldCount += c->fields.dim; + Expressions *elems = new Expressions; + elems->setDim(totalFieldCount); + size_t fieldsSoFar = totalFieldCount; + for (ClassDeclaration *c = cd; c; c = c->baseClass) + { + fieldsSoFar -= c->fields.dim; + for (size_t i = 0; i < c->fields.dim; i++) + { + Dsymbol *s = c->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + Expression *m = v->init ? v->init->toExpression() : v->type->defaultInitLiteral(); + if (exceptionOrCantInterpret(m)) + return m; + elems->tdata()[fieldsSoFar+i] = copyLiteral(m); + } + } + // Hack: we store a ClassDeclaration instead of a StructDeclaration. + // We probably won't get away with this. + StructLiteralExp *se = new StructLiteralExp(loc, (StructDeclaration *)cd, elems, newtype); + se->ownedByCtfe = true; + Expression *e = new ClassReferenceExp(loc, se, type); + if (member) + { // Call constructor + if (!member->fbody) + { + Expression *ctorfail = evaluateIfBuiltin(istate, loc, member, arguments, e); + if (ctorfail && exceptionOrCantInterpret(ctorfail)) + return ctorfail; + if (ctorfail) + return e; + member->error("%s cannot be constructed at compile time, because the constructor has no available source code", newtype->toChars()); + return EXP_CANT_INTERPRET; + } + Expression * ctorfail = member->interpret(istate, arguments, e); + if (exceptionOrCantInterpret(ctorfail)) + return ctorfail; + } + return e; + } + error("Cannot interpret %s at compile time", toChars()); + return EXP_CANT_INTERPRET; +} + +Expression *UnaExp::interpretCommon(InterState *istate, CtfeGoal goal, Expression *(*fp)(Type *, Expression *)) +{ Expression *e; + Expression *e1; + +#if LOG + printf("UnaExp::interpretCommon() %s\n", toChars()); +#endif + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + e = (*fp)(type, e1); + return e; +} + +#define UNA_INTERPRET(op) \ +Expression *op##Exp::interpret(InterState *istate, CtfeGoal goal) \ +{ \ + return interpretCommon(istate, goal, &op); \ +} + +UNA_INTERPRET(Neg) +UNA_INTERPRET(Com) +UNA_INTERPRET(Not) +UNA_INTERPRET(Bool) + +Expression *getAggregateFromPointer(Expression *e, dinteger_t *ofs) +{ + *ofs = 0; + if (e->op == TOKaddress) + e = ((AddrExp *)e)->e1; + if (e->op == TOKdotvar) + { + Expression *ex = ((DotVarExp *)e)->e1; + VarDeclaration *v = ((DotVarExp *)e)->var->isVarDeclaration(); + assert(v); + StructLiteralExp *se = ex->op == TOKclassreference ? ((ClassReferenceExp *)ex)->value : (StructLiteralExp *)ex; + // We can't use getField, because it makes a copy + int i = -1; + if (ex->op == TOKclassreference) + i = ((ClassReferenceExp *)ex)->getFieldIndex(e->type, v->offset); + else + i = se->getFieldIndex(e->type, v->offset); + assert(i != -1); + e = se->elements->tdata()[i]; + } + if (e->op == TOKindex) + { + IndexExp *ie = (IndexExp *)e; + // Note that each AA element is part of its own memory block + if ((ie->e1->type->ty == Tarray || ie->e1->type->ty == Tsarray + || ie->e1->op == TOKstring || ie->e1->op==TOKarrayliteral) && + ie->e2->op == TOKint64) + { + *ofs = ie->e2->toInteger(); + return ie->e1; + } + } + return e; +} + +// return e1 - e2 as an integer, or error if not possible +Expression *pointerDifference(Loc loc, Type *type, Expression *e1, Expression *e2) +{ + dinteger_t ofs1, ofs2; + Expression *agg1 = getAggregateFromPointer(e1, &ofs1); + Expression *agg2 = getAggregateFromPointer(e2, &ofs2); + if (agg1 == agg2) + { + Type *pointee = ((TypePointer *)agg1->type)->next; + dinteger_t sz = pointee->size(); + return new IntegerExp(loc, (ofs1-ofs2)*sz, type); + } + else if (agg1->op == TOKstring && agg2->op == TOKstring) + { + if (((StringExp *)agg1)->string == ((StringExp *)agg2)->string) + { + Type *pointee = ((TypePointer *)agg1->type)->next; + dinteger_t sz = pointee->size(); + return new IntegerExp(loc, (ofs1-ofs2)*sz, type); + } + } +#if LOGASSIGN + printf("FAILED POINTER DIFF\n"); + showCtfeExpr(agg1); + showCtfeExpr(agg2); +#endif + error(loc, "%s - %s cannot be interpreted at compile time: cannot subtract " + "pointers to two different memory blocks", + e1->toChars(), e2->toChars()); + return EXP_CANT_INTERPRET; +} + +// Return eptr op e2, where eptr is a pointer, e2 is an integer, +// and op is TOKadd or TOKmin +Expression *pointerArithmetic(Loc loc, enum TOK op, Type *type, + Expression *eptr, Expression *e2) +{ + if (eptr->type->nextOf()->ty == Tvoid) + { + error(loc, "cannot perform arithmetic on void* pointers at compile time"); + return EXP_CANT_INTERPRET; + } + dinteger_t ofs1, ofs2; + if (eptr->op == TOKaddress) + eptr = ((AddrExp *)eptr)->e1; + Expression *agg1 = getAggregateFromPointer(eptr, &ofs1); + if (agg1->op != TOKstring && agg1->op != TOKarrayliteral) + { + error(loc, "cannot perform pointer arithmetic on non-arrays at compile time"); + return EXP_CANT_INTERPRET; + } + ofs2 = e2->toInteger(); + Type *pointee = ((TypePointer *)agg1->type)->next; + dinteger_t sz = pointee->size(); + Expression *dollar = ArrayLength(Type::tsize_t, agg1); + assert(dollar != EXP_CANT_INTERPRET); + dinteger_t len = dollar->toInteger(); + + Expression *val = agg1; + TypeArray *tar = (TypeArray *)val->type; + dinteger_t indx = ofs1; + if (op == TOKadd || op == TOKaddass || op == TOKplusplus) + indx = indx + ofs2/sz; + else if (op == TOKmin || op == TOKminass || op == TOKminusminus) + indx -= ofs2/sz; + else + { + error(loc, "CTFE Internal compiler error: bad pointer operation"); + return EXP_CANT_INTERPRET; + } + if (val->op != TOKarrayliteral && val->op != TOKstring) + { + error(loc, "CTFE Internal compiler error: pointer arithmetic %s", val->toChars()); + return EXP_CANT_INTERPRET; + } + if (indx < 0 || indx > len) + { + error(loc, "cannot assign pointer to index %jd inside memory block [0..%jd]", indx, len); + return EXP_CANT_INTERPRET; + } + + IntegerExp *ofs = new IntegerExp(loc, indx, Type::tsize_t); + IndexExp *ie = new IndexExp(loc, val, ofs); + ie->type = type; + return ie; +} + +typedef Expression *(*fp_t)(Type *, Expression *, Expression *); + +Expression *BinExp::interpretCommon(InterState *istate, CtfeGoal goal, fp_t fp) +{ Expression *e; + Expression *e1; + Expression *e2; + +#if LOG + printf("BinExp::interpretCommon() %s\n", toChars()); +#endif + if (this->e1->type->ty == Tpointer && this->e2->type->ty == Tpointer && op == TOKmin) + { + e1 = this->e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + e2 = this->e2->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e2)) + return e2; + return pointerDifference(loc, type, e1, e2); + } + if (this->e1->type->ty == Tpointer && this->e2->type->isintegral()) + { + e1 = this->e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + return pointerArithmetic(loc, op, type, e1, e2); + } + if (this->e2->type->ty == Tpointer && this->e1->type->isintegral() && op==TOKadd) + { + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + e2 = this->e2->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e2)) + return e1; + return pointerArithmetic(loc, op, type, e2, e1); + } + if (this->e1->type->ty == Tpointer || this->e2->type->ty == Tpointer) + { + error("pointer expression %s cannot be interpreted at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->isConst() != 1) + goto Lcant; + + e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + if (e2->isConst() != 1) + goto Lcant; + + e = (*fp)(type, e1, e2); + if (e == EXP_CANT_INTERPRET) + error("%s cannot be interpreted at compile time", toChars()); + return e; + +Lcant: + return EXP_CANT_INTERPRET; +} + +#define BIN_INTERPRET(op) \ +Expression *op##Exp::interpret(InterState *istate, CtfeGoal goal) \ +{ \ + return interpretCommon(istate, goal, &op); \ +} + +BIN_INTERPRET(Add) +BIN_INTERPRET(Min) +BIN_INTERPRET(Mul) +BIN_INTERPRET(Div) +BIN_INTERPRET(Mod) +BIN_INTERPRET(Shl) +BIN_INTERPRET(Shr) +BIN_INTERPRET(Ushr) +BIN_INTERPRET(And) +BIN_INTERPRET(Or) +BIN_INTERPRET(Xor) +#if DMDV2 +BIN_INTERPRET(Pow) +#endif + + +typedef Expression *(*fp2_t)(enum TOK, Type *, Expression *, Expression *); + +// Return EXP_CANT_INTERPRET if they point to independent memory blocks +Expression *comparePointers(Loc loc, enum TOK op, Type *type, Expression *e1, Expression *e2) +{ + dinteger_t ofs1, ofs2; + Expression *agg1 = getAggregateFromPointer(e1, &ofs1); + Expression *agg2 = getAggregateFromPointer(e2, &ofs2); + // Note that type painting can occur with VarExp, so we + // must compare the variables being pointed to. + if (agg1 == agg2 || + (agg1->op == TOKvar && agg2->op == TOKvar && + ((VarExp *)agg1)->var == ((VarExp *)agg2)->var) + ) + { + dinteger_t cm = ofs1 - ofs2; + dinteger_t n; + dinteger_t zero = 0; + switch(op) + { + case TOKlt: n = (ofs1 < ofs2); break; + case TOKle: n = (ofs1 <= ofs2); break; + case TOKgt: n = (ofs1 > ofs2); break; + case TOKge: n = (ofs1 >= ofs2); break; + case TOKidentity: + case TOKequal: n = (ofs1 == ofs2); break; + case TOKnotidentity: + case TOKnotequal: n = (ofs1 != ofs2); break; + default: + assert(0); + } + return new IntegerExp(loc, n, type); + } + int cmp; + if (agg1->op == TOKnull) + { + cmp = (agg2->op == TOKnull); + } + else if (agg2->op == TOKnull) + { + cmp = 0; + } + else + { + switch(op) + { + case TOKidentity: + case TOKequal: + case TOKnotidentity: // 'cmp' gets inverted below + case TOKnotequal: + cmp = 0; + break; + default: + return EXP_CANT_INTERPRET; + } + } + if (op == TOKnotidentity || op == TOKnotequal) + cmp ^= 1; + return new IntegerExp(loc, cmp, type); +} + +Expression *ctfeIdentity(enum TOK op, Type *type, Expression *e1, Expression *e2) +{ + if (e1->op == TOKclassreference || e2->op == TOKclassreference) + { + int cmp = 0; + if (e1->op == TOKclassreference && e2->op == TOKclassreference && + ((ClassReferenceExp *)e1)->value == ((ClassReferenceExp *)e2)->value) + cmp = 1; + if (op == TOKnotidentity || op == TOKnotequal) + cmp ^= 1; + return new IntegerExp(e1->loc, cmp, type); + } + return Identity(op, type, e1, e2); +} + + +Expression *BinExp::interpretCommon2(InterState *istate, CtfeGoal goal, fp2_t fp) +{ Expression *e; + Expression *e1; + Expression *e2; + +#if LOG + printf("BinExp::interpretCommon2() %s\n", toChars()); +#endif + if (this->e1->type->ty == Tpointer && this->e2->type->ty == Tpointer) + { + e1 = this->e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + e2 = this->e2->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e2)) + return e2; + e = comparePointers(loc, op, type, e1, e2); + if (e == EXP_CANT_INTERPRET) + { + error("%s and %s point to independent memory blocks and " + "cannot be compared at compile time", this->e1->toChars(), + this->e2->toChars()); + } + return e; + } + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKslice) + e1 = resolveSlice(e1); + + if (e1->isConst() != 1 && + e1->op != TOKnull && + e1->op != TOKstring && + e1->op != TOKarrayliteral && + e1->op != TOKstructliteral && + e1->op != TOKclassreference) + { + error("cannot compare %s at compile time", e1->toChars()); + goto Lcant; + } + + e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + if (e2->op == TOKslice) + e2 = resolveSlice(e2); + if (e2->isConst() != 1 && + e2->op != TOKnull && + e2->op != TOKstring && + e2->op != TOKarrayliteral && + e2->op != TOKstructliteral && + e2->op != TOKclassreference) + { + error("cannot compare %s at compile time", e2->toChars()); + goto Lcant; + } + e = (*fp)(op, type, e1, e2); + if (e == EXP_CANT_INTERPRET) + error("%s cannot be interpreted at compile time", toChars()); + return e; + +Lcant: + return EXP_CANT_INTERPRET; +} + +#define BIN_INTERPRET2(op, opfunc) \ +Expression *op##Exp::interpret(InterState *istate, CtfeGoal goal) \ +{ \ + return interpretCommon2(istate, goal, &opfunc); \ +} + +BIN_INTERPRET2(Equal, Equal) +BIN_INTERPRET2(Identity, ctfeIdentity) +BIN_INTERPRET2(Cmp, Cmp) + +/* Helper functions for BinExp::interpretAssignCommon + */ + +/*************************************** + * Duplicate the elements array, then set field 'indexToChange' = newelem. + */ +Expressions *changeOneElement(Expressions *oldelems, size_t indexToChange, Expression *newelem) +{ + Expressions *expsx = new Expressions(); + ++CtfeStatus::numArrayAllocs; + expsx->setDim(oldelems->dim); + for (size_t j = 0; j < expsx->dim; j++) + { + if (j == indexToChange) + expsx->tdata()[j] = newelem; + else + expsx->tdata()[j] = oldelems->tdata()[j]; + } + return expsx; +} + +// Create a new struct literal, which is the same as se except that se.field[offset] = elem +Expression * modifyStructField(Type *type, StructLiteralExp *se, size_t offset, Expression *newval) +{ + int fieldi = se->getFieldIndex(newval->type, offset); + if (fieldi == -1) + return EXP_CANT_INTERPRET; + /* Create new struct literal reflecting updated fieldi + */ + Expressions *expsx = changeOneElement(se->elements, fieldi, newval); + StructLiteralExp * ee = new StructLiteralExp(se->loc, se->sd, expsx); + ee->type = se->type; + ee->ownedByCtfe = 1; + return ee; +} + +/******************************** + * Given an array literal arr (either arrayliteral, stringliteral, or assocArrayLiteral), + * set arr[index] = newval and return the new array. + * + */ +Expression *assignAssocArrayElement(Loc loc, AssocArrayLiteralExp *aae, Expression *index, Expression *newval) +{ + /* Create new associative array literal reflecting updated key/value + */ + Expressions *keysx = aae->keys; + Expressions *valuesx = aae->values; + int updated = 0; + for (size_t j = valuesx->dim; j; ) + { j--; + Expression *ekey = aae->keys->tdata()[j]; + Expression *ex = ctfeEqual(TOKequal, Type::tbool, ekey, index); + if (exceptionOrCantInterpret(ex)) + return ex; + if (ex->isBool(TRUE)) + { valuesx->tdata()[j] = newval; + updated = 1; + } + } + if (!updated) + { // Append index/newval to keysx[]/valuesx[] + valuesx->push(newval); + keysx->push(index); + } + return newval; +} + +// Return true if e is derived from UnaryExp. +// Consider moving this function into Expression. +UnaExp *isUnaExp(Expression *e) +{ + switch (e->op) + { + case TOKdotvar: + case TOKindex: + case TOKslice: + case TOKcall: + case TOKdot: + case TOKdotti: + case TOKdottype: + case TOKcast: + return (UnaExp *)e; + default: + break; + } + return NULL; +} + +// Returns the variable which is eventually modified, or NULL if an rvalue. +// thisval is the current value of 'this'. +VarDeclaration * findParentVar(Expression *e, Expression *thisval) +{ + for (;;) + { + e = resolveReferences(e, thisval); + if (e->op == TOKvar) + break; + if (e->op == TOKindex) + e = ((IndexExp*)e)->e1; + else if (e->op == TOKdotvar) + e = ((DotVarExp *)e)->e1; + else if (e->op == TOKdotti) + e = ((DotTemplateInstanceExp *)e)->e1; + else if (e->op == TOKslice) + e = ((SliceExp*)e)->e1; + else + return NULL; + } + VarDeclaration *v = ((VarExp *)e)->var->isVarDeclaration(); + assert(v); + return v; +} + +// Given expr, which evaluates to an array/AA/string literal, +// return true if it needs to be copied +bool needToCopyLiteral(Expression *expr) +{ + for (;;) + { + switch (expr->op) + { + case TOKarrayliteral: + return !((ArrayLiteralExp *)expr)->ownedByCtfe; + case TOKassocarrayliteral: + return !((AssocArrayLiteralExp *)expr)->ownedByCtfe; + case TOKstructliteral: + return !((StructLiteralExp *)expr)->ownedByCtfe; + case TOKstring: + case TOKthis: + case TOKvar: + return false; + case TOKassign: + return false; + case TOKindex: + case TOKdotvar: + case TOKslice: + case TOKcast: + expr = ((UnaExp *)expr)->e1; + continue; + case TOKcat: + return needToCopyLiteral(((BinExp *)expr)->e1) || + needToCopyLiteral(((BinExp *)expr)->e2); + case TOKcatass: + expr = ((BinExp *)expr)->e2; + continue; + default: + return false; + } + } +} + +Expressions *copyLiteralArray(Expressions *oldelems) +{ + if (!oldelems) + return oldelems; + CtfeStatus::numArrayAllocs++; + Expressions *newelems = new Expressions(); + newelems->setDim(oldelems->dim); + for (size_t i = 0; i < oldelems->dim; i++) + newelems->tdata()[i] = copyLiteral(oldelems->tdata()[i]); + return newelems; +} + + + +// Make a copy of the ArrayLiteral, AALiteral, String, or StructLiteral. +// This value will be used for in-place modification. +Expression *copyLiteral(Expression *e) +{ + if (e->op == TOKstring) // syntaxCopy doesn't make a copy for StringExp! + { + StringExp *se = (StringExp *)e; + unsigned char *s; + s = (unsigned char *)mem.calloc(se->len + 1, se->sz); + memcpy(s, se->string, se->len * se->sz); + StringExp *se2 = new StringExp(se->loc, s, se->len); + se2->committed = se->committed; + se2->postfix = se->postfix; + se2->type = se->type; + se2->sz = se->sz; + se2->ownedByCtfe = true; + return se2; + } + else if (e->op == TOKarrayliteral) + { + ArrayLiteralExp *ae = (ArrayLiteralExp *)e; + ArrayLiteralExp *r = new ArrayLiteralExp(e->loc, + copyLiteralArray(ae->elements)); + r->type = e->type; + r->ownedByCtfe = true; + return r; + } + else if (e->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)e; + AssocArrayLiteralExp *r = new AssocArrayLiteralExp(e->loc, + copyLiteralArray(aae->keys), copyLiteralArray(aae->values)); + r->type = e->type; + r->ownedByCtfe = true; + return r; + } + /* syntaxCopy doesn't work for struct literals, because of a nasty special + * case: block assignment is permitted inside struct literals, eg, + * an int[4] array can be initialized with a single int. + */ + else if (e->op == TOKstructliteral) + { + StructLiteralExp *se = (StructLiteralExp *)e; + Expressions *oldelems = se->elements; + Expressions * newelems = new Expressions(); + newelems->setDim(oldelems->dim); + for (size_t i = 0; i < newelems->dim; i++) + { + Expression *m = oldelems->tdata()[i]; + // We need the struct definition to detect block assignment + AggregateDeclaration *sd = se->sd; + Dsymbol *s = sd->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v); + // If it is a void assignment, use the default initializer + if (!m) + m = v->type->defaultInitLiteral(e->loc); + if (m->op == TOKslice) + m = resolveSlice(m); + if ((v->type->ty != m->type->ty) && v->type->ty == Tsarray) + { + // Block assignment from inside struct literals + TypeSArray *tsa = (TypeSArray *)v->type; + uinteger_t length = tsa->dim->toInteger(); + m = createBlockDuplicatedArrayLiteral(e->loc, v->type, m, (size_t)length); + } + else if (v->type->ty != Tarray && v->type->ty!=Taarray) // NOTE: do not copy array references + m = copyLiteral(m); + newelems->tdata()[i] = m; + } +#if DMDV2 + StructLiteralExp *r = new StructLiteralExp(e->loc, se->sd, newelems, se->stype); +#else + StructLiteralExp *r = new StructLiteralExp(e->loc, se->sd, newelems); +#endif + r->type = e->type; + r->ownedByCtfe = true; + return r; + } + else if (e->op == TOKfunction || e->op == TOKdelegate + || e->op == TOKsymoff || e->op == TOKnull + || e->op == TOKvar + || e->op == TOKint64 || e->op == TOKfloat64 + || e->op == TOKchar || e->op == TOKcomplex80) + { // Simple value types + Expression *r = e->syntaxCopy(); + r->type = e->type; + return r; + } + else if ( isPointer(e->type) ) + { // For pointers, we only do a shallow copy. + Expression *r; + if (e->op == TOKaddress) + r = new AddrExp(e->loc, ((AddrExp *)e)->e1); + else if (e->op == TOKindex) + r = new IndexExp(e->loc, ((IndexExp *)e)->e1, ((IndexExp *)e)->e2); + else if (e->op == TOKdotvar) + r = new DotVarExp(e->loc, ((DotVarExp *)e)->e1, + ((DotVarExp *)e)->var +#if DMDV2 + , ((DotVarExp *)e)->hasOverloads +#endif + ); + else + assert(0); + r->type = e->type; + return r; + } + else if (e->op == TOKslice) + { // Array slices only do a shallow copy + Expression *r = new SliceExp(e->loc, ((SliceExp *)e)->e1, + ((SliceExp *)e)->lwr, ((SliceExp *)e)->upr); + r->type = e->type; + return r; + } + else if (e->op == TOKclassreference) + return new ClassReferenceExp(e->loc, ((ClassReferenceExp *)e)->value, e->type); + else + { + e->error("Internal Compiler Error: CTFE literal %s", e->toChars()); + assert(0); + return e; + } +} + +/* Deal with type painting. + * Type painting is a major nuisance: we can't just set + * e->type = type, because that would change the original literal. + * But, we can't simply copy the literal either, because that would change + * the values of any pointers. + */ +Expression *paintTypeOntoLiteral(Type *type, Expression *lit) +{ + if (lit->type == type) + return lit; + Expression *e; + if (lit->op == TOKslice) + { + SliceExp *se = (SliceExp *)lit; + e = new SliceExp(lit->loc, se->e1, se->lwr, se->upr); + } + else if (lit->op == TOKindex) + { + IndexExp *ie = (IndexExp *)lit; + e = new IndexExp(lit->loc, ie->e1, ie->e2); + } + else if (lit->op == TOKarrayliteral) + { + e = new SliceExp(lit->loc, lit, + new IntegerExp(0, 0, Type::tsize_t), ArrayLength(Type::tsize_t, lit)); + } + else if (lit->op == TOKstring) + { + // For strings, we need to introduce another level of indirection + e = new SliceExp(lit->loc, lit, + new IntegerExp(0, 0, Type::tsize_t), ArrayLength(Type::tsize_t, lit)); + } + else if (lit->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)lit; + // TODO: we should be creating a reference to this AAExp, not + // just a ref to the keys and values. + bool wasOwned = aae->ownedByCtfe; + aae = new AssocArrayLiteralExp(lit->loc, aae->keys, aae->values); + aae->ownedByCtfe = wasOwned; + e = aae; + } + else + { // Can't type paint from struct to struct*; this needs another + // level of indirection + if (lit->op == TOKstructliteral && isPointer(type) ) + lit->error("CTFE internal error painting %s", type->toChars()); + e = copyLiteral(lit); + } + e->type = type; + return e; +} + + +Expression *ctfeCast(Loc loc, Type *type, Type *to, Expression *e) +{ + if (e->op == TOKnull) + return paintTypeOntoLiteral(to, e); + if (e->op == TOKclassreference) + { // Disallow reinterpreting class casts. Do this by ensuring that + // the original class can implicitly convert to the target class + ClassDeclaration *originalClass = ((ClassReferenceExp *)e)->originalClass(); + if (originalClass->type->implicitConvTo(to)) + return paintTypeOntoLiteral(to, e); + else + return new NullExp(loc, to); + } + Expression *r = Cast(type, to, e); + if (r == EXP_CANT_INTERPRET) + error(loc, "cannot cast %s to %s at compile time", e->toChars(), to->toChars()); + if (e->op == TOKarrayliteral) + ((ArrayLiteralExp *)e)->ownedByCtfe = true; + if (e->op == TOKstring) + ((StringExp *)e)->ownedByCtfe = true; + return r; +} + +/* Set dest = src, where both dest and src are container value literals + * (ie, struct literals, or static arrays (can be an array literal or a string) + * Assignment is recursively in-place. + * Purpose: any reference to a member of 'dest' will remain valid after the + * assignment. + */ +void assignInPlace(Expression *dest, Expression *src) +{ + assert(dest->op == TOKstructliteral || dest->op == TOKarrayliteral || + dest->op == TOKstring); + Expressions *oldelems; + Expressions *newelems; + if (dest->op == TOKstructliteral) + { + assert(dest->op == src->op); + oldelems = ((StructLiteralExp *)dest)->elements; + newelems = ((StructLiteralExp *)src)->elements; + } + else if (dest->op == TOKarrayliteral && src->op==TOKarrayliteral) + { + oldelems = ((ArrayLiteralExp *)dest)->elements; + newelems = ((ArrayLiteralExp *)src)->elements; + } + else if (dest->op == TOKstring && src->op == TOKstring) + { + sliceAssignStringFromString((StringExp *)dest, (StringExp *)src, 0); + return; + } + else if (dest->op == TOKarrayliteral && src->op == TOKstring) + { + sliceAssignArrayLiteralFromString((ArrayLiteralExp *)dest, (StringExp *)src, 0); + return; + } + else if (src->op == TOKarrayliteral && dest->op == TOKstring) + { + sliceAssignStringFromArrayLiteral((StringExp *)dest, (ArrayLiteralExp *)src, 0); + return; + } + else assert(0); + + assert(oldelems->dim == newelems->dim); + + for (size_t i= 0; i < oldelems->dim; ++i) + { + Expression *e = newelems->tdata()[i]; + Expression *o = oldelems->tdata()[i]; + if (e->op == TOKstructliteral) + { + assert(o->op == e->op); + assignInPlace(o, e); + } + else if (e->type->ty == Tsarray && o->type->ty == Tsarray) + { + assignInPlace(o, e); + } + else + { + oldelems->tdata()[i] = newelems->tdata()[i]; + } + } +} + +void recursiveBlockAssign(ArrayLiteralExp *ae, Expression *val, bool wantRef) +{ + assert( ae->type->ty == Tsarray || ae->type->ty == Tarray); +#if DMDV2 + Type *desttype = ((TypeArray *)ae->type)->next->castMod(0); + bool directblk = (val->type->toBasetype()->castMod(0)) == desttype; +#else + Type *desttype = ((TypeArray *)ae->type)->next; + bool directblk = (val->type->toBasetype()) == desttype; +#endif + + bool cow = !(val->op == TOKstructliteral || val->op == TOKarrayliteral + || val->op == TOKstring); + + for (size_t k = 0; k < ae->elements->dim; k++) + { + if (!directblk && ae->elements->tdata()[k]->op == TOKarrayliteral) + { + recursiveBlockAssign((ArrayLiteralExp *)ae->elements->tdata()[k], val, wantRef); + } + else + { + if (wantRef || cow) + ae->elements->tdata()[k] = val; + else + assignInPlace(ae->elements->tdata()[k], val); + } + } +} + + +Expression *BinExp::interpretAssignCommon(InterState *istate, CtfeGoal goal, fp_t fp, int post) +{ +#if LOG + printf("BinExp::interpretAssignCommon() %s\n", toChars()); +#endif + Expression *returnValue = EXP_CANT_INTERPRET; + Expression *e1 = this->e1; + if (!istate) + { + error("value of %s is not known at compile time", e1->toChars()); + return returnValue; + } + ++CtfeStatus::numAssignments; + /* Before we begin, we need to know if this is a reference assignment + * (dynamic array, AA, or class) or a value assignment. + * Determining this for slice assignments are tricky: we need to know + * if it is a block assignment (a[] = e) rather than a direct slice + * assignment (a[] = b[]). Note that initializers of multi-dimensional + * static arrays can have 2D block assignments (eg, int[7][7] x = 6;). + * So we need to recurse to determine if it is a block assignment. + */ + bool isBlockAssignment = false; + if (e1->op == TOKslice) + { + // a[] = e can have const e. So we compare the naked types. + Type *desttype = e1->type->toBasetype(); +#if DMDV2 + Type *srctype = e2->type->toBasetype()->castMod(0); +#else + Type *srctype = e2->type->toBasetype(); +#endif + while ( desttype->ty == Tsarray || desttype->ty == Tarray) + { + desttype = ((TypeArray *)desttype)->next; +#if DMDV2 + if (srctype == desttype->castMod(0)) +#else + if (srctype == desttype) +#endif + { + isBlockAssignment = true; + break; + } + } + } + bool wantRef = false; + if (!fp && this->e1->type->toBasetype() == this->e2->type->toBasetype() && + (e1->type->toBasetype()->ty == Tarray || isAssocArray(e1->type)) + // e = *x is never a reference, because *x is always a value + && this->e2->op != TOKstar + ) + { +#if DMDV2 + wantRef = true; +#else + /* D1 doesn't have const in the type system. But there is still a + * vestigal const in the form of static const variables. + * Problematic code like: + * const int [] x = [1,2,3]; + * int [] y = x; + * can be dealt with by making this a non-ref assign (y = x.dup). + * Otherwise it's a big mess. + */ + VarDeclaration * targetVar = findParentVar(e2, istate->localThis); + if (!(targetVar && targetVar->isConst())) + wantRef = true; + // slice assignment of static arrays is not reference assignment + if ((e1->op==TOKslice) && ((SliceExp *)e1)->e1->type->ty == Tsarray) + wantRef = false; +#endif + // If it is assignment from a ref parameter, it's not a ref assignment + if (this->e2->op == TOKvar) + { + VarDeclaration *v = ((VarExp *)this->e2)->var->isVarDeclaration(); + if (v && (v->storage_class & (STCref | STCout))) + wantRef = false; + } + } + if (isBlockAssignment && (e2->type->toBasetype()->ty == Tarray || e2->type->toBasetype()->ty == Tsarray)) + { + wantRef = true; + } + // If it is a construction of a ref variable, it is a ref assignment + if (op == TOKconstruct && this->e1->op==TOKvar + && ((VarExp*)this->e1)->var->storage_class & STCref) + { + wantRef = true; + } + + if (fp) + { + while (e1->op == TOKcast) + { CastExp *ce = (CastExp *)e1; + e1 = ce->e1; + } + } + if (exceptionOrCantInterpret(e1)) + return e1; + + // First, deal with this = e; and call() = e; + if (e1->op == TOKthis) + { + e1 = istate->localThis; + } + if (e1->op == TOKcall) + { + bool oldWaiting = istate->awaitingLvalueReturn; + istate->awaitingLvalueReturn = true; + e1 = e1->interpret(istate); + istate->awaitingLvalueReturn = oldWaiting; + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKarrayliteral || e1->op == TOKstring) + { + // f() = e2, when f returns an array, is always a slice assignment. + // Convert into arr[0..arr.length] = e2 + e1 = new SliceExp(loc, e1, + new IntegerExp(0, 0, Type::tsize_t), + ArrayLength(Type::tsize_t, e1)); + e1->type = type; + } + } + if (e1->op == TOKstar) + { + e1 = e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + if (!(e1->op == TOKvar || e1->op == TOKdotvar || e1->op == TOKindex + || e1->op == TOKslice)) + { + error("cannot dereference invalid pointer %s", + this->e1->toChars()); + return EXP_CANT_INTERPRET; + } + } + + if (!(e1->op == TOKarraylength || e1->op == TOKvar || e1->op == TOKdotvar + || e1->op == TOKindex || e1->op == TOKslice)) + { + error("CTFE internal error: unsupported assignment %s", toChars()); + return EXP_CANT_INTERPRET; + } + + Expression * newval = NULL; + + if (!wantRef) + { // We need to treat pointers specially, because TOKsymoff can be used to + // return a value OR a pointer + assert(e1); + assert(e1->type); + if ( isPointer(e1->type) && (e2->op == TOKsymoff || e2->op==TOKaddress || e2->op==TOKvar)) + newval = this->e2->interpret(istate, ctfeNeedLvalue); + else + newval = this->e2->interpret(istate); + if (exceptionOrCantInterpret(newval)) + return newval; + } + // ---------------------------------------------------- + // Deal with read-modify-write assignments. + // Set 'newval' to the final assignment value + // Also determine the return value (except for slice + // assignments, which are more complicated) + // ---------------------------------------------------- + + if (fp || e1->op == TOKarraylength) + { + // If it isn't a simple assignment, we need the existing value + Expression * oldval = e1->interpret(istate); + if (exceptionOrCantInterpret(oldval)) + return oldval; + while (oldval->op == TOKvar) + { + oldval = resolveReferences(oldval, istate->localThis); + oldval = oldval->interpret(istate); + if (exceptionOrCantInterpret(oldval)) + return oldval; + } + + if (fp) + { + // ~= can create new values (see bug 6052) + if (op == TOKcatass) + { + // We need to dup it. We can skip this if it's a dynamic array, + // because it gets copied later anyway + if (newval->type->ty != Tarray) + newval = copyLiteral(newval); + if (newval->op == TOKslice) + newval = resolveSlice(newval); + // It becomes a reference assignment + wantRef = true; + } + if (oldval->op == TOKslice) + oldval = resolveSlice(oldval); + if (this->e1->type->ty == Tpointer && this->e2->type->isintegral() + && (op==TOKaddass || op == TOKminass || + op == TOKplusplus || op == TOKminusminus)) + { + oldval = this->e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(oldval)) + return oldval; + newval = this->e2->interpret(istate); + if (exceptionOrCantInterpret(newval)) + return newval; + newval = pointerArithmetic(loc, op, type, oldval, newval); + } + else if (this->e1->type->ty == Tpointer) + { + error("pointer expression %s cannot be interpreted at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + else + { + newval = (*fp)(type, oldval, newval); + } + if (newval == EXP_CANT_INTERPRET) + { + error("Cannot interpret %s at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + if (exceptionOrCantInterpret(newval)) + return newval; + // Determine the return value + returnValue = ctfeCast(loc, type, type, post ? oldval : newval); + if (exceptionOrCantInterpret(returnValue)) + return returnValue; + } + else + returnValue = newval; + if (e1->op == TOKarraylength) + { + size_t oldlen = oldval->toInteger(); + size_t newlen = newval->toInteger(); + if (oldlen == newlen) // no change required -- we're done! + return returnValue; + // Now change the assignment from arr.length = n into arr = newval + e1 = ((ArrayLengthExp *)e1)->e1; + if (oldlen != 0) + { // Get the old array literal. + oldval = e1->interpret(istate); + while (oldval->op == TOKvar) + { oldval = resolveReferences(oldval, istate->localThis); + oldval = oldval->interpret(istate); + } + } + if (oldval->op == TOKslice) + oldval = resolveSlice(oldval); + Type *t = e1->type->toBasetype(); + if (t->ty == Tarray) + { + Type *elemType= NULL; + elemType = ((TypeArray *)t)->next; + assert(elemType); + Expression *defaultElem = elemType->defaultInitLiteral(); + + Expressions *elements = new Expressions(); + elements->setDim(newlen); + size_t copylen = oldlen < newlen ? oldlen : newlen; + if (oldval->op == TOKstring) + { + StringExp *oldse = (StringExp *)oldval; + unsigned char *s = (unsigned char *)mem.calloc(newlen + 1, oldse->sz); + memcpy(s, oldse->string, copylen * oldse->sz); + unsigned defaultValue = (unsigned)(defaultElem->toInteger()); + for (size_t elemi = copylen; elemi < newlen; ++elemi) + { + switch (oldse->sz) + { + case 1: s[elemi] = defaultValue; break; + case 2: ((unsigned short *)s)[elemi] = defaultValue; break; + case 4: ((unsigned *)s)[elemi] = defaultValue; break; + default: assert(0); + } + } + StringExp *se = new StringExp(loc, s, newlen); + se->type = t; + se->sz = oldse->sz; + se->committed = oldse->committed; + se->ownedByCtfe = true; + newval = se; + } + else + { + if (oldlen !=0) + assert(oldval->op == TOKarrayliteral); + ArrayLiteralExp *ae = (ArrayLiteralExp *)oldval; + for (size_t i = 0; i < copylen; i++) + elements->tdata()[i] = ae->elements->tdata()[i]; + if (elemType->ty == Tstruct || elemType->ty == Tsarray) + { /* If it is an aggregate literal representing a value type, + * we need to create a unique copy for each element + */ + for (size_t i = copylen; i < newlen; i++) + elements->tdata()[i] = copyLiteral(defaultElem); + } + else + { + for (size_t i = copylen; i < newlen; i++) + elements->tdata()[i] = defaultElem; + } + ArrayLiteralExp *aae = new ArrayLiteralExp(0, elements); + aae->type = t; + newval = aae; + aae->ownedByCtfe = true; + } + // We have changed it into a reference assignment + // Note that returnValue is still the new length. + wantRef = true; + if (e1->op == TOKstar) + { // arr.length+=n becomes (t=&arr, *(t).length=*(t).length+n); + e1 = e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + } + } + else + { + error("%s is not yet supported at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + + } + } + else if (!wantRef && e1->op != TOKslice) + { /* Look for special case of struct being initialized with 0. + */ + if (type->toBasetype()->ty == Tstruct && newval->op == TOKint64) + { + newval = type->defaultInitLiteral(loc); + if (newval->op != TOKstructliteral) + { + error("nested structs with constructors are not yet supported in CTFE (Bug 6419)"); + return EXP_CANT_INTERPRET; + } + } + newval = ctfeCast(loc, type, type, newval); + if (exceptionOrCantInterpret(newval)) + return newval; + returnValue = newval; + } + if (exceptionOrCantInterpret(newval)) + return newval; + + // ------------------------------------------------- + // Make sure destination can be modified + // ------------------------------------------------- + // Make sure we're not trying to modify a global or static variable + // We do this by locating the ultimate parent variable which gets modified. + VarDeclaration * ultimateVar = findParentVar(e1, istate->localThis); + if (ultimateVar && ultimateVar->isDataseg() && !ultimateVar->isCTFE()) + { // Can't modify global or static data + error("%s cannot be modified at compile time", ultimateVar->toChars()); + return EXP_CANT_INTERPRET; + } + + e1 = resolveReferences(e1, istate->localThis); + + // Unless we have a simple var assignment, we're + // only modifying part of the variable. So we need to make sure + // that the parent variable exists. + if (e1->op != TOKvar && ultimateVar && !ultimateVar->getValue()) + ultimateVar->setValue(copyLiteral(ultimateVar->type->defaultInitLiteral())); + + // --------------------------------------- + // Deal with reference assignment + // (We already have 'newval' for arraylength operations) + // --------------------------------------- + if (wantRef && !fp && this->e1->op != TOKarraylength) + { + newval = this->e2->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(newval)) + return newval; + // If it is an assignment from a array function parameter passed by + // reference, resolve the reference. (This should NOT happen for + // non-reference types). + if (newval->op == TOKvar && (newval->type->ty == Tarray || + newval->type->ty == Tclass)) + { + newval = newval->interpret(istate); + } + + if (newval->op == TOKassocarrayliteral || newval->op == TOKstring || + newval->op==TOKarrayliteral) + { + if (needToCopyLiteral(newval)) + newval = copyLiteral(newval); + } + returnValue = newval; + } + + // --------------------------------------- + // Deal with AA index assignment + // --------------------------------------- + /* This needs special treatment if the AA doesn't exist yet. + * There are two special cases: + * (1) If the AA is itself an index of another AA, we may need to create + * multiple nested AA literals before we can insert the new value. + * (2) If the ultimate AA is null, no insertion happens at all. Instead, we + * create nested AA literals, and change it into a assignment. + */ + if (e1->op == TOKindex && ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + IndexExp *ie = (IndexExp *)e1; + int depth = 0; // how many nested AA indices are there? + while (ie->e1->op == TOKindex && ((IndexExp *)ie->e1)->e1->type->toBasetype()->ty == Taarray) + { + ie = (IndexExp *)ie->e1; + ++depth; + } + Expression *aggregate = resolveReferences(ie->e1, istate->localThis); + Expression *oldagg = aggregate; + // Get the AA to be modified. (We do an LvalueRef interpret, unless it + // is a simple ref parameter -- in which case, we just want the value) + aggregate = aggregate->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + if (aggregate->op == TOKassocarrayliteral) + { // Normal case, ultimate parent AA already exists + // We need to walk from the deepest index up, checking that an AA literal + // already exists on each level. + Expression *index = ((IndexExp *)e1)->e2->interpret(istate); + if (exceptionOrCantInterpret(index)) + return index; + if (index->op == TOKslice) // only happens with AA assignment + index = resolveSlice(index); + AssocArrayLiteralExp *existingAA = (AssocArrayLiteralExp *)aggregate; + while (depth > 0) + { // Walk the syntax tree to find the indexExp at this depth + IndexExp *xe = (IndexExp *)e1; + for (int d= 0; d < depth; ++d) + xe = (IndexExp *)xe->e1; + + Expression *indx = xe->e2->interpret(istate); + if (exceptionOrCantInterpret(indx)) + return indx; + if (indx->op == TOKslice) // only happens with AA assignment + indx = resolveSlice(indx); + + // Look up this index in it up in the existing AA, to get the next level of AA. + AssocArrayLiteralExp *newAA = (AssocArrayLiteralExp *)findKeyInAA(existingAA, indx); + if (exceptionOrCantInterpret(newAA)) + return newAA; + if (!newAA) + { // Doesn't exist yet, create an empty AA... + Expressions *valuesx = new Expressions(); + Expressions *keysx = new Expressions(); + newAA = new AssocArrayLiteralExp(loc, keysx, valuesx); + newAA->type = xe->type; + newAA->ownedByCtfe = true; + //... and insert it into the existing AA. + existingAA->keys->push(indx); + existingAA->values->push(newAA); + } + existingAA = newAA; + --depth; + } + if (assignAssocArrayElement(loc, existingAA, index, newval) == EXP_CANT_INTERPRET) + return EXP_CANT_INTERPRET; + return returnValue; + } + else + { /* The AA is currently null. 'aggregate' is actually a reference to + * whatever contains it. It could be anything: var, dotvarexp, ... + * We rewrite the assignment from: aggregate[i][j] = newval; + * into: aggregate = [i:[j: newval]]; + */ + while (e1->op == TOKindex && ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + Expression *index = ((IndexExp *)e1)->e2->interpret(istate); + if (exceptionOrCantInterpret(index)) + return index; + if (index->op == TOKslice) // only happens with AA assignment + index = resolveSlice(index); + Expressions *valuesx = new Expressions(); + Expressions *keysx = new Expressions(); + valuesx->push(newval); + keysx->push(index); + AssocArrayLiteralExp *newaae = new AssocArrayLiteralExp(loc, keysx, valuesx); + newaae->ownedByCtfe = true; + newaae->type = e1->type; + newval = newaae; + e1 = ((IndexExp *)e1)->e1; + } + // We must return to the original aggregate, in case it was a reference + wantRef = true; + e1 = oldagg; + // fall through -- let the normal assignment logic take care of it + } + } + + // --------------------------------------- + // Deal with dotvar expressions + // --------------------------------------- + // Because structs are not reference types, dotvar expressions can be + // collapsed into a single assignment. + if (!wantRef && e1->op == TOKdotvar) + { + // Strip of all of the leading dotvars, unless we started with a call + // or a ref parameter + // (in which case, we already have the lvalue). + if (this->e1->op != TOKcall && !(this->e1->op==TOKvar + && ((VarExp*)this->e1)->var->storage_class & (STCref | STCout))) + e1 = e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKstructliteral && newval->op == TOKstructliteral) + { + assignInPlace(e1, newval); + return returnValue; + } + } +#if LOGASSIGN + if (wantRef) + printf("REF ASSIGN: %s=%s\n", e1->toChars(), newval->toChars()); + else + printf("ASSIGN: %s=%s\n", e1->toChars(), newval->toChars()); + showCtfeExpr(newval); +#endif + + /* Assignment to variable of the form: + * v = newval + */ + if (e1->op == TOKvar) + { + VarExp *ve = (VarExp *)e1; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (wantRef) + { + v->setValueNull(); + v->setValue(newval); + } + else if (e1->type->toBasetype()->ty == Tstruct) + { + // In-place modification + if (newval->op != TOKstructliteral) + { + error("CTFE internal error assigning struct"); + return EXP_CANT_INTERPRET; + } + newval = copyLiteral(newval); + if (v->getValue()) + assignInPlace(v->getValue(), newval); + else + v->setValue(newval); + } + else + { + TY tyE1 = e1->type->toBasetype()->ty; + if (tyE1 == Tarray || tyE1 == Taarray) + { // arr op= arr + v->setValue(newval); + } + else + { + v->setValue(newval); + } + } + } + else if (e1->op == TOKdotvar) + { + /* Assignment to member variable of the form: + * e.v = newval + */ + Expression *exx = ((DotVarExp *)e1)->e1; + if (wantRef && exx->op != TOKstructliteral) + { + exx = exx->interpret(istate); + if (exceptionOrCantInterpret(exx)) + return exx; + } + if (exx->op != TOKstructliteral && exx->op != TOKclassreference) + { + error("CTFE internal error: Dotvar assignment"); + return EXP_CANT_INTERPRET; + } + VarDeclaration *member = ((DotVarExp *)e1)->var->isVarDeclaration(); + if (!member) + { + error("CTFE internal error: Dotvar assignment"); + return EXP_CANT_INTERPRET; + } + StructLiteralExp *se = exx->op == TOKstructliteral + ? (StructLiteralExp *)exx + : ((ClassReferenceExp *)exx)->value; + int fieldi = exx->op == TOKstructliteral + ? se->getFieldIndex(member->type, member->offset) + : ((ClassReferenceExp *)exx)->getFieldIndex(member->type, member->offset); + if (fieldi == -1) + { + error("CTFE internal error: cannot find field %s in %s", member->toChars(), exx->toChars()); + return EXP_CANT_INTERPRET; + } + assert(fieldi>=0 && fieldi < se->elements->dim); + if (newval->op == TOKstructliteral) + assignInPlace(se->elements->tdata()[fieldi], newval); + else + se->elements->tdata()[fieldi] = newval; + return returnValue; + } + else if (e1->op == TOKindex) + { + /* Assignment to array element of the form: + * aggregate[i] = newval + * aggregate is not AA (AAs were dealt with already). + */ + IndexExp *ie = (IndexExp *)e1; + assert(ie->e1->type->toBasetype()->ty != Taarray); + uinteger_t destarraylen = 0; + + // Set the $ variable, and find the array literal to modify + if (ie->e1->type->toBasetype()->ty != Tpointer) + { + Expression *oldval = ie->e1->interpret(istate); + if (oldval->op == TOKnull) + { + error("cannot index null array %s", ie->e1->toChars()); + return EXP_CANT_INTERPRET; + } + if (oldval->op != TOKarrayliteral && oldval->op != TOKstring + && oldval->op != TOKslice) + { + error("cannot determine length of %s at compile time", + ie->e1->toChars()); + return EXP_CANT_INTERPRET; + } + destarraylen = resolveArrayLength(oldval); + if (ie->lengthVar) + { + IntegerExp *dollarExp = new IntegerExp(loc, destarraylen, Type::tsize_t); + ctfeStack.push(ie->lengthVar); + ie->lengthVar->setValue(dollarExp); + } + } + Expression *index = ie->e2->interpret(istate); + if (ie->lengthVar) + ctfeStack.pop(ie->lengthVar); // $ is defined only inside [] + if (exceptionOrCantInterpret(index)) + return index; + + assert (index->op != TOKslice); // only happens with AA assignment + + ArrayLiteralExp *existingAE = NULL; + StringExp *existingSE = NULL; + + Expression *aggregate = resolveReferences(ie->e1, istate->localThis); + + // Set the index to modify, and check that it is in range + dinteger_t indexToModify = index->toInteger(); + if (ie->e1->type->toBasetype()->ty == Tpointer) + { + dinteger_t ofs; + aggregate = aggregate->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + if (aggregate->op == TOKnull) + { + error("cannot index through null pointer %s", ie->e1->toChars()); + return EXP_CANT_INTERPRET; + } + if (aggregate->op == TOKint64) + { + error("cannot index through invalid pointer %s of value %s", + ie->e1->toChars(), aggregate->toChars()); + return EXP_CANT_INTERPRET; + } + aggregate = getAggregateFromPointer(aggregate, &ofs); + indexToModify += ofs; + destarraylen = resolveArrayLength(aggregate); + } + if (indexToModify >= destarraylen) + { + error("array index %lld is out of bounds [0..%lld]", indexToModify, + destarraylen); + return EXP_CANT_INTERPRET; + } + + /* The only possible indexable LValue aggregates are array literals, and + * slices of array literals. + */ + if (aggregate->op == TOKindex || aggregate->op == TOKdotvar || + aggregate->op == TOKslice || aggregate->op == TOKcall || + aggregate->op == TOKstar) + { + Expression *origagg = aggregate; + aggregate = aggregate->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + // The array could be an index of an AA. Resolve it if so. + if (aggregate->op == TOKindex && + ((IndexExp *)aggregate)->e1->op == TOKassocarrayliteral) + { + IndexExp *ix = (IndexExp *)aggregate; + aggregate = findKeyInAA((AssocArrayLiteralExp *)ix->e1, ix->e2); + if (!aggregate) + { + error("key %s not found in associative array %s", + ix->e2->toChars(), ix->e1->toChars()); + return EXP_CANT_INTERPRET; + } + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + } + } + if (aggregate->op == TOKvar) + { + VarExp *ve = (VarExp *)aggregate; + VarDeclaration *v = ve->var->isVarDeclaration(); + aggregate = v->getValue(); + if (aggregate->op == TOKnull) + { + // This would be a runtime segfault + error("cannot index null array %s", v->toChars()); + return EXP_CANT_INTERPRET; + } + } + if (aggregate->op == TOKslice) + { + SliceExp *sexp = (SliceExp *)aggregate; + aggregate = sexp->e1; + Expression *lwr = sexp->lwr->interpret(istate); + indexToModify += lwr->toInteger(); + } + if (aggregate->op == TOKarrayliteral) + existingAE = (ArrayLiteralExp *)aggregate; + else if (aggregate->op == TOKstring) + existingSE = (StringExp *)aggregate; + else + { + error("CTFE internal compiler error %s", aggregate->toChars()); + return EXP_CANT_INTERPRET; + } + if (!wantRef && newval->op == TOKslice) + { + newval = resolveSlice(newval); + if (newval == EXP_CANT_INTERPRET) + { + error("Compiler error: CTFE index assign %s", toChars()); + assert(0); + } + } + if (wantRef && newval->op == TOKindex + && ((IndexExp *)newval)->e1 == aggregate) + { // It's a circular reference, resolve it now + newval = newval->interpret(istate); + } + + if (existingAE) + { + if (newval->op == TOKstructliteral) + assignInPlace((Expression *)(existingAE->elements->tdata()[indexToModify]), newval); + else + existingAE->elements->tdata()[indexToModify] = newval; + return returnValue; + } + if (existingSE) + { + unsigned char *s = (unsigned char *)existingSE->string; + if (!existingSE->ownedByCtfe) + { + error("cannot modify read-only string literal %s", ie->e1->toChars()); + return EXP_CANT_INTERPRET; + } + unsigned value = newval->toInteger(); + switch (existingSE->sz) + { + case 1: s[indexToModify] = value; break; + case 2: ((unsigned short *)s)[indexToModify] = value; break; + case 4: ((unsigned *)s)[indexToModify] = value; break; + default: + assert(0); + break; + } + return returnValue; + } + else + { + error("Index assignment %s is not yet supported in CTFE ", toChars()); + return EXP_CANT_INTERPRET; + } + return returnValue; + } + else if (e1->op == TOKslice) + { + // ------------------------------ + // aggregate[] = newval + // aggregate[low..upp] = newval + // ------------------------------ + SliceExp * sexp = (SliceExp *)e1; + // Set the $ variable + Expression *oldval = sexp->e1; + bool assignmentToSlicedPointer = false; + if (isPointer(oldval->type)) + { // Slicing a pointer + oldval = oldval->interpret(istate, ctfeNeedLvalue); + dinteger_t ofs; + oldval = getAggregateFromPointer(oldval, &ofs); + assignmentToSlicedPointer = true; + } else + oldval = oldval->interpret(istate); + + if (oldval->op != TOKarrayliteral && oldval->op != TOKstring + && oldval->op != TOKslice && oldval->op != TOKnull) + { + error("CTFE ICE: cannot resolve array length"); + return EXP_CANT_INTERPRET; + } + uinteger_t dollar = resolveArrayLength(oldval); + if (sexp->lengthVar) + { + Expression *arraylen = new IntegerExp(loc, dollar, Type::tsize_t); + ctfeStack.push(sexp->lengthVar); + sexp->lengthVar->setValue(arraylen); + } + + Expression *upper = NULL; + Expression *lower = NULL; + if (sexp->upr) + upper = sexp->upr->interpret(istate); + if (exceptionOrCantInterpret(upper)) + { + if (sexp->lengthVar) + ctfeStack.pop(sexp->lengthVar); // $ is defined only in [L..U] + return upper; + } + if (sexp->lwr) + lower = sexp->lwr->interpret(istate); + if (sexp->lengthVar) + ctfeStack.pop(sexp->lengthVar); // $ is defined only in [L..U] + if (exceptionOrCantInterpret(lower)) + return lower; + + size_t dim = dollar; + size_t upperbound = upper ? upper->toInteger() : dim; + int lowerbound = lower ? lower->toInteger() : 0; + + if (!assignmentToSlicedPointer && (((int)lowerbound < 0) || (upperbound > dim))) + { + error("Array bounds [0..%d] exceeded in slice [%d..%d]", + dim, lowerbound, upperbound); + return EXP_CANT_INTERPRET; + } + if (upperbound == lowerbound) + return newval; + + Expression *aggregate = resolveReferences(((SliceExp *)e1)->e1, istate->localThis); + dinteger_t firstIndex = lowerbound; + + ArrayLiteralExp *existingAE = NULL; + StringExp *existingSE = NULL; + + /* The only possible slicable LValue aggregates are array literals, + * and slices of array literals. + */ + + if (aggregate->op == TOKindex || aggregate->op == TOKdotvar || + aggregate->op == TOKslice || + aggregate->op == TOKstar || aggregate->op == TOKcall) + { + aggregate = aggregate->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + // The array could be an index of an AA. Resolve it if so. + if (aggregate->op == TOKindex && + ((IndexExp *)aggregate)->e1->op == TOKassocarrayliteral) + { + IndexExp *ix = (IndexExp *)aggregate; + aggregate = findKeyInAA((AssocArrayLiteralExp *)ix->e1, ix->e2); + if (!aggregate) + { + error("key %s not found in associative array %s", + ix->e2->toChars(), ix->e1->toChars()); + return EXP_CANT_INTERPRET; + } + if (exceptionOrCantInterpret(aggregate)) + return aggregate; + } + } + if (aggregate->op == TOKvar) + { + VarExp *ve = (VarExp *)(aggregate); + VarDeclaration *v = ve->var->isVarDeclaration(); + aggregate = v->getValue(); + } + if (aggregate->op == TOKslice) + { // Slice of a slice --> change the bounds + SliceExp *sexpold = (SliceExp *)aggregate; + dinteger_t hi = upperbound + sexpold->lwr->toInteger(); + firstIndex = lowerbound + sexpold->lwr->toInteger(); + if (hi > sexpold->upr->toInteger()) + { + error("slice [%d..%d] exceeds array bounds [0..%jd]", + lowerbound, upperbound, + sexpold->upr->toInteger() - sexpold->lwr->toInteger()); + return EXP_CANT_INTERPRET; + } + aggregate = sexpold->e1; + } + if ( isPointer(aggregate->type) ) + { // Slicing a pointer --> change the bounds + aggregate = sexp->e1->interpret(istate, ctfeNeedLvalue); + dinteger_t ofs; + aggregate = getAggregateFromPointer(aggregate, &ofs); + dinteger_t hi = upperbound + ofs; + firstIndex = lowerbound + ofs; + if (firstIndex < 0 || hi > dim) + { + error("slice [%d..%jd] exceeds memory block bounds [0..%jd]", + firstIndex, hi, dim); + return EXP_CANT_INTERPRET; + } + } + if (aggregate->op == TOKarrayliteral) + existingAE = (ArrayLiteralExp *)aggregate; + else if (aggregate->op == TOKstring) + existingSE = (StringExp *)aggregate; + if (existingSE && !existingSE->ownedByCtfe) + { error("cannot modify read-only string literal %s", sexp->e1->toChars()); + return EXP_CANT_INTERPRET; + } + + if (!wantRef && newval->op == TOKslice) + { + newval = resolveSlice(newval); + if (newval == EXP_CANT_INTERPRET) + { + error("Compiler error: CTFE slice %s", toChars()); + assert(0); + } + } + if (wantRef && newval->op == TOKindex + && ((IndexExp *)newval)->e1 == aggregate) + { // It's a circular reference, resolve it now + newval = newval->interpret(istate); + } + + // For slice assignment, we check that the lengths match. + size_t srclen = 0; + if (newval->op == TOKarrayliteral) + srclen = ((ArrayLiteralExp *)newval)->elements->dim; + else if (newval->op == TOKstring) + srclen = ((StringExp *)newval)->len; + if (!isBlockAssignment && srclen != (upperbound - lowerbound)) + { + error("Array length mismatch assigning [0..%d] to [%d..%d]", srclen, lowerbound, upperbound); + return EXP_CANT_INTERPRET; + } + + if (!isBlockAssignment && newval->op == TOKarrayliteral && existingAE) + { + Expressions *oldelems = existingAE->elements; + Expressions *newelems = ((ArrayLiteralExp *)newval)->elements; + for (size_t j = 0; j < newelems->dim; j++) + { + oldelems->tdata()[j + firstIndex] = newelems->tdata()[j]; + } + return newval; + } + else if (newval->op == TOKstring && existingSE) + { + sliceAssignStringFromString((StringExp *)existingSE, (StringExp *)newval, firstIndex); + return newval; + } + else if (newval->op == TOKstring && existingAE + && existingAE->type->isString()) + { /* Mixed slice: it was initialized as an array literal of chars. + * Now a slice of it is being set with a string. + */ + sliceAssignArrayLiteralFromString(existingAE, (StringExp *)newval, firstIndex); + return newval; + } + else if (newval->op == TOKarrayliteral && existingSE) + { /* Mixed slice: it was initialized as a string literal. + * Now a slice of it is being set with an array literal. + */ + sliceAssignStringFromArrayLiteral(existingSE, (ArrayLiteralExp *)newval, firstIndex); + return newval; + } + else if (existingSE) + { // String literal block slice assign + unsigned value = newval->toInteger(); + unsigned char *s = (unsigned char *)existingSE->string; + for (size_t j = 0; j < upperbound-lowerbound; j++) + { + switch (existingSE->sz) + { + case 1: s[j+firstIndex] = value; break; + case 2: ((unsigned short *)s)[j+firstIndex] = value; break; + case 4: ((unsigned *)s)[j+firstIndex] = value; break; + default: + assert(0); + break; + } + } + if (goal == ctfeNeedNothing) + return NULL; // avoid creating an unused literal + SliceExp *retslice = new SliceExp(loc, existingSE, + new IntegerExp(loc, firstIndex, Type::tsize_t), + new IntegerExp(loc, firstIndex + upperbound-lowerbound, Type::tsize_t)); + retslice->type = this->type; + return retslice->interpret(istate); + } + else if (existingAE) + { + /* Block assignment, initialization of static arrays + * x[] = e + * x may be a multidimensional static array. (Note that this + * only happens with array literals, never with strings). + */ + Expressions * w = existingAE->elements; + assert( existingAE->type->ty == Tsarray || + existingAE->type->ty == Tarray); +#if DMDV2 + Type *desttype = ((TypeArray *)existingAE->type)->next->castMod(0); + bool directblk = (e2->type->toBasetype()->castMod(0)) == desttype; +#else + Type *desttype = ((TypeArray *)existingAE->type)->next; + bool directblk = (e2->type->toBasetype()) == desttype; +#endif + bool cow = !(newval->op == TOKstructliteral || newval->op == TOKarrayliteral + || newval->op == TOKstring); + for (size_t j = 0; j < upperbound-lowerbound; j++) + { + if (!directblk) + // Multidimensional array block assign + recursiveBlockAssign((ArrayLiteralExp *)w->tdata()[j+firstIndex], newval, wantRef); + else + { + if (wantRef || cow) + existingAE->elements->tdata()[j+firstIndex] = newval; + else + assignInPlace(existingAE->elements->tdata()[j+firstIndex], newval); + } + } + if (goal == ctfeNeedNothing) + return NULL; // avoid creating an unused literal + SliceExp *retslice = new SliceExp(loc, existingAE, + new IntegerExp(loc, firstIndex, Type::tsize_t), + new IntegerExp(loc, firstIndex + upperbound-lowerbound, Type::tsize_t)); + retslice->type = this->type; + return retslice->interpret(istate); + } + else + error("Slice operation %s cannot be evaluated at compile time", toChars()); + } + else + { + error("%s cannot be evaluated at compile time", toChars()); +#ifdef DEBUG + dump(0); +#endif + } + return returnValue; +} + +Expression *AssignExp::interpret(InterState *istate, CtfeGoal goal) +{ + return interpretAssignCommon(istate, goal, NULL); +} + +#define BIN_ASSIGN_INTERPRET_CTFE(op, ctfeOp) \ +Expression *op##AssignExp::interpret(InterState *istate, CtfeGoal goal) \ +{ \ + return interpretAssignCommon(istate, goal, &ctfeOp); \ +} + +#define BIN_ASSIGN_INTERPRET(op) BIN_ASSIGN_INTERPRET_CTFE(op, op) + +BIN_ASSIGN_INTERPRET(Add) +BIN_ASSIGN_INTERPRET(Min) +BIN_ASSIGN_INTERPRET_CTFE(Cat, ctfeCat) +BIN_ASSIGN_INTERPRET(Mul) +BIN_ASSIGN_INTERPRET(Div) +BIN_ASSIGN_INTERPRET(Mod) +BIN_ASSIGN_INTERPRET(Shl) +BIN_ASSIGN_INTERPRET(Shr) +BIN_ASSIGN_INTERPRET(Ushr) +BIN_ASSIGN_INTERPRET(And) +BIN_ASSIGN_INTERPRET(Or) +BIN_ASSIGN_INTERPRET(Xor) +#if DMDV2 +BIN_ASSIGN_INTERPRET(Pow) +#endif + +Expression *PostExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("PostExp::interpret() %s\n", toChars()); +#endif + Expression *e; + if (op == TOKplusplus) + e = interpretAssignCommon(istate, goal, &Add, 1); + else + e = interpretAssignCommon(istate, goal, &Min, 1); +#if LOG + if (e == EXP_CANT_INTERPRET) + printf("PostExp::interpret() CANT\n"); +#endif + return e; +} + +Expression *AndAndExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("AndAndExp::interpret() %s\n", toChars()); +#endif + Expression *e = e1->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + + int result; + if (e != EXP_CANT_INTERPRET) + { + if (e->isBool(FALSE)) + result = 0; + else if (isTrueBool(e)) + { + e = e2->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (e == EXP_VOID_INTERPRET) + { + assert(type->ty == Tvoid); + return NULL; + } + if (e != EXP_CANT_INTERPRET) + { + if (e->isBool(FALSE)) + result = 0; + else if (isTrueBool(e)) + result = 1; + else + { + error("%s does not evaluate to a boolean", e->toChars()); + e = EXP_CANT_INTERPRET; + } + } + } + else + { + error("%s cannot be interpreted as a boolean", e->toChars()); + e = EXP_CANT_INTERPRET; + } + } + if (e != EXP_CANT_INTERPRET && goal != ctfeNeedNothing) + e = new IntegerExp(loc, result, type); + return e; +} + +Expression *OrOrExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("OrOrExp::interpret() %s\n", toChars()); +#endif + Expression *e = e1->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + + int result; + if (e != EXP_CANT_INTERPRET) + { + if (isTrueBool(e)) + result = 1; + else if (e->isBool(FALSE)) + { + e = e2->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + + if (e == EXP_VOID_INTERPRET) + { + assert(type->ty == Tvoid); + return NULL; + } + if (e != EXP_CANT_INTERPRET) + { + if (e->isBool(FALSE)) + result = 0; + else if (isTrueBool(e)) + result = 1; + else + { + error("%s cannot be interpreted as a boolean", e->toChars()); + e = EXP_CANT_INTERPRET; + } + } + } + else + { + error("%s cannot be interpreted as a boolean", e->toChars()); + e = EXP_CANT_INTERPRET; + } + } + if (e != EXP_CANT_INTERPRET && goal != ctfeNeedNothing) + e = new IntegerExp(loc, result, type); + return e; +} + +// Print a stack trace, starting from callingExp which called fd. +// To shorten the stack trace, try to detect recursion. +void showCtfeBackTrace(InterState *istate, CallExp * callingExp, FuncDeclaration *fd) +{ + if (CtfeStatus::stackTraceCallsToSuppress > 0) + { + --CtfeStatus::stackTraceCallsToSuppress; + return; + } + errorSupplemental(callingExp->loc, "called from here: %s", callingExp->toChars()); + // Quit if it's not worth trying to compress the stack trace + if (CtfeStatus::callDepth < 6 || global.params.verbose) + return; + // Recursion happens if the current function already exists in the call stack. + int numToSuppress = 0; + int recurseCount = 0; + int depthSoFar = 0; + InterState *lastRecurse = istate; + for (InterState * cur = istate; cur; cur = cur->caller) + { + if (cur->fd == fd) + { ++recurseCount; + numToSuppress = depthSoFar; + lastRecurse = cur; + } + ++depthSoFar; + } + // We need at least three calls to the same function, to make compression worthwhile + if (recurseCount < 2) + return; + // We found a useful recursion. Print all the calls involved in the recursion + errorSupplemental(fd->loc, "%d recursive calls to function %s", recurseCount, fd->toChars()); + for (InterState *cur = istate; cur->fd != fd; cur = cur->caller) + { + errorSupplemental(cur->fd->loc, "recursively called from function %s", cur->fd->toChars()); + } + // We probably didn't enter the recursion in this function. + // Go deeper to find the real beginning. + InterState * cur = istate; + while (lastRecurse->caller && cur->fd == lastRecurse->caller->fd) + { + cur = cur->caller; + lastRecurse = lastRecurse->caller; + ++numToSuppress; + } + CtfeStatus::stackTraceCallsToSuppress = numToSuppress; +} + +Expression *CallExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e = EXP_CANT_INTERPRET; + +#if LOG + printf("CallExp::interpret() %s\n", toChars()); +#endif + + Expression * pthis = NULL; + FuncDeclaration *fd = NULL; + Expression *ecall = e1; + if (ecall->op == TOKcall) + { + ecall = e1->interpret(istate); + if (exceptionOrCantInterpret(ecall)) + return ecall; + } + if (ecall->op == TOKstar) + { // Calling a function pointer + Expression * pe = ((PtrExp*)ecall)->e1; + if (pe->op == TOKvar) { + VarDeclaration *vd = ((VarExp *)((PtrExp*)ecall)->e1)->var->isVarDeclaration(); + if (vd && vd->getValue() && vd->getValue()->op == TOKsymoff) + fd = ((SymOffExp *)vd->getValue())->var->isFuncDeclaration(); + else + { + ecall = getVarExp(loc, istate, vd, goal); + if (exceptionOrCantInterpret(ecall)) + return ecall; + + if (ecall->op == TOKsymoff) + fd = ((SymOffExp *)ecall)->var->isFuncDeclaration(); + } + } + else if (pe->op == TOKsymoff) + fd = ((SymOffExp *)pe)->var->isFuncDeclaration(); + else + ecall = ((PtrExp*)ecall)->e1->interpret(istate); + + } + if (exceptionOrCantInterpret(ecall)) + return ecall; + + if (ecall->op == TOKindex) + { ecall = e1->interpret(istate); + if (exceptionOrCantInterpret(ecall)) + return ecall; + } + + if (ecall->op == TOKdotvar && !((DotVarExp*)ecall)->var->isFuncDeclaration()) + { ecall = e1->interpret(istate); + if (exceptionOrCantInterpret(ecall)) + return ecall; + } + + if (ecall->op == TOKdotvar) + { // Calling a member function + pthis = ((DotVarExp*)e1)->e1; + fd = ((DotVarExp*)e1)->var->isFuncDeclaration(); + } + else if (ecall->op == TOKvar) + { + VarDeclaration *vd = ((VarExp *)ecall)->var->isVarDeclaration(); + if (vd && vd->getValue()) + ecall = vd->getValue(); + else // Calling a function + fd = ((VarExp *)e1)->var->isFuncDeclaration(); + } + if (ecall->op == TOKdelegate) + { // Calling a delegate + fd = ((DelegateExp *)ecall)->func; + pthis = ((DelegateExp *)ecall)->e1; + } + else if (ecall->op == TOKfunction) + { // Calling a delegate literal + fd = ((FuncExp*)ecall)->fd; + } + else if (ecall->op == TOKstar && ((PtrExp*)ecall)->e1->op==TOKfunction) + { // Calling a function literal + fd = ((FuncExp*)((PtrExp*)ecall)->e1)->fd; + } + + TypeFunction *tf = fd ? (TypeFunction *)(fd->type) : NULL; + if (!tf) + { // DAC: This should never happen, it's an internal compiler error. + //printf("ecall=%s %d %d\n", ecall->toChars(), ecall->op, TOKcall); + if (ecall->op == TOKidentifier) + error("cannot evaluate %s at compile time. Circular reference?", toChars()); + else + error("CTFE internal error: cannot evaluate %s at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + if (!fd) + { + error("cannot evaluate %s at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + if (pthis) + { // Member function call + Expression *oldpthis; + if (pthis->op == TOKthis) + { + pthis = istate ? istate->localThis : NULL; + oldpthis = pthis; + } + else + { + if (pthis->op == TOKcomma) + pthis = pthis->interpret(istate); + if (exceptionOrCantInterpret(pthis)) + return pthis; + // Evaluate 'this' + oldpthis = pthis; + if (pthis->op != TOKvar) + pthis = pthis->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(pthis)) + return pthis; + } + if (fd->isVirtual()) + { // Make a virtual function call. + Expression *thisval = pthis; + if (pthis->op == TOKvar) + { assert(((VarExp*)thisval)->var->isVarDeclaration()); + thisval = ((VarExp*)thisval)->var->isVarDeclaration()->getValue(); + } + // Get the function from the vtable of the original class + ClassDeclaration *cd; + if (thisval && thisval->op == TOKnull) + { + error("function call through null class reference %s", pthis->toChars()); + return EXP_CANT_INTERPRET; + } + if (oldpthis->op == TOKsuper) + { assert(oldpthis->type->ty == Tclass); + cd = ((TypeClass *)oldpthis->type)->sym; + } + else + { + assert(thisval && thisval->op == TOKclassreference); + cd = ((ClassReferenceExp *)thisval)->originalClass(); + } + // We can't just use the vtable index to look it up, because + // vtables for interfaces don't get populated until the glue layer. + fd = cd->findFunc(fd->ident, (TypeFunction *)fd->type); + + assert(fd); + } + } + if (fd && fd->semanticRun >= PASSsemantic3done && fd->semantic3Errors) + { + error("CTFE failed because of previous errors in %s", fd->toChars()); + return EXP_CANT_INTERPRET; + } + // Check for built-in functions + Expression *eresult = evaluateIfBuiltin(istate, loc, fd, arguments, pthis); + if (eresult) + return eresult; + + // Inline .dup. Special case because it needs the return type. + if (!pthis && fd->ident == Id::adDup && arguments && arguments->dim == 2) + { + e = arguments->tdata()[1]; + e = e->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (e != EXP_CANT_INTERPRET) + { + if (e->op == TOKslice) + e= resolveSlice(e); + e = paintTypeOntoLiteral(type, copyLiteral(e)); + } + return e; + } + if (!fd->fbody) + { + error("%s cannot be interpreted at compile time," + " because it has no available source code", fd->toChars()); + return EXP_CANT_INTERPRET; + } + eresult = fd->interpret(istate, arguments, pthis); + if (eresult == EXP_CANT_INTERPRET) + { // Print a stack trace. + if (!global.gag) + showCtfeBackTrace(istate, this, fd); + } + return eresult; +} + +Expression *CommaExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("CommaExp::interpret() %s\n", toChars()); +#endif + + CommaExp * firstComma = this; + while (firstComma->e1->op == TOKcomma) + firstComma = (CommaExp *)firstComma->e1; + + // If it creates a variable, and there's no context for + // the variable to be created in, we need to create one now. + InterState istateComma; + if (!istate && firstComma->e1->op == TOKdeclaration) + { + assert(ctfeStack.stackPointer() == 0); + ctfeStack.startFrame(); + istate = &istateComma; + } + + Expression *e = EXP_CANT_INTERPRET; + + // If the comma returns a temporary variable, it needs to be an lvalue + // (this is particularly important for struct constructors) + if (e1->op == TOKdeclaration && e2->op == TOKvar + && ((DeclarationExp *)e1)->declaration == ((VarExp*)e2)->var + && ((VarExp*)e2)->var->storage_class & STCctfe) // same as Expression::isTemp + { + VarExp* ve = (VarExp *)e2; + VarDeclaration *v = ve->var->isVarDeclaration(); + ctfeStack.push(v); + if (!v->init && !v->getValue()) + { + v->setValue(copyLiteral(v->type->defaultInitLiteral())); + } + if (!v->getValue()) { + Expression *newval = v->init->toExpression(); + // Bug 4027. Copy constructors are a weird case where the + // initializer is a void function (the variable is modified + // through a reference parameter instead). + newval = newval->interpret(istate); + if (exceptionOrCantInterpret(newval)) + { + if (istate == &istateComma) + ctfeStack.endFrame(0); + return newval; + } + if (newval != EXP_VOID_INTERPRET) + { + // v isn't necessarily null. + v->setValueWithoutChecking(copyLiteral(newval)); + } + } + if (goal == ctfeNeedLvalue || goal == ctfeNeedLvalueRef) + e = e2; + else + e = e2->interpret(istate, goal); + } + else + { + e = e1->interpret(istate, ctfeNeedNothing); + if (!exceptionOrCantInterpret(e)) + e = e2->interpret(istate, goal); + } + // If we created a temporary stack frame, end it now. + if (istate == &istateComma) + ctfeStack.endFrame(0); + return e; +} + +Expression *CondExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("CondExp::interpret() %s\n", toChars()); +#endif + Expression *e; + if ( isPointer(econd->type) ) + { + e = econd->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e)) + return e; + if (e->op != TOKnull) + e = new IntegerExp(loc, 1, Type::tbool); + } + else + e = econd->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + if (isTrueBool(e)) + e = e1->interpret(istate, goal); + else if (e->isBool(FALSE)) + e = e2->interpret(istate, goal); + else + { + error("%s does not evaluate to boolean result at compile time", + econd->toChars()); + e = EXP_CANT_INTERPRET; + } + return e; +} + +Expression *ArrayLengthExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e; + Expression *e1; + +#if LOG + printf("ArrayLengthExp::interpret() %s\n", toChars()); +#endif + e1 = this->e1->interpret(istate); + assert(e1); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKstring || e1->op == TOKarrayliteral || e1->op == TOKslice + || e1->op == TOKassocarrayliteral || e1->op == TOKnull) + { + e = new IntegerExp(loc, resolveArrayLength(e1), type); + } + else + { + error("%s cannot be evaluated at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + return e; +} + +/* Given an AA literal 'ae', and a key 'e2': + * Return ae[e2] if present, or NULL if not found. + * Return EXP_CANT_INTERPRET on error. + */ +Expression *findKeyInAA(AssocArrayLiteralExp *ae, Expression *e2) +{ + /* Search the keys backwards, in case there are duplicate keys + */ + for (size_t i = ae->keys->dim; i;) + { + i--; + Expression *ekey = ae->keys->tdata()[i]; + Expression *ex = ctfeEqual(TOKequal, Type::tbool, ekey, e2); + if (ex == EXP_CANT_INTERPRET) + { + error("cannot evaluate %s==%s at compile time", + ekey->toChars(), e2->toChars()); + return ex; + } + if (ex->isBool(TRUE)) + { + return ae->values->tdata()[i]; + } + } + return NULL; +} + +/* Same as for constfold.Index, except that it only works for static arrays, + * dynamic arrays, and strings. We know that e1 is an + * interpreted CTFE expression, so it cannot have side-effects. + */ +Expression *ctfeIndex(Loc loc, Type *type, Expression *e1, uinteger_t indx) +{ //printf("ctfeIndex(e1 = %s)\n", e1->toChars()); + assert(e1->type); + if (e1->op == TOKstring) + { StringExp *es1 = (StringExp *)e1; + if (indx >= es1->len) + { + error(loc, "string index %ju is out of bounds [0 .. %zu]", indx, es1->len); + return EXP_CANT_INTERPRET; + } + else + return new IntegerExp(loc, es1->charAt(indx), type); + } + assert(e1->op == TOKarrayliteral); + ArrayLiteralExp *ale = (ArrayLiteralExp *)e1; + if (indx >= ale->elements->dim) + { + error(loc, "array index %ju is out of bounds %s[0 .. %u]", indx, e1->toChars(), ale->elements->dim); + return EXP_CANT_INTERPRET; + } + Expression *e = ale->elements->tdata()[indx]; + return paintTypeOntoLiteral(type, e); +} + +Expression *IndexExp::interpret(InterState *istate, CtfeGoal goal) +{ + Expression *e1 = NULL; + Expression *e2; + +#if LOG + printf("IndexExp::interpret() %s\n", toChars()); +#endif + if (this->e1->type->toBasetype()->ty == Tpointer) + { + // Indexing a pointer. Note that there is no $ in this case. + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + dinteger_t indx = e2->toInteger(); + dinteger_t ofs; + Expression *agg = getAggregateFromPointer(e1, &ofs); + if (agg->op == TOKnull) + { + error("cannot index null pointer %s", this->e1->toChars()); + return EXP_CANT_INTERPRET; + } + assert(agg->op == TOKarrayliteral || agg->op == TOKstring); + dinteger_t len = ArrayLength(Type::tsize_t, agg)->toInteger(); + Type *pointee = ((TypePointer *)agg->type)->next; + if ((indx + ofs) < 0 || (indx+ofs) > len) + { + error("pointer index [%jd] exceeds allocated memory block [0..%jd]", + indx+ofs, len); + return EXP_CANT_INTERPRET; + } + return ctfeIndex(loc, type, agg, indx+ofs); + } + e1 = this->e1; + if (!(e1->op == TOKarrayliteral && ((ArrayLiteralExp *)e1)->ownedByCtfe)) + e1 = e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + + if (e1->op == TOKnull) + { + if (goal == ctfeNeedLvalue && e1->type->ty == Taarray) + return paintTypeOntoLiteral(type, e1); + error("cannot index null array %s", this->e1->toChars()); + return EXP_CANT_INTERPRET; + } + /* Set the $ variable. + * Note that foreach uses indexing but doesn't need $ + */ + if (lengthVar && (e1->op == TOKstring || e1->op == TOKarrayliteral + || e1->op == TOKslice)) + { + uinteger_t dollar = resolveArrayLength(e1); + Expression *dollarExp = new IntegerExp(loc, dollar, Type::tsize_t); + ctfeStack.push(lengthVar); + lengthVar->setValue(dollarExp); + } + + e2 = this->e2->interpret(istate); + if (lengthVar) + ctfeStack.pop(lengthVar); // $ is defined only inside [] + if (exceptionOrCantInterpret(e2)) + return e2; + if (e1->op == TOKslice && e2->op == TOKint64) + { + // Simplify index of slice: agg[lwr..upr][indx] --> agg[indx'] + uinteger_t indx = e2->toInteger(); + uinteger_t ilo = ((SliceExp *)e1)->lwr->toInteger(); + uinteger_t iup = ((SliceExp *)e1)->upr->toInteger(); + + if (indx > iup - ilo) + { + error("index %ju exceeds array length %ju", indx, iup - ilo); + return EXP_CANT_INTERPRET; + } + indx += ilo; + e1 = ((SliceExp *)e1)->e1; + e2 = new IntegerExp(e2->loc, indx, e2->type); + } + Expression *e = NULL; + if ((goal == ctfeNeedLvalue && type->ty != Taarray && type->ty != Tarray + && type->ty != Tsarray && type->ty != Tstruct && type->ty != Tclass) + || (goal == ctfeNeedLvalueRef && type->ty != Tsarray && type->ty != Tstruct) + ) + { // Pointer or reference of a scalar type + e = new IndexExp(loc, e1, e2); + e->type = type; + return e; + } + if (e1->op == TOKassocarrayliteral) + { + if (e2->op == TOKslice) + e2 = resolveSlice(e2); + e = findKeyInAA((AssocArrayLiteralExp *)e1, e2); + if (!e) + { + error("key %s not found in associative array %s", + e2->toChars(), this->e1->toChars()); + return EXP_CANT_INTERPRET; + } + } + else + { + if (e2->op != TOKint64) + { + e1->error("CTFE internal error: non-integral index [%s]", this->e2->toChars()); + return EXP_CANT_INTERPRET; + } + e = ctfeIndex(loc, type, e1, e2->toInteger()); + } + if (exceptionOrCantInterpret(e)) + return e; + if (goal == ctfeNeedRvalue && (e->op == TOKslice || e->op == TOKdotvar)) + e = e->interpret(istate); + e = paintTypeOntoLiteral(type, e); + return e; +} + + +Expression *SliceExp::interpret(InterState *istate, CtfeGoal goal) +{ + Expression *e1; + Expression *lwr; + Expression *upr; + +#if LOG + printf("SliceExp::interpret() %s\n", toChars()); +#endif + + if (this->e1->type->toBasetype()->ty == Tpointer) + { + // Slicing a pointer. Note that there is no $ in this case. + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKint64) + { + error("cannot slice invalid pointer %s of value %s", + this->e1->toChars(), e1->toChars()); + return EXP_CANT_INTERPRET; + } + + /* Evaluate lower and upper bounds of slice + */ + lwr = this->lwr->interpret(istate); + if (exceptionOrCantInterpret(lwr)) + return lwr; + upr = this->upr->interpret(istate); + if (exceptionOrCantInterpret(upr)) + return upr; + uinteger_t ilwr; + uinteger_t iupr; + ilwr = lwr->toInteger(); + iupr = upr->toInteger(); + Expression *e; + dinteger_t ofs; + Expression *agg = getAggregateFromPointer(e1, &ofs); + if (agg->op == TOKnull) + { + if (iupr == ilwr) + { + e = new NullExp(loc); + e->type = type; + return e; + } + error("cannot slice null pointer %s", this->e1->toChars()); + return EXP_CANT_INTERPRET; + } + assert(agg->op == TOKarrayliteral || agg->op == TOKstring); + dinteger_t len = ArrayLength(Type::tsize_t, agg)->toInteger(); + Type *pointee = ((TypePointer *)agg->type)->next; + if ((ilwr + ofs) < 0 || (iupr+ofs) > (len + 1) || iupr < ilwr) + { + error("pointer slice [%jd..%jd] exceeds allocated memory block [0..%jd]", + ilwr+ofs, iupr+ofs, len); + return EXP_CANT_INTERPRET; + } + e = new SliceExp(loc, agg, lwr, upr); + e->type = type; + return e; + } + if (goal == ctfeNeedRvalue && this->e1->op == TOKstring) + e1 = this->e1; // Will get duplicated anyway + else + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKvar) + e1 = e1->interpret(istate); + + if (!this->lwr) + { + if (goal == ctfeNeedLvalue || goal == ctfeNeedLvalueRef) + return e1; + return paintTypeOntoLiteral(type, e1); + } + + /* Set the $ variable + */ + if (e1->op != TOKarrayliteral && e1->op != TOKstring && + e1->op != TOKnull && e1->op != TOKslice) + { + error("Cannot determine length of %s at compile time", e1->toChars()); + return EXP_CANT_INTERPRET; + } + uinteger_t dollar = resolveArrayLength(e1); + if (lengthVar) + { + IntegerExp *dollarExp = new IntegerExp(loc, dollar, Type::tsize_t); + ctfeStack.push(lengthVar); + lengthVar->setValue(dollarExp); + } + + /* Evaluate lower and upper bounds of slice + */ + lwr = this->lwr->interpret(istate); + if (exceptionOrCantInterpret(lwr)) + { + if (lengthVar) + ctfeStack.pop(lengthVar);; // $ is defined only inside [L..U] + return lwr; + } + upr = this->upr->interpret(istate); + if (lengthVar) + ctfeStack.pop(lengthVar); // $ is defined only inside [L..U] + if (exceptionOrCantInterpret(upr)) + return upr; + + Expression *e; + uinteger_t ilwr; + uinteger_t iupr; + ilwr = lwr->toInteger(); + iupr = upr->toInteger(); + if (e1->op == TOKnull) + { + if (ilwr== 0 && iupr == 0) + return e1; + e1->error("slice [%ju..%ju] is out of bounds", ilwr, iupr); + return EXP_CANT_INTERPRET; + } + if (e1->op == TOKslice) + { + SliceExp *se = (SliceExp *)e1; + // Simplify slice of slice: + // aggregate[lo1..up1][lwr..upr] ---> aggregate[lwr'..upr'] + uinteger_t lo1 = se->lwr->toInteger(); + uinteger_t up1 = se->upr->toInteger(); + if (ilwr > iupr || iupr > up1 - lo1) + { + error("slice[%ju..%ju] exceeds array bounds[%ju..%ju]", + ilwr, iupr, lo1, up1); + return EXP_CANT_INTERPRET; + } + ilwr += lo1; + iupr += lo1; + e = new SliceExp(loc, se->e1, + new IntegerExp(loc, ilwr, lwr->type), + new IntegerExp(loc, iupr, upr->type)); + e->type = type; + return e; + } + if (e1->op == TOKarrayliteral + || e1->op == TOKstring) + { + if (iupr < ilwr || ilwr < 0 || iupr > dollar) + { + error("slice [%jd..%jd] exceeds array bounds [0..%jd]", + ilwr, iupr, dollar); + return EXP_CANT_INTERPRET; + } + } + e = new SliceExp(loc, e1, lwr, upr); + e->type = type; + return e; +} + +Expression *InExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e = EXP_CANT_INTERPRET; + +#if LOG + printf("InExp::interpret() %s\n", toChars()); +#endif + Expression *e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + Expression *e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + if (e2->op == TOKnull) + return new NullExp(loc, type); + if (e2->op != TOKassocarrayliteral) + { + error(" %s cannot be interpreted at compile time", toChars()); + return EXP_CANT_INTERPRET; + } + if (e1->op == TOKslice) + e1 = resolveSlice(e1); + e = findKeyInAA((AssocArrayLiteralExp *)e2, e1); + if (exceptionOrCantInterpret(e)) + return e; + if (!e) + return new NullExp(loc, type); + e = new IndexExp(loc, e2, e1); + e->type = type; + return e; +} + +Expression *CatExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e; + Expression *e1; + Expression *e2; + +#if LOG + printf("CatExp::interpret() %s\n", toChars()); +#endif + e1 = this->e1->interpret(istate); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op == TOKslice) + { + e1 = resolveSlice(e1); + } + e2 = this->e2->interpret(istate); + if (exceptionOrCantInterpret(e2)) + return e2; + if (e2->op == TOKslice) + e2 = resolveSlice(e2); + e = ctfeCat(type, e1, e2); + if (e == EXP_CANT_INTERPRET) + error("%s cannot be interpreted at compile time", toChars()); + // We know we still own it, because we interpreted both e1 and e2 + if (e->op == TOKarrayliteral) + ((ArrayLiteralExp *)e)->ownedByCtfe = true; + if (e->op == TOKstring) + ((StringExp *)e)->ownedByCtfe = true; + return e; +} + + +// Return true if t is a pointer (not a function pointer) +bool isPointer(Type *t) +{ + Type * tb = t->toBasetype(); + return tb->ty == Tpointer && tb->nextOf()->ty != Tfunction; +} + +// Return true if t is an AA, or AssociativeArray!(key, value) +bool isAssocArray(Type *t) +{ + t = t->toBasetype(); + if (t->ty == Taarray) + return true; +#if DMDV2 + if (t->ty != Tstruct) + return false; + StructDeclaration *sym = ((TypeStruct *)t)->sym; + if (sym->ident == Id::AssociativeArray) + return true; +#endif + return false; +} + +// Given a template AA type, extract the corresponding built-in AA type +TypeAArray *toBuiltinAAType(Type *t) +{ + t = t->toBasetype(); + if (t->ty == Taarray) + return (TypeAArray *)t; +#if DMDV2 + assert(t->ty == Tstruct); + StructDeclaration *sym = ((TypeStruct *)t)->sym; + assert(sym->ident == Id::AssociativeArray); + TemplateInstance *tinst = sym->parent->isTemplateInstance(); + assert(tinst); + return new TypeAArray((Type *)(tinst->tiargs->tdata()[1]), (Type *)(tinst->tiargs->tdata()[0])); +#else + assert(0); + return NULL; +#endif +} + +Expression *CastExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e; + Expression *e1; + +#if LOG + printf("CastExp::interpret() %s\n", toChars()); +#endif + e1 = this->e1->interpret(istate, goal); + if (exceptionOrCantInterpret(e1)) + return e1; + // If the expression has been cast to void, do nothing. + if (to->ty == Tvoid && goal == ctfeNeedNothing) + return e1; + if (to->ty == Tpointer && e1->op != TOKnull) + { + Type *pointee = ((TypePointer *)type)->next; + // Implement special cases of normally-unsafe casts +#if DMDV2 + if (pointee->ty == Taarray && e1->op == TOKaddress + && isAssocArray(((AddrExp*)e1)->e1->type)) + { // cast from template AA pointer to true AA pointer is OK. + return paintTypeOntoLiteral(to, e1); + } +#endif + if (e1->op == TOKint64) + { // Happens with Windows HANDLEs, for example. + return paintTypeOntoLiteral(to, e1); + } + bool castBackFromVoid = false; + if (e1->type->ty == Tarray || e1->type->ty == Tsarray || e1->type->ty == Tpointer) + { + // Check for unsupported type painting operations + // For slices, we need the type being sliced, + // since it may have already been type painted + Type *elemtype = e1->type->nextOf(); + if (e1->op == TOKslice) + elemtype = ((SliceExp *)e1)->e1->type->nextOf(); + // Allow casts from X* to void *, and X** to void** for any X. + // But don't allow cast from X* to void**. + // So, we strip all matching * from source and target to find X. + // Allow casts to X* from void* only if the 'void' was originally an X; + // we check this later on. + Type *ultimatePointee = pointee; + Type *ultimateSrc = elemtype; + while (ultimatePointee->ty == Tpointer && ultimateSrc->ty == Tpointer) + { + ultimatePointee = ultimatePointee->nextOf(); + ultimateSrc = ultimateSrc->nextOf(); + } + if (ultimatePointee->ty != Tvoid && ultimateSrc->ty != Tvoid + && !isSafePointerCast(elemtype, pointee)) + { + error("reinterpreting cast from %s* to %s* is not supported in CTFE", + elemtype->toChars(), pointee->toChars()); + return EXP_CANT_INTERPRET; + } + if (ultimateSrc->ty == Tvoid) + castBackFromVoid = true; + } + + if (e1->op == TOKslice) + { + if ( ((SliceExp *)e1)->e1->op == TOKnull) + { + return paintTypeOntoLiteral(type, ((SliceExp *)e1)->e1); + } + e = new IndexExp(loc, ((SliceExp *)e1)->e1, ((SliceExp *)e1)->lwr); + e->type = type; + return e; + } + if (e1->op == TOKarrayliteral || e1->op == TOKstring) + { + e = new IndexExp(loc, e1, new IntegerExp(loc, 0, Type::tsize_t)); + e->type = type; + return e; + } + if (e1->op == TOKindex && ((IndexExp *)e1)->e1->type != e1->type) + { // type painting operation + IndexExp *ie = (IndexExp *)e1; + e = new IndexExp(e1->loc, ie->e1, ie->e2); + if (castBackFromVoid) + { + // get the original type. For strings, it's just the type... + Type *origType = ie->e1->type->nextOf(); + // ..but for arrays of type void*, it's the type of the element + Expression *xx = NULL; + if (ie->e1->op == TOKarrayliteral && ie->e2->op == TOKint64) + { ArrayLiteralExp *ale = (ArrayLiteralExp *)ie->e1; + uinteger_t indx = ie->e2->toInteger(); + if (indx < ale->elements->dim) + xx = ale->elements->tdata()[indx]; + } + if (xx && xx->op == TOKindex) + origType = ((IndexExp *)xx)->e1->type->nextOf(); + else if (xx && xx->op == TOKaddress) + origType= ((AddrExp *)xx)->e1->type; + else if (xx && xx->op == TOKvar) + origType = ((VarExp *)xx)->var->type; + if (!isSafePointerCast(origType, pointee)) + { + error("using void* to reinterpret cast from %s* to %s* is not supported in CTFE", + origType->toChars(), pointee->toChars()); + return EXP_CANT_INTERPRET; + } + } + e->type = type; + return e; + } + if (e1->op == TOKaddress) + { + Type *origType = ((AddrExp *)e1)->type; + if (isSafePointerCast(origType, pointee)) + { + e = new AddrExp(loc, ((AddrExp *)e1)->e1); + e->type = type; + return e; + } + } + if (e1->op == TOKvar) + { // type painting operation + Type *origType = ((VarExp *)e1)->var->type; + if (castBackFromVoid && !isSafePointerCast(origType, pointee)) + { + error("using void* to reinterpret cast from %s* to %s* is not supported in CTFE", + origType->toChars(), pointee->toChars()); + return EXP_CANT_INTERPRET; + } + e = new VarExp(loc, ((VarExp *)e1)->var); + e->type = type; + return e; + } + error("pointer cast from %s to %s is not supported at compile time", + e1->type->toChars(), to->toChars()); + return EXP_CANT_INTERPRET; + } + if (to->ty == Tarray && e1->op == TOKslice) + { + e1 = new SliceExp(e1->loc, ((SliceExp *)e1)->e1, ((SliceExp *)e1)->lwr, + ((SliceExp *)e1)->upr); + e1->type = to; + return e1; + } + // Disallow array type painting, except for conversions between built-in + // types of identical size. + if ((to->ty == Tsarray || to->ty == Tarray) && + (e1->type->ty == Tsarray || e1->type->ty == Tarray) && + !isSafePointerCast(e1->type->nextOf(), to->nextOf()) ) + { + error("array cast from %s to %s is not supported at compile time", e1->type->toChars(), to->toChars()); + return EXP_CANT_INTERPRET; + } + if (to->ty == Tsarray && e1->op == TOKslice) + e1 = resolveSlice(e1); + if (to->toBasetype()->ty == Tbool && e1->type->ty==Tpointer) + { + return new IntegerExp(loc, e1->op != TOKnull, to); + } + return ctfeCast(loc, type, to, e1); +} + +Expression *AssertExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e; + Expression *e1; + +#if LOG + printf("AssertExp::interpret() %s\n", toChars()); +#endif +#if DMDV2 + e1 = this->e1->interpret(istate); +#else + // Deal with pointers (including compiler-inserted assert(&this, "null this")) + if ( isPointer(this->e1->type) ) + { + e1 = this->e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e1)) + return e1; + if (e1->op != TOKnull) + return new IntegerExp(loc, 1, Type::tbool); + } + else + e1 = this->e1->interpret(istate); +#endif + if (exceptionOrCantInterpret(e1)) + return e1; + if (isTrueBool(e1)) + { + } + else if (e1->isBool(FALSE)) + { + if (msg) + { + e = msg->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + error("%s", e->toChars()); + } + else + error("%s failed", toChars()); + goto Lcant; + } + else + { + error("%s is not a compile-time boolean expression", e1->toChars()); + goto Lcant; + } + return e1; + +Lcant: + return EXP_CANT_INTERPRET; +} + +Expression *PtrExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e = EXP_CANT_INTERPRET; + +#if LOG + printf("PtrExp::interpret() %s\n", toChars()); +#endif + // Constant fold *(&structliteral + offset) + if (e1->op == TOKadd) + { AddExp *ae = (AddExp *)e1; + if (ae->e1->op == TOKaddress && ae->e2->op == TOKint64) + { AddrExp *ade = (AddrExp *)ae->e1; + Expression *ex = ade->e1; + ex = ex->interpret(istate); + if (exceptionOrCantInterpret(ex)) + return ex; + if (ex->op == TOKstructliteral) + { StructLiteralExp *se = (StructLiteralExp *)ex; + dinteger_t offset = ae->e2->toInteger(); + e = se->getField(type, offset); + if (!e) + e = EXP_CANT_INTERPRET; + return e; + } + } + e = Ptr(type, e1); + } +#if DMDV2 +#else // this is required for D1, where structs return *this instead of 'this'. + else if (e1->op == TOKthis) + { + if(istate->localThis) + return istate->localThis->interpret(istate); + } +#endif + else + { // It's possible we have an array bounds error. We need to make sure it + // errors with this line number, not the one where the pointer was set. + e = e1->interpret(istate, ctfeNeedLvalue); + if (exceptionOrCantInterpret(e)) + return e; + if (!(e->op == TOKvar || e->op == TOKdotvar || e->op == TOKindex + || e->op == TOKslice || e->op == TOKaddress)) + { + error("dereference of invalid pointer '%s'", e->toChars()); + return EXP_CANT_INTERPRET; + } + if (goal != ctfeNeedLvalue) + { + if (e->op == TOKindex && e->type->ty == Tpointer) + { + IndexExp *ie = (IndexExp *)e; + // Is this a real index to an array of pointers, or just a CTFE pointer? + // If the index has the same levels of indirection, it's an index + int srcLevels = 0; + int destLevels = 0; + for(Type *xx = ie->e1->type; xx->ty == Tpointer; xx = xx->nextOf()) + ++srcLevels; + for(Type *xx = e->type->nextOf(); xx->ty == Tpointer; xx = xx->nextOf()) + ++destLevels; + bool isGenuineIndex = (srcLevels == destLevels); + + if ((ie->e1->op == TOKarrayliteral || ie->e1->op == TOKstring) + && ie->e2->op == TOKint64) + { + Expression *dollar = ArrayLength(Type::tsize_t, ie->e1); + dinteger_t len = dollar->toInteger(); + dinteger_t indx = ie->e2->toInteger(); + assert(indx >=0 && indx <= len); // invalid pointer + if (indx == len) + { + error("dereference of pointer %s one past end of memory block limits [0..%jd]", + toChars(), len); + return EXP_CANT_INTERPRET; + } + e = ctfeIndex(loc, type, ie->e1, indx); + if (isGenuineIndex) + { + if (e->op == TOKindex) + e = e->interpret(istate, goal); + else if (e->op == TOKaddress) + e = paintTypeOntoLiteral(type, ((AddrExp *)e)->e1); + } + return e; + } + if (ie->e1->op == TOKassocarrayliteral) + { + e = Index(type, ie->e1, ie->e2); + if (isGenuineIndex) + { + if (e->op == TOKindex) + e = e->interpret(istate, goal); + else if (e->op == TOKaddress) + e = paintTypeOntoLiteral(type, ((AddrExp *)e)->e1); + } + return e; + } + } + if (e->op == TOKstructliteral) + return e; + e = e1->interpret(istate, goal); + if (e->op == TOKaddress) + { + e = ((AddrExp*)e)->e1; + if (e->op == TOKdotvar || e->op == TOKindex) + e = e->interpret(istate, goal); + } + else if (e->op == TOKvar) + { + e = e->interpret(istate, goal); + } + if (exceptionOrCantInterpret(e)) + return e; + } + else if (e->op == TOKaddress) + e = ((AddrExp*)e)->e1; // *(&x) ==> x + if (e->op == TOKnull) + { + error("dereference of null pointer '%s'", e1->toChars()); + return EXP_CANT_INTERPRET; + } + e->type = type; + } + +#if LOG + if (e == EXP_CANT_INTERPRET) + printf("PtrExp::interpret() %s = EXP_CANT_INTERPRET\n", toChars()); +#endif + return e; +} + +Expression *DotVarExp::interpret(InterState *istate, CtfeGoal goal) +{ Expression *e = EXP_CANT_INTERPRET; + +#if LOG + printf("DotVarExp::interpret() %s\n", toChars()); +#endif + + Expression *ex = e1->interpret(istate); + if (exceptionOrCantInterpret(ex)) + return ex; + if (ex != EXP_CANT_INTERPRET) + { + #if DMDV2 + // Special case for template AAs: AA.var returns the AA itself. + // ie AA.p ----> AA. This is a hack, to get around the + // corresponding hack in the AA druntime implementation. + if (isAssocArray(ex->type)) + return ex; + #endif + if (ex->op == TOKaddress) + ex = ((AddrExp *)ex)->e1; + VarDeclaration *v = var->isVarDeclaration(); + if (!v) + error("CTFE internal error: %s", toChars()); + if (ex->op == TOKnull && ex->type->toBasetype()->ty == Tclass) + { error("class '%s' is null and cannot be dereferenced", e1->toChars()); + return EXP_CANT_INTERPRET; + } + if (ex->op == TOKstructliteral || ex->op == TOKclassreference) + { + StructLiteralExp *se = ex->op == TOKclassreference ? ((ClassReferenceExp *)ex)->value : (StructLiteralExp *)ex; + // We can't use getField, because it makes a copy + int i = -1; + if (ex->op == TOKclassreference) + i = ((ClassReferenceExp *)ex)->findFieldIndexByName(v); + else + i = findFieldIndexByName(se->sd, v); + if (i == -1) + { + error("couldn't find field %s of type %s in %s", v->toChars(), type->toChars(), se->toChars()); + return EXP_CANT_INTERPRET; + } + e = se->elements->tdata()[i]; + if (goal == ctfeNeedLvalue || goal == ctfeNeedLvalueRef) + { + // If it is an lvalue literal, return it... + if (e->op == TOKstructliteral) + return e; + if ((type->ty == Tsarray || goal == ctfeNeedLvalue) && ( + e->op == TOKarrayliteral || + e->op == TOKassocarrayliteral || e->op == TOKstring || + e->op == TOKclassreference || e->op == TOKslice)) + return e; + /* Element is an allocated pointer, which was created in + * CastExp. + */ + if (goal == ctfeNeedLvalue && e->op == TOKindex && + e->type == type && + isPointer(type) ) + return e; + // ...Otherwise, just return the (simplified) dotvar expression + e = new DotVarExp(loc, ex, v); + e->type = type; + return e; + } + if (!e) + { + error("couldn't find field %s in %s", v->toChars(), type->toChars()); + e = EXP_CANT_INTERPRET; + } + // If it is an rvalue literal, return it... + if (e->op == TOKstructliteral || e->op == TOKarrayliteral || + e->op == TOKassocarrayliteral || e->op == TOKstring) + return e; + if ( isPointer(type) ) + { + return paintTypeOntoLiteral(type, e); + } + if (e->op == TOKvar) + { // Don't typepaint twice, since that might cause an erroneous copy + e = getVarExp(loc, istate, ((VarExp *)e)->var, goal); + if (e != EXP_CANT_INTERPRET && e->op != TOKthrownexception) + e = paintTypeOntoLiteral(type, e); + return e; + } + return e->interpret(istate, goal); + } + else + error("%s.%s is not yet implemented at compile time", e1->toChars(), var->toChars()); + } + +#if LOG + if (e == EXP_CANT_INTERPRET) + printf("DotVarExp::interpret() %s = EXP_CANT_INTERPRET\n", toChars()); +#endif + return e; +} + +Expression *RemoveExp::interpret(InterState *istate, CtfeGoal goal) +{ +#if LOG + printf("RemoveExp::interpret() %s\n", toChars()); +#endif + Expression *agg = e1->interpret(istate); + if (exceptionOrCantInterpret(agg)) + return agg; + Expression *index = e2->interpret(istate); + if (exceptionOrCantInterpret(index)) + return index; + if (agg->op == TOKnull) + return EXP_VOID_INTERPRET; + assert(agg->op == TOKassocarrayliteral); + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)agg; + Expressions *keysx = aae->keys; + Expressions *valuesx = aae->values; + size_t removed = 0; + for (size_t j = 0; j < valuesx->dim; ++j) + { Expression *ekey = keysx->tdata()[j]; + Expression *ex = ctfeEqual(TOKequal, Type::tbool, ekey, index); + if (exceptionOrCantInterpret(ex)) + return ex; + if (ex->isBool(TRUE)) + ++removed; + else if (removed != 0) + { keysx->tdata()[j - removed] = ekey; + valuesx->tdata()[j - removed] = valuesx->tdata()[j]; + } + } + valuesx->dim = valuesx->dim - removed; + keysx->dim = keysx->dim - removed; + return new IntegerExp(loc, removed?1:0, Type::tbool); +} + + +/******************************* Special Functions ***************************/ + +Expression *interpret_length(InterState *istate, Expression *earg) +{ + //printf("interpret_length()\n"); + earg = earg->interpret(istate); + if (earg == EXP_CANT_INTERPRET) + return NULL; + if (exceptionOrCantInterpret(earg)) + return earg; + dinteger_t len = 0; + if (earg->op == TOKassocarrayliteral) + len = ((AssocArrayLiteralExp *)earg)->keys->dim; + else assert(earg->op == TOKnull); + Expression *e = new IntegerExp(earg->loc, len, Type::tsize_t); + return e; +} + +Expression *interpret_keys(InterState *istate, Expression *earg, Type *elemType) +{ +#if LOG + printf("interpret_keys()\n"); +#endif + earg = earg->interpret(istate); + if (earg == EXP_CANT_INTERPRET) + return NULL; + if (exceptionOrCantInterpret(earg)) + return earg; + if (earg->op == TOKnull) + return new NullExp(earg->loc); + if (earg->op != TOKassocarrayliteral && earg->type->toBasetype()->ty != Taarray) + return NULL; + assert(earg->op == TOKassocarrayliteral); + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)earg; + ArrayLiteralExp *ae = new ArrayLiteralExp(aae->loc, aae->keys); + ae->ownedByCtfe = aae->ownedByCtfe; + ae->type = new TypeSArray(elemType, new IntegerExp(aae->keys->dim)); + return copyLiteral(ae); +} + +Expression *interpret_values(InterState *istate, Expression *earg, Type *elemType) +{ +#if LOG + printf("interpret_values()\n"); +#endif + earg = earg->interpret(istate); + if (earg == EXP_CANT_INTERPRET) + return NULL; + if (exceptionOrCantInterpret(earg)) + return earg; + if (earg->op == TOKnull) + return new NullExp(earg->loc); + if (earg->op != TOKassocarrayliteral && earg->type->toBasetype()->ty != Taarray) + return NULL; + assert(earg->op == TOKassocarrayliteral); + AssocArrayLiteralExp *aae = (AssocArrayLiteralExp *)earg; + ArrayLiteralExp *ae = new ArrayLiteralExp(aae->loc, aae->values); + ae->ownedByCtfe = aae->ownedByCtfe; + ae->type = new TypeSArray(elemType, new IntegerExp(aae->values->dim)); + //printf("result is %s\n", e->toChars()); + return copyLiteral(ae); +} + +// signature is int delegate(ref Value) OR int delegate(ref Key, ref Value) +Expression *interpret_aaApply(InterState *istate, Expression *aa, Expression *deleg) +{ aa = aa->interpret(istate); + if (exceptionOrCantInterpret(aa)) + return aa; + if (aa->op != TOKassocarrayliteral) + return new IntegerExp(deleg->loc, 0, Type::tsize_t); + + FuncDeclaration *fd = NULL; + Expression *pthis = NULL; + if (deleg->op == TOKdelegate) + { + fd = ((DelegateExp *)deleg)->func; + pthis = ((DelegateExp *)deleg)->e1; + } + else if (deleg->op == TOKfunction) + fd = ((FuncExp*)deleg)->fd; + + assert(fd && fd->fbody); + assert(fd->parameters); + int numParams = fd->parameters->dim; + assert(numParams == 1 || numParams==2); + + Type *valueType = fd->parameters->tdata()[numParams-1]->type; + Type *keyType = numParams == 2 ? fd->parameters->tdata()[0]->type + : Type::tsize_t; + Expressions args; + args.setDim(numParams); + + AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)aa; + if (!ae->keys || ae->keys->dim == 0) + return new IntegerExp(deleg->loc, 0, Type::tsize_t); + Expression *eresult; + + for (size_t i = 0; i < ae->keys->dim; ++i) + { + Expression *ekey = ae->keys->tdata()[i]; + Expression *evalue = ae->values->tdata()[i]; + args.tdata()[numParams - 1] = evalue; + if (numParams == 2) args.tdata()[0] = ekey; + + eresult = fd->interpret(istate, &args, pthis); + if (exceptionOrCantInterpret(eresult)) + return eresult; + + assert(eresult->op == TOKint64); + if (((IntegerExp *)eresult)->value != 0) + return eresult; + } + return eresult; +} + +// Helper function: given a function of type A[] f(...), +// return A. +Type *returnedArrayElementType(FuncDeclaration *fd) +{ + assert(fd->type->ty == Tfunction); + assert(fd->type->nextOf()->ty == Tarray); + return ((TypeFunction *)fd->type)->nextOf()->nextOf(); +} + +/* Decoding UTF strings for foreach loops. Duplicates the functionality of + * the twelve _aApplyXXn functions in aApply.d in the runtime. + */ +Expression *foreachApplyUtf(InterState *istate, Expression *str, Expression *deleg, bool rvs) +{ +#if LOG + printf("foreachApplyUtf(%s, %s)\n", str->toChars(), deleg->toChars()); +#endif + FuncDeclaration *fd = NULL; + Expression *pthis = NULL; + if (deleg->op == TOKdelegate) + { + fd = ((DelegateExp *)deleg)->func; + pthis = ((DelegateExp *)deleg)->e1; + } + else if (deleg->op == TOKfunction) + fd = ((FuncExp*)deleg)->fd; + + assert(fd && fd->fbody); + assert(fd->parameters); + int numParams = fd->parameters->dim; + assert(numParams == 1 || numParams==2); + Type *charType = fd->parameters->tdata()[numParams-1]->type; + Type *indexType = numParams == 2 ? fd->parameters->tdata()[0]->type + : Type::tsize_t; + uinteger_t len = resolveArrayLength(str); + if (len == 0) + return new IntegerExp(deleg->loc, 0, indexType); + + if (str->op == TOKslice) + str = resolveSlice(str); + + StringExp *se = NULL; + ArrayLiteralExp *ale = NULL; + if (str->op == TOKstring) + se = (StringExp *) str; + else if (str->op == TOKarrayliteral) + ale = (ArrayLiteralExp *)str; + else + { error("CTFE internal error: cannot foreach %s", str->toChars()); + return EXP_CANT_INTERPRET; + } + Expressions args; + args.setDim(numParams); + + Expression *eresult; + + // Buffers for encoding; also used for decoding array literals + unsigned char utf8buf[4]; + unsigned short utf16buf[2]; + + size_t start = rvs ? len : 0; + size_t end = rvs ? 0: len; + for (size_t indx = start; indx != end;) + { + // Step 1: Decode the next dchar from the string. + + const char *errmsg = NULL; // Used for reporting decoding errors + dchar_t rawvalue; // Holds the decoded dchar + size_t currentIndex = indx; // The index of the decoded character + + if (ale) + { // If it is an array literal, copy the code points into the buffer + int buflen = 1; // #code points in the buffer + size_t n = 1; // #code points in this char + size_t sz = ale->type->nextOf()->size(); + + switch(sz) + { + case 1: + if (rvs) + { // find the start of the string + --indx; + buflen = 1; + while (indx > 0 && buflen < 4) + { Expression * r = ale->elements->tdata()[indx]; + assert(r->op == TOKint64); + unsigned char x = (unsigned char)(((IntegerExp *)r)->value); + if ( (x & 0xC0) != 0x80) + break; + ++buflen; + } + } + else + buflen = (indx + 4 > len) ? len - indx : 4; + for (int i=0; i < buflen; ++i) + { + Expression * r = ale->elements->tdata()[indx + i]; + assert(r->op == TOKint64); + utf8buf[i] = (unsigned char)(((IntegerExp *)r)->value); + } + n = 0; + errmsg = utf_decodeChar(&utf8buf[0], buflen, &n, &rawvalue); + break; + case 2: + if (rvs) + { // find the start of the string + --indx; + buflen = 1; + Expression * r = ale->elements->tdata()[indx]; + assert(r->op == TOKint64); + unsigned short x = (unsigned short)(((IntegerExp *)r)->value); + if (indx > 0 && x >= 0xDC00 && x <= 0xDFFF) + { + --indx; + ++buflen; + } + } + else + buflen = (indx + 2 > len) ? len - indx : 2; + for (int i=0; i < buflen; ++i) + { + Expression * r = ale->elements->tdata()[indx + i]; + assert(r->op == TOKint64); + utf16buf[i] = (unsigned short)(((IntegerExp *)r)->value); + } + n = 0; + errmsg = utf_decodeWchar(&utf16buf[0], buflen, &n, &rawvalue); + break; + case 4: + { + if (rvs) + --indx; + + Expression * r = ale->elements->tdata()[indx]; + assert(r->op == TOKint64); + rawvalue = ((IntegerExp *)r)->value; + n = 1; + } + break; + default: + assert(0); + } + if (!rvs) + indx += n; + } + else + { // String literals + size_t saveindx; // used for reverse iteration + + switch (se->sz) + { + case 1: + if (rvs) + { // find the start of the string + unsigned char *s = (unsigned char *)se->string; + --indx; + while (indx > 0 && ((s[indx]&0xC0)==0x80)) + --indx; + saveindx = indx; + } + errmsg = utf_decodeChar((unsigned char *)se->string, se->len, &indx, &rawvalue); + if (rvs) + indx = saveindx; + break; + case 2: + if (rvs) + { // find the start + unsigned short *s = (unsigned short *)se->string; + --indx; + if (s[indx] >= 0xDC00 && s[indx]<= 0xDFFF) + --indx; + saveindx = indx; + } + errmsg = utf_decodeWchar((unsigned short *)se->string, se->len, &indx, &rawvalue); + if (rvs) + indx = saveindx; + break; + case 4: + if (rvs) + --indx; + rawvalue = ((unsigned *)(se->string))[indx]; + if (!rvs) + ++indx; + break; + default: + assert(0); + } + } + if (errmsg) + { deleg->error("%s", errmsg); + return EXP_CANT_INTERPRET; + } + + // Step 2: encode the dchar in the target encoding + + int charlen = 1; // How many codepoints are involved? + switch(charType->size()) + { + case 1: + charlen = utf_codeLengthChar(rawvalue); + utf_encodeChar(&utf8buf[0], rawvalue); + break; + case 2: + charlen = utf_codeLengthWchar(rawvalue); + utf_encodeWchar(&utf16buf[0], rawvalue); + break; + case 4: + break; + default: + assert(0); + } + if (rvs) + currentIndex = indx; + + // Step 3: call the delegate once for each code point + + // The index only needs to be set once + if (numParams == 2) + args.tdata()[0] = new IntegerExp(deleg->loc, currentIndex, indexType); + + Expression *val = NULL; + + for (int k= 0; k < charlen; ++k) + { + dchar_t codepoint; + switch(charType->size()) + { + case 1: + codepoint = utf8buf[k]; + break; + case 2: + codepoint = utf16buf[k]; + break; + case 4: + codepoint = rawvalue; + break; + default: + assert(0); + } + val = new IntegerExp(str->loc, codepoint, charType); + + args.tdata()[numParams - 1] = val; + + eresult = fd->interpret(istate, &args, pthis); + if (exceptionOrCantInterpret(eresult)) + return eresult; + assert(eresult->op == TOKint64); + if (((IntegerExp *)eresult)->value != 0) + return eresult; + } + } + return eresult; +} + +/* If this is a built-in function, return the interpreted result, + * Otherwise, return NULL. + */ +Expression *evaluateIfBuiltin(InterState *istate, Loc loc, + FuncDeclaration *fd, Expressions *arguments, Expression *pthis) +{ + Expression *e = NULL; + int nargs = arguments ? arguments->dim : 0; +#if DMDV2 + if (pthis && isAssocArray(pthis->type)) + { + if (fd->ident == Id::length && nargs==0) + return interpret_length(istate, pthis); + else if (fd->ident == Id::keys && nargs==0) + return interpret_keys(istate, pthis, returnedArrayElementType(fd)); + else if (fd->ident == Id::values && nargs==0) + return interpret_values(istate, pthis, returnedArrayElementType(fd)); + else if (fd->ident == Id::rehash && nargs==0) + return pthis->interpret(istate, ctfeNeedLvalue); // rehash is a no-op + } + if (!pthis) + { + enum BUILTIN b = fd->isBuiltin(); + if (b) + { Expressions args; + args.setDim(nargs); + for (size_t i = 0; i < args.dim; i++) + { + Expression *earg = arguments->tdata()[i]; + earg = earg->interpret(istate); + if (exceptionOrCantInterpret(earg)) + return earg; + args.tdata()[i] = earg; + } + e = eval_builtin(loc, b, &args); + if (!e) + e = EXP_CANT_INTERPRET; + } + } + /* Horrid hack to retrieve the builtin AA functions after they've been + * mashed by the inliner. + */ + if (!pthis) + { + Expression *firstarg = nargs > 0 ? (Expression *)(arguments->data[0]) : NULL; + // Check for the first parameter being a templatized AA. Hack: we assume that + // template AA.var is always the AA data itself. + Expression *firstdotvar = (firstarg && firstarg->op == TOKdotvar) + ? ((DotVarExp *)firstarg)->e1 : NULL; + if (nargs==3 && isAssocArray(firstarg->type) && !strcmp(fd->ident->string, "_aaApply")) + return interpret_aaApply(istate, firstarg, (Expression *)(arguments->data[2])); + if (nargs==3 && isAssocArray(firstarg->type) &&!strcmp(fd->ident->string, "_aaApply2")) + return interpret_aaApply(istate, firstarg, (Expression *)(arguments->data[2])); + if (firstdotvar && isAssocArray(firstdotvar->type)) + { if (fd->ident == Id::aaLen && nargs == 1) + return interpret_length(istate, firstdotvar->interpret(istate)); + else if (fd->ident == Id::aaKeys && nargs == 2) + { + Expression *trueAA = firstdotvar->interpret(istate); + return interpret_keys(istate, trueAA, toBuiltinAAType(trueAA->type)->index); + } + else if (fd->ident == Id::aaValues && nargs == 3) + { + Expression *trueAA = firstdotvar->interpret(istate); + return interpret_values(istate, trueAA, toBuiltinAAType(trueAA->type)->nextOf()); + } + else if (fd->ident == Id::aaRehash && nargs == 2) + { + return firstdotvar->interpret(istate, ctfeNeedLvalue); + } + } + } +#endif +#if DMDV1 + if (!pthis) + { + Expression *firstarg = nargs > 0 ? (Expression *)(arguments->data[0]) : NULL; + if (firstarg && firstarg->type->toBasetype()->ty == Taarray) + { + TypeAArray *firstAAtype = (TypeAArray *)firstarg->type; + if (fd->ident == Id::aaLen && nargs == 1) + return interpret_length(istate, firstarg); + else if (fd->ident == Id::aaKeys) + return interpret_keys(istate, firstarg, firstAAtype->index); + else if (fd->ident == Id::aaValues) + return interpret_values(istate, firstarg, firstAAtype->nextOf()); + else if (nargs==2 && fd->ident == Id::aaRehash) + return firstarg->interpret(istate, ctfeNeedLvalue); //no-op + else if (nargs==3 && !strcmp(fd->ident->string, "_aaApply")) + return interpret_aaApply(istate, firstarg, (Expression *)(arguments->data[2])); + else if (nargs==3 && !strcmp(fd->ident->string, "_aaApply2")) + return interpret_aaApply(istate, firstarg, (Expression *)(arguments->data[2])); + } + } +#endif +#if DMDV2 + if (pthis && !fd->fbody && fd->isCtorDeclaration() && fd->parent && fd->parent->parent && fd->parent->parent->ident == Id::object) + { + if (pthis->op == TOKclassreference && fd->parent->ident == Id::Throwable) + { // At present, the constructors just copy their arguments into the struct. + // But we might need some magic if stack tracing gets added to druntime. + StructLiteralExp *se = ((ClassReferenceExp *)pthis)->value; + assert(arguments->dim <= se->elements->dim); + for (int i = 0; i < arguments->dim; ++i) + { + Expression *e = arguments->tdata()[i]->interpret(istate); + if (exceptionOrCantInterpret(e)) + return e; + se->elements->tdata()[i] = e; + } + return EXP_VOID_INTERPRET; + } + } +#endif + if (nargs == 1 && !pthis && + (fd->ident == Id::criticalenter || fd->ident == Id::criticalexit)) + { // Support synchronized{} as a no-op + return EXP_VOID_INTERPRET; + } + if (!pthis) + { + size_t idlen = strlen(fd->ident->string); + if (nargs == 2 && (idlen == 10 || idlen == 11) + && !strncmp(fd->ident->string, "_aApply", 7)) + { // Functions from aApply.d and aApplyR.d in the runtime + bool rvs = (idlen == 11); // true if foreach_reverse + char c = fd->ident->string[idlen-3]; // char width: 'c', 'w', or 'd' + char s = fd->ident->string[idlen-2]; // string width: 'c', 'w', or 'd' + char n = fd->ident->string[idlen-1]; // numParams: 1 or 2. + // There are 12 combinations + if ( (n == '1' || n == '2') && + (c == 'c' || c == 'w' || c == 'd') && + (s == 'c' || s == 'w' || s == 'd') && c != s) + { Expression *str = arguments->tdata()[0]; + str = str->interpret(istate); + if (exceptionOrCantInterpret(str)) + return str; + return foreachApplyUtf(istate, str, arguments->tdata()[1], rvs); + } + } + } + return e; +} + +/*************************** CTFE Sanity Checks ***************************/ + +/* Setter functions for CTFE variable values. + * These functions exist to check for compiler CTFE bugs. + */ + +bool isCtfeValueValid(Expression *newval) +{ + if ( +#if DMDV2 + newval->type->ty == Tnull || +#endif + isPointer(newval->type) ) + { + if (newval->op == TOKaddress || newval->op == TOKnull || + newval->op == TOKstring) + return true; + if (newval->op == TOKindex) + { + Expression *g = ((IndexExp *)newval)->e1; + if (g->op == TOKarrayliteral || g->op == TOKstring || + g->op == TOKassocarrayliteral) + return true; + } + if (newval->op == TOKvar) + return true; + if (newval->type->nextOf()->ty == Tarray && newval->op == TOKslice) + return true; + if (newval->op == TOKint64) + return true; // Result of a cast, but cannot be dereferenced + // else it must be a reference + } + if (newval->op == TOKclassreference || (newval->op == TOKnull && newval->type->ty == Tclass)) + return true; + if (newval->op == TOKvar) + { + VarExp *ve = (VarExp *)newval; + VarDeclaration *vv = ve->var->isVarDeclaration(); + // Must not be a reference to a reference + if (!(vv && vv->getValue() && vv->getValue()->op == TOKvar)) + return true; + } + if (newval->op == TOKdotvar) + { + if (((DotVarExp *)newval)->e1->op == TOKstructliteral) + { + assert(((StructLiteralExp *)((DotVarExp *)newval)->e1)->ownedByCtfe); + return true; + } + } + if (newval->op == TOKindex) + { + IndexExp *ie = (IndexExp *)newval; + if (ie->e2->op == TOKint64) + { + if (ie->e1->op == TOKarrayliteral || ie->e1->op == TOKstring) + return true; + } + if (ie->e1->op == TOKassocarrayliteral) + return true; + // BUG: Happens ONLY in ref foreach. Should tighten this. + if (ie->e2->op == TOKvar) + return true; + } + if (newval->op == TOKfunction) return true; // function/delegate literal + if (newval->op == TOKdelegate) return true; + if (newval->op == TOKsymoff) // function pointer + { + if (((SymOffExp *)newval)->var->isFuncDeclaration()) + return true; + } + if (newval->op == TOKint64 || newval->op == TOKfloat64 || + newval->op == TOKchar || newval->op == TOKcomplex80) + return true; + + // References + + if (newval->op == TOKstructliteral) + assert(((StructLiteralExp *)newval)->ownedByCtfe); + if (newval->op == TOKarrayliteral) + assert(((ArrayLiteralExp *)newval)->ownedByCtfe); + if (newval->op == TOKassocarrayliteral) + assert(((AssocArrayLiteralExp *)newval)->ownedByCtfe); + + if ((newval->op ==TOKarrayliteral) || ( newval->op==TOKstructliteral) || + (newval->op==TOKstring) || (newval->op == TOKassocarrayliteral) || + (newval->op == TOKnull)) + { return true; + } + // Dynamic arrays passed by ref may be null. When this happens + // they may originate from an index or dotvar expression. + if (newval->type->ty == Tarray || newval->type->ty == Taarray) + if (newval->op == TOKdotvar || newval->op == TOKindex) + return true; // actually must be null + + if (newval->op == TOKslice) + { + SliceExp *se = (SliceExp *)newval; + assert(se->lwr && se->lwr != EXP_CANT_INTERPRET && se->lwr->op == TOKint64); + assert(se->upr && se->upr != EXP_CANT_INTERPRET && se->upr->op == TOKint64); + assert(se->e1->op == TOKarrayliteral || se->e1->op == TOKstring); + if (se->e1->op == TOKarrayliteral) + assert(((ArrayLiteralExp *)se->e1)->ownedByCtfe); + return true; + } + newval->error("CTFE internal error: illegal value %s\n", newval->toChars()); + return false; +} + +bool VarDeclaration::hasValue() +{ + if (ctfeAdrOnStack == (size_t)-1) + return false; + return NULL != getValue(); +} + +Expression *VarDeclaration::getValue() +{ + return ctfeStack.getValue(this); +} + +void VarDeclaration::setValueNull() +{ + ctfeStack.setValue(this, NULL); +} + +// Don't check for validity +void VarDeclaration::setValueWithoutChecking(Expression *newval) +{ + ctfeStack.setValue(this, newval); +} + +void VarDeclaration::setValue(Expression *newval) +{ + assert(isCtfeValueValid(newval)); + ctfeStack.setValue(this, newval); +} diff --git a/intrange.c b/intrange.c new file mode 100644 index 00000000..baf099c0 --- /dev/null +++ b/intrange.c @@ -0,0 +1,1105 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by KennyTM +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include "intrange.h" +#include "mars.h" +#include "mtype.h" +#include "expression.h" + +#ifndef PERFORM_UNITTEST +#define PERFORM_UNITTEST 0 +#endif + +// Copy the sign to the value *x*. Equivalent to `sign ? -x : x`. +static uinteger_t copySign(uinteger_t x, bool sign) +{ + // return sign ? -x : x; + return (x - (uinteger_t)sign) ^ -(uinteger_t)sign; +} + +#ifndef UINT64_MAX +#define UINT64_MAX 0xFFFFFFFFFFFFFFFFULL +#endif + +//==================== SignExtendedNumber ====================================== + +SignExtendedNumber SignExtendedNumber::fromInteger(uinteger_t value_) +{ + return SignExtendedNumber(value_, value_ >> 63); +} + +bool SignExtendedNumber::operator==(const SignExtendedNumber& a) const +{ + return value == a.value && negative == a.negative; +} + +bool SignExtendedNumber::operator<(const SignExtendedNumber& a) const +{ + return (negative && !a.negative) + || (negative == a.negative && value < a.value); +} + +SignExtendedNumber SignExtendedNumber::extreme(bool minimum) +{ + return SignExtendedNumber(minimum-1, minimum); +} + +SignExtendedNumber SignExtendedNumber::max() +{ + return SignExtendedNumber(UINT64_MAX, false); +} + +SignExtendedNumber SignExtendedNumber::operator-() const +{ + if (value == 0) + return SignExtendedNumber(-negative); + else + return SignExtendedNumber(-value, !negative); +} + +SignExtendedNumber SignExtendedNumber::operator+(const SignExtendedNumber& a) const +{ + uinteger_t sum = value + a.value; + bool carry = sum < value && sum < a.value; + if (negative != a.negative) + return SignExtendedNumber(sum, !carry); + else if (negative) + return SignExtendedNumber(carry ? sum : 0, true); + else + return SignExtendedNumber(carry ? UINT64_MAX : sum, false); +} + +SignExtendedNumber SignExtendedNumber::operator-(const SignExtendedNumber& a) const +{ + if (a.isMinimum()) + return negative ? SignExtendedNumber(value, false) : max(); + else + return *this + (-a); +} + + +SignExtendedNumber SignExtendedNumber::operator*(const SignExtendedNumber& a) const +{ + // perform *saturated* multiplication, otherwise we may get bogus ranges + // like 0x10 * 0x10 == 0x100 == 0. + + /* Special handling for zeros: + INT65_MIN * 0 = 0 + INT65_MIN * + = INT65_MIN + INT65_MIN * - = INT65_MAX + 0 * anything = 0 + */ + if (value == 0) + { + if (!negative) + return *this; + else if (a.negative) + return max(); + else + return a.value == 0 ? a : *this; + } + else if (a.value == 0) + return a * *this; // don't duplicate the symmetric case. + + SignExtendedNumber rv; + // these are != 0 now surely. + uinteger_t tAbs = copySign(value, negative); + uinteger_t aAbs = copySign(a.value, a.negative); + rv.negative = negative != a.negative; + if (UINT64_MAX / tAbs < aAbs) + rv.value = rv.negative-1; + else + rv.value = copySign(tAbs * aAbs, rv.negative); + return rv; +} + +SignExtendedNumber SignExtendedNumber::operator/(const SignExtendedNumber& a) const +{ + /* special handling for zeros: + INT65_MIN / INT65_MIN = 1 + anything / INT65_MIN = 0 + + / 0 = INT65_MAX (eh?) + - / 0 = INT65_MIN (eh?) + */ + if (a.value == 0) + { + if (a.negative) + return SignExtendedNumber(value == 0 && negative); + else + return extreme(negative); + } + + uinteger_t aAbs = copySign(a.value, a.negative); + uinteger_t rvVal; + + if (!isMinimum()) + rvVal = copySign(value, negative) / aAbs; + // Special handling for INT65_MIN + // if the denominator is not a power of 2, it is same as UINT64_MAX / x. + else if (aAbs & (aAbs-1)) + rvVal = UINT64_MAX / aAbs; + // otherwise, it's the same as reversing the bits of x. + else + { + if (aAbs == 1) + return extreme(!a.negative); + rvVal = 1ULL << 63; + aAbs >>= 1; + if (aAbs & 0xAAAAAAAAAAAAAAAAULL) rvVal >>= 1; + if (aAbs & 0xCCCCCCCCCCCCCCCCULL) rvVal >>= 2; + if (aAbs & 0xF0F0F0F0F0F0F0F0ULL) rvVal >>= 4; + if (aAbs & 0xFF00FF00FF00FF00ULL) rvVal >>= 8; + if (aAbs & 0xFFFF0000FFFF0000ULL) rvVal >>= 16; + if (aAbs & 0xFFFFFFFF00000000ULL) rvVal >>= 32; + } + bool rvNeg = negative != a.negative; + rvVal = copySign(rvVal, rvNeg); + + return SignExtendedNumber(rvVal, rvVal != 0 && rvNeg); +} + +SignExtendedNumber SignExtendedNumber::operator%(const SignExtendedNumber& a) const +{ + if (a.value == 0) + return !a.negative ? a : isMinimum() ? SignExtendedNumber(0) : *this; + + uinteger_t aAbs = copySign(a.value, a.negative); + uinteger_t rvVal; + + // a % b == sgn(a) * abs(a) % abs(b). + if (!isMinimum()) + rvVal = copySign(value, negative) % aAbs; + // Special handling for INT65_MIN + // if the denominator is not a power of 2, it is same as UINT64_MAX%x + 1. + else if (aAbs & (aAbs - 1)) + rvVal = UINT64_MAX % aAbs + 1; + // otherwise, the modulus is trivially zero. + else + rvVal = 0; + + rvVal = copySign(rvVal, negative); + return SignExtendedNumber(rvVal, rvVal != 0 && negative); +} + +SignExtendedNumber& SignExtendedNumber::operator++() +{ + if (value != UINT64_MAX) + ++ value; + else if (negative) + { + value = 0; + negative = false; + } + return *this; +} + +SignExtendedNumber SignExtendedNumber::operator<<(const SignExtendedNumber& a) const +{ + // assume left-shift the shift-amount is always unsigned. Thus negative + // shifts will give huge result. + if (value == 0) + return *this; + else if (a.negative) + return extreme(negative); + + uinteger_t v = copySign(value, negative); + + // compute base-2 log of 'v' to determine the maximum allowed bits to shift. + // Ref: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog + + size_t r, s; + + r = (v > 0xFFFFFFFFULL) << 5; v >>= r; + s = (v > 0xFFFFULL ) << 4; v >>= s; r |= s; + s = (v > 0xFFULL ) << 3; v >>= s; r |= s; + s = (v > 0xFULL ) << 2; v >>= s; r |= s; + s = (v > 0x3ULL ) << 1; v >>= s; r |= s; + r |= (v >> 1); + + uinteger_t allowableShift = 63 - r; + if (a.value > allowableShift) + return extreme(negative); + else + return SignExtendedNumber(value << a.value, negative); +} + +SignExtendedNumber SignExtendedNumber::operator>>(const SignExtendedNumber& a) const +{ + if (a.negative || a.value > 64) + return negative ? SignExtendedNumber(-1, true) : SignExtendedNumber(0); + else if (isMinimum()) + return a.value == 0 ? *this : SignExtendedNumber(-1ULL << (64-a.value), true); + + uinteger_t x = value ^ -negative; + x >>= a.value; + return SignExtendedNumber(x ^ -negative, negative); +} + + +//==================== IntRange ================================================ + +IntRange IntRange::widest() +{ + return IntRange(SignExtendedNumber::min(), SignExtendedNumber::max()); +} + +#if !PERFORM_UNITTEST +IntRange IntRange::fromType(Type *type) +{ + return fromType(type, type->isunsigned()); +} + +IntRange IntRange::fromType(Type *type, bool isUnsigned) +{ + if (!type->isintegral()) + return widest(); + + uinteger_t mask = type->sizemask(); + SignExtendedNumber lower(0), upper(mask); + if (type->toBasetype()->ty == Tdchar) + upper.value = 0x10FFFFULL; + else if (!isUnsigned) + { + lower.value = ~(mask >> 1); + lower.negative = true; + upper.value = (mask >> 1); + } + return IntRange(lower, upper); +} +#endif + +IntRange IntRange::fromNumbers2(const SignExtendedNumber numbers[2]) +{ + if (numbers[0] < numbers[1]) + return IntRange(numbers[0], numbers[1]); + else + return IntRange(numbers[1], numbers[0]); +} +IntRange IntRange::fromNumbers4(const SignExtendedNumber numbers[4]) +{ + IntRange ab = fromNumbers2(numbers); + IntRange cd = fromNumbers2(numbers + 2); + if (cd.imin < ab.imin) + ab.imin = cd.imin; + if (cd.imax > ab.imax) + ab.imax = cd.imax; + return ab; +} + +bool IntRange::contains(const IntRange& a) const +{ + return imin <= a.imin && imax >= a.imax; +} + +bool IntRange::containsZero() const +{ + return (imin.negative && !imax.negative) + || (!imin.negative && imin.value == 0); +} + +IntRange& IntRange::castUnsigned(uinteger_t mask) +{ + // .... 0x1eff ] [0x1f00 .. 0x1fff] [0 .. 0xff] [0x100 .. 0x1ff] [0x200 .... + // + // regular unsigned type. We just need to see if ir steps across the + // boundary of validRange. If yes, ir will represent the whole validRange, + // otherwise, we just take the modulus. + // e.g. [0x105, 0x107] & 0xff == [5, 7] + // [0x105, 0x207] & 0xff == [0, 0xff] + uinteger_t minChunk = imin.value & ~mask; + uinteger_t maxChunk = imax.value & ~mask; + if (minChunk == maxChunk && imin.negative == imax.negative) + { + imin.value &= mask; + imax.value &= mask; + } + else + { + imin.value = 0; + imax.value = mask; + } + imin.negative = imax.negative = false; + return *this; +} + +IntRange& IntRange::castSigned(uinteger_t mask) +{ + // .... 0x1e7f ] [0x1e80 .. 0x1f7f] [0x1f80 .. 0x7f] [0x80 .. 0x17f] [0x180 .... + // + // regular signed type. We use a technique similar to the unsigned version, + // but the chunk has to be offset by 1/2 of the range. + uinteger_t halfChunkMask = mask >> 1; + uinteger_t minHalfChunk = imin.value & ~halfChunkMask; + uinteger_t maxHalfChunk = imax.value & ~halfChunkMask; + int minHalfChunkNegativity = imin.negative; // 1 = neg, 0 = nonneg, -1 = chunk containing ::max + int maxHalfChunkNegativity = imax.negative; + if (minHalfChunk & mask) + { + minHalfChunk += halfChunkMask+1; + if (minHalfChunk == 0) + -- minHalfChunkNegativity; + } + if (maxHalfChunk & mask) + { + maxHalfChunk += halfChunkMask+1; + if (maxHalfChunk == 0) + -- maxHalfChunkNegativity; + } + if (minHalfChunk == maxHalfChunk && minHalfChunkNegativity == maxHalfChunkNegativity) + { + imin.value &= mask; + imax.value &= mask; + // sign extend if necessary. + imin.negative = imin.value & ~halfChunkMask; + imax.negative = imax.value & ~halfChunkMask; + halfChunkMask += 1; + imin.value = (imin.value ^ halfChunkMask) - halfChunkMask; + imax.value = (imax.value ^ halfChunkMask) - halfChunkMask; + } + else + { + imin = SignExtendedNumber(~halfChunkMask, true); + imax = SignExtendedNumber(halfChunkMask, false); + } + return *this; +} + +IntRange& IntRange::castDchar() +{ + // special case for dchar. Casting to dchar means "I'll ignore all + // invalid characters." + castUnsigned(0xFFFFFFFFULL); + if (imin.value > 0x10FFFFULL) // ?? + imin.value = 0x10FFFFULL; // ?? + if (imax.value > 0x10FFFFULL) + imax.value = 0x10FFFFULL; + return *this; +} + +#if !PERFORM_UNITTEST +IntRange& IntRange::cast(Type *type) +{ + if (!type->isintegral()) + return *this; + else if (!type->isunsigned()) + return castSigned(type->sizemask()); + else if (type->toBasetype()->ty == Tdchar) + return castDchar(); + else + return castUnsigned(type->sizemask()); +} + +IntRange& IntRange::castUnsigned(Type *type) +{ + if (!type->isintegral()) + return castUnsigned(UINT64_MAX); + else if (type->toBasetype()->ty == Tdchar) + return castDchar(); + else + return castUnsigned(type->sizemask()); +} +#endif + +IntRange IntRange::absNeg() const +{ + if (imax.negative) + return *this; + else if (!imin.negative) + return IntRange(-imax, -imin); + else + { + SignExtendedNumber imaxAbsNeg = -imax; + return IntRange(imaxAbsNeg < imin ? imaxAbsNeg : imin, + SignExtendedNumber(0)); + } +} + +IntRange IntRange::unionWith(const IntRange& other) const +{ + return IntRange(imin < other.imin ? imin : other.imin, + imax > other.imax ? imax : other.imax); +} + +void IntRange::unionOrAssign(const IntRange& other, bool& union_) +{ + if (!union_ || imin > other.imin) + imin = other.imin; + if (!union_ || imax < other.imax) + imax = other.imax; + union_ = true; +} + +void IntRange::splitBySign(IntRange& negRange, bool& hasNegRange, + IntRange& nonNegRange, bool& hasNonNegRange) const +{ + hasNegRange = imin.negative; + if (hasNegRange) + { + negRange.imin = imin; + negRange.imax = imax.negative ? imax : SignExtendedNumber(-1, true); + } + hasNonNegRange = !imax.negative; + if (hasNonNegRange) + { + nonNegRange.imin = imin.negative ? SignExtendedNumber(0) : imin; + nonNegRange.imax = imax; + } +} + + +#if !PERFORM_UNITTEST +const IntRange& IntRange::dump(const char* funcName, Expression *e) const +{ + printf("[(%c)%#018llx, (%c)%#018llx] @ %s ::: %s\n", + imin.negative?'-':'+', (unsigned long long)imin.value, + imax.negative?'-':'+', (unsigned long long)imax.value, + funcName, e->toChars()); + return *this; +} +#endif + +//------------------------------------------------------------------------------ + +#if PERFORM_UNITTEST +#include +#include + +class AssertionError : public std::exception { +public: + AssertionError() : std::exception() {} +}; + +void _assertPred(uinteger_t x, uinteger_t y, int line) { + if (x != y) { + printf("Line %d: %#018llx != %#018llx\n", line, x, y); + throw AssertionError(); + } +} +void _assertPred(const SignExtendedNumber& x, const SignExtendedNumber& y, int line) { + if (x != y) { + printf("Line %d: (%c)%#018llx != (%c)%#018llx\n", line, + x.negative?'-':'+', x.value, + y.negative?'-':'+', y.value); + throw AssertionError(); + } +} +void _assertPred(bool x, bool y, int line) { + if (x != y) { + static const char* const names[] = {"false", "true"}; + printf("Line %d: %s != %s\n", line, names[x], names[y]); + throw AssertionError(); + } +} +#define assertPred(x, y) _assertPred(x, y, __LINE__) +#define RUN(testName) \ + try { \ + testName(); \ + } catch (const AssertionError&) { \ + printf("********" #testName " failed\n"); \ + } + +void testAssertSanity() { + int saneCount = 0; + + printf("Testing 'assert' sanity. You should see 3 assertion failures below\n"); + + assertPred(true, true); + try { + assertPred(true, false); + } catch (const AssertionError&) { + ++ saneCount; + } + + assertPred(4ULL, 4ULL); + try { + assertPred(3ULL, -3ULL); + } catch (const AssertionError&) { + ++ saneCount; + } + + assertPred(SignExtendedNumber(5, false), SignExtendedNumber(5, false)); + try { + assertPred(SignExtendedNumber(4, false), SignExtendedNumber(4, true)); + } catch (const AssertionError&) { + ++ saneCount; + } + + printf("--------------\n"); + + if (saneCount != 3) throw AssertionError(); +} + +void testNegation() { + SignExtendedNumber s (4); + SignExtendedNumber t = -s; + assertPred(t.value, -4ULL); + assertPred(t.negative, true); + + s = SignExtendedNumber::max(); + t = -s; + assertPred(t.value, 1); + assertPred(t.negative, true); + + s = SignExtendedNumber::fromInteger(-4); + assertPred(s.value, -4ULL); + assertPred(s.negative, true); + + t = -s; + assertPred(t.value, 4); + assertPred(t.negative, false); + + s = SignExtendedNumber::min(); + t = -s; + assertPred(t.value, UINT64_MAX); + assertPred(t.negative, false); + + s = SignExtendedNumber(0); + t = -s; + assertPred(t.value, 0); + assertPred(t.negative, false); +} + +void testCompare() { + SignExtendedNumber a = SignExtendedNumber::min(); + SignExtendedNumber b = SignExtendedNumber(-5, true); + SignExtendedNumber c = SignExtendedNumber(0, false); + SignExtendedNumber d = SignExtendedNumber(5, false); + SignExtendedNumber e = SignExtendedNumber::max(); + + assertPred(a == a, true); + assertPred(a != a, false); + assertPred(a < b, true); + assertPred(b < c, true); + assertPred(c < d, true); + assertPred(d < e, true); + assertPred(a < c, true); + assertPred(c < e, true); + assertPred(b < d, true); + assertPred(b < a, false); + assertPred(c < b, false); + assertPred(d < c, false); + assertPred(e < d, false); + assertPred(e < c, false); + assertPred(d < b, false); + assertPred(c < a, false); + + assertPred(a, a); + assertPred(SignExtendedNumber::extreme(false), SignExtendedNumber::max()); + assertPred(SignExtendedNumber::extreme(true), SignExtendedNumber::min()); +} + +void testAddition() { + assertPred(SignExtendedNumber(4, false) + SignExtendedNumber(8, false), + SignExtendedNumber(12, false)); + assertPred(SignExtendedNumber(4, false) + SignExtendedNumber(-9, true), + SignExtendedNumber(-5, true)); + assertPred(SignExtendedNumber(-9, true) + SignExtendedNumber(4, false), + SignExtendedNumber(-5, true)); + assertPred(SignExtendedNumber(-4, true) + SignExtendedNumber(9, false), + SignExtendedNumber(5, false)); + assertPred(SignExtendedNumber(9, false) + SignExtendedNumber(-4, true), + SignExtendedNumber(5, false)); + assertPred(SignExtendedNumber(9, true) + SignExtendedNumber(-4, false), + SignExtendedNumber(5, false)); + assertPred(SignExtendedNumber(-4, true) + SignExtendedNumber(-6, true), + SignExtendedNumber(-10, true)); + assertPred(SignExtendedNumber::max() + SignExtendedNumber(1, false), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(UINT64_MAX/2+1, false) + SignExtendedNumber(UINT64_MAX/2+1, false), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::max() + SignExtendedNumber::min(), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber::min() + SignExtendedNumber(-1, true), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::max() + SignExtendedNumber::max(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::min() + SignExtendedNumber::min(), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(1, true) + SignExtendedNumber(1, true), + SignExtendedNumber::min()); + + SignExtendedNumber x(0); + assertPred(++x, SignExtendedNumber(1)); + x = SignExtendedNumber(-1, true); + assertPred(++x, SignExtendedNumber(0)); + x = SignExtendedNumber::min(); + assertPred(++x, SignExtendedNumber(1, true)); + x = SignExtendedNumber::max(); + assertPred(++x, SignExtendedNumber::max()); +} + +void testSubtraction() { + assertPred(SignExtendedNumber(4, false) - SignExtendedNumber(8, false), + SignExtendedNumber(-4, true)); + assertPred(SignExtendedNumber(4, false) - SignExtendedNumber(-9, true), + SignExtendedNumber(13, false)); + assertPred(SignExtendedNumber(-9, true) - SignExtendedNumber(4, false), + SignExtendedNumber(-13, true)); + assertPred(SignExtendedNumber(-4, true) - SignExtendedNumber(9, false), + SignExtendedNumber(-13, true)); + assertPred(SignExtendedNumber(9, false) - SignExtendedNumber(-4, true), + SignExtendedNumber(13, false)); + assertPred(SignExtendedNumber(9, true) - SignExtendedNumber(-4, false), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(-4, true) - SignExtendedNumber(-6, true), + SignExtendedNumber(2, false)); + assertPred(SignExtendedNumber::max() - SignExtendedNumber(-1, true), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::max() - SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() - SignExtendedNumber::min(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::min() - SignExtendedNumber(1, false), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(1, false) - SignExtendedNumber::min(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::min() - SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(1, true) - SignExtendedNumber::min(), + SignExtendedNumber(1, false)); +} + +void testMultiplication() { + assertPred(SignExtendedNumber(4, false) * SignExtendedNumber(8, false), + SignExtendedNumber(32, false)); + assertPred(SignExtendedNumber(4, false) * SignExtendedNumber(-9, true), + SignExtendedNumber(-36, true)); + assertPred(SignExtendedNumber(-9, true) * SignExtendedNumber(4, false), + SignExtendedNumber(-36, true)); + assertPred(SignExtendedNumber(-4, true) * SignExtendedNumber(9, false), + SignExtendedNumber(-36, true)); + assertPred(SignExtendedNumber(9, false) * SignExtendedNumber(-4, true), + SignExtendedNumber(-36, true)); + assertPred(SignExtendedNumber(9, true) * SignExtendedNumber(-4, false), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(-4, true) * SignExtendedNumber(-6, true), + SignExtendedNumber(24, false)); + assertPred(SignExtendedNumber::max() * SignExtendedNumber::max(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::max() * SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() * SignExtendedNumber::min(), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(0) * SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) * SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) * SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() * SignExtendedNumber::max(), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::min() * SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() * SignExtendedNumber::min(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(-6, false) * SignExtendedNumber(2, false), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(-6, false) * SignExtendedNumber(-2, true), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::max() * SignExtendedNumber(-1, true), + SignExtendedNumber(1, true)); + assertPred(SignExtendedNumber::max() * SignExtendedNumber(-2, true), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::max() * SignExtendedNumber(2, false), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::min() * SignExtendedNumber(2, false), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::min() * SignExtendedNumber(-1, true), + SignExtendedNumber::max()); +} + +void testDivision() { + assertPred(SignExtendedNumber(4, false) / SignExtendedNumber(8, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(8, false) / SignExtendedNumber(4, false), + SignExtendedNumber(2, false)); + assertPred(SignExtendedNumber(4, false) / SignExtendedNumber(-9, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(-9, true) / SignExtendedNumber(4, false), + SignExtendedNumber(-2, true)); + assertPred(SignExtendedNumber(-4, true) / SignExtendedNumber(9, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(9, false) / SignExtendedNumber(-4, true), + SignExtendedNumber(-2, true)); + assertPred(SignExtendedNumber(4, true) / SignExtendedNumber(-9, false), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(-6, true) / SignExtendedNumber(-4, true), + SignExtendedNumber(1, false)); + assertPred(SignExtendedNumber::max() / SignExtendedNumber::max(), + SignExtendedNumber(1)); + assertPred(SignExtendedNumber::max() / SignExtendedNumber(0), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::max() / SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) / SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) / SignExtendedNumber(0), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(0) / SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() / SignExtendedNumber::max(), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber::min() / SignExtendedNumber(0), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::min() / SignExtendedNumber::min(), + SignExtendedNumber(1)); + assertPred(SignExtendedNumber(-6, false) / SignExtendedNumber(2, false), + SignExtendedNumber((~5ULL)>>1)); + assertPred(SignExtendedNumber(-6, false) / SignExtendedNumber(-2, true), + SignExtendedNumber(3 | 1ULL<<63, true)); + assertPred(SignExtendedNumber::max() / SignExtendedNumber(-1, true), + SignExtendedNumber(1, true)); + assertPred(SignExtendedNumber::min() / SignExtendedNumber(-1, true), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::max() / SignExtendedNumber(1, false), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber::min() / SignExtendedNumber(1, false), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber::min() / SignExtendedNumber(2, false), + SignExtendedNumber(-(1ULL << 63), true)); + assertPred(SignExtendedNumber::min() / SignExtendedNumber(-1024, true), + SignExtendedNumber(1ULL << 54)); +} + +void testModulus() { + assertPred(SignExtendedNumber(4, false) % SignExtendedNumber(8, false), + SignExtendedNumber(4, false)); + assertPred(SignExtendedNumber(8, false) % SignExtendedNumber(4, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(4, false) % SignExtendedNumber(-9, true), + SignExtendedNumber(4, false)); + assertPred(SignExtendedNumber(-9, true) % SignExtendedNumber(4, false), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(-4, true) % SignExtendedNumber(9, false), + SignExtendedNumber(-4, true)); + assertPred(SignExtendedNumber(9, false) % SignExtendedNumber(-4, true), + SignExtendedNumber(1, false)); + assertPred(SignExtendedNumber(4, true) % SignExtendedNumber(-9, false), + SignExtendedNumber(-5, true)); + assertPred(SignExtendedNumber(-6, true) % SignExtendedNumber(-4, true), + SignExtendedNumber(-2, true)); + assertPred(SignExtendedNumber::max() % SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() % SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() % SignExtendedNumber::min(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(0) % SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) % SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) % SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber::max(), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber(0), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(-6, false) % SignExtendedNumber(2, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(-6, false) % SignExtendedNumber(-2, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() % SignExtendedNumber(-1, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber(-1, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::max() % SignExtendedNumber(1, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber(1, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber(2, false), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber::min() % SignExtendedNumber(999, false), + SignExtendedNumber(-160, true)); +} + +void testShift() { + assertPred(SignExtendedNumber(0) << SignExtendedNumber(4), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) << SignExtendedNumber(74), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) << SignExtendedNumber(-5, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) << SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) << SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(1) << SignExtendedNumber(4), + SignExtendedNumber(16)); + assertPred(SignExtendedNumber(1) << SignExtendedNumber(74), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(1) << SignExtendedNumber(-5, true), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(1) << SignExtendedNumber::max(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(1) << SignExtendedNumber::min(), + SignExtendedNumber::max()); + assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(4), + SignExtendedNumber(-16, true)); + assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(74), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(-5, true), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber::max(), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber::min(), + SignExtendedNumber::min()); + assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(12, false), + SignExtendedNumber(0xabcdef000ULL)); + assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(40, false), + SignExtendedNumber(0xabcdef0000000000ULL)); + assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(41, false), + SignExtendedNumber::max()); + + + assertPred(SignExtendedNumber(0) >> SignExtendedNumber(4), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) >> SignExtendedNumber(74), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) >> SignExtendedNumber(-5, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) >> SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(0) >> SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(16) >> SignExtendedNumber(4), + SignExtendedNumber(1)); + assertPred(SignExtendedNumber(16) >> SignExtendedNumber(74), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(16) >> SignExtendedNumber(-5, true), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(16) >> SignExtendedNumber::max(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(16) >> SignExtendedNumber::min(), + SignExtendedNumber(0)); + assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(4), + SignExtendedNumber(-2, true)); + assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(74), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(-5, true), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber::max(), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber::min(), + SignExtendedNumber(-1, true)); + assertPred(SignExtendedNumber(0xabcdef, false) >> SignExtendedNumber(12, false), + SignExtendedNumber(0xabcULL)); + assertPred(SignExtendedNumber(0xabcdef, true) >> SignExtendedNumber(12, false), + SignExtendedNumber(0xFFF0000000000ABCULL, true)); + assertPred(SignExtendedNumber::min() >> SignExtendedNumber(1, false), + SignExtendedNumber(0x8000000000000000ULL, true)); + assertPred(SignExtendedNumber::min() >> SignExtendedNumber(63, false), + SignExtendedNumber(-2, true)); + assertPred(SignExtendedNumber::min() >> SignExtendedNumber(65, false), + SignExtendedNumber(-1, true)); +} + +void testFromNumbers() { + SignExtendedNumber a[] = { + SignExtendedNumber(12, false), + SignExtendedNumber(-35, true), + SignExtendedNumber(40, false), + SignExtendedNumber(-21, true), + SignExtendedNumber::min() + }; + + IntRange ir1 = IntRange::fromNumbers2(a); + assertPred(ir1.imin, SignExtendedNumber(-35, true)); + assertPred(ir1.imax, SignExtendedNumber(12, false)); + + IntRange ir2 = IntRange::fromNumbers2(a+1); + assertPred(ir2.imin, SignExtendedNumber(-35, true)); + assertPred(ir2.imax, SignExtendedNumber(40, false)); + + IntRange ir3 = IntRange::fromNumbers4(a); + assertPred(ir3.imin, SignExtendedNumber(-35, true)); + assertPred(ir3.imax, SignExtendedNumber(40, false)); + + IntRange ir4 = IntRange::fromNumbers4(a+1); + assertPred(ir4.imin, SignExtendedNumber::min()); + assertPred(ir4.imax, SignExtendedNumber(40, false)); + + assertPred(ir4.contains(ir3), true); + assertPred(ir1.contains(ir2), false); + + IntRange ir5 = IntRange::widest(); + assertPred(ir5.imin, SignExtendedNumber::min()); + assertPred(ir5.imax, SignExtendedNumber::max()); + assertPred(ir5.contains(ir4), true); +} + +void testContainsZero() { + IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(4)); + assertPred(ir1.containsZero(), true); + + IntRange ir2 (SignExtendedNumber(-4, true), SignExtendedNumber(0)); + assertPred(ir2.containsZero(), true); + + IntRange ir3 (SignExtendedNumber(-5, true), SignExtendedNumber(5)); + assertPred(ir3.containsZero(), true); + + assertPred(IntRange::widest().containsZero(), true); + + IntRange ir4 (SignExtendedNumber(8), SignExtendedNumber(9)); + assertPred(ir4.containsZero(), false); + + IntRange ir5 (SignExtendedNumber(-5, true), SignExtendedNumber(-2, true)); + assertPred(ir5.containsZero(), false); + + IntRange ir6 (SignExtendedNumber(0), SignExtendedNumber(0)); + assertPred(ir6.containsZero(), true); +} + +void testCast() { + { + IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0xFFFF)); + ir1.castUnsigned(0xFF); + assertPred(ir1.imin, SignExtendedNumber(0)); + assertPred(ir1.imax, SignExtendedNumber(0xFF)); + + IntRange ir2 (SignExtendedNumber(0x101), SignExtendedNumber(0x105)); + ir2.castUnsigned(0xFF); + assertPred(ir2.imin, SignExtendedNumber(1)); + assertPred(ir2.imax, SignExtendedNumber(5)); + + IntRange ir3 (SignExtendedNumber(-7, true), SignExtendedNumber(7, false)); + ir3.castUnsigned(0xFF); + assertPred(ir3.imin, SignExtendedNumber(0)); + assertPred(ir3.imax, SignExtendedNumber(0xFF)); + + IntRange ir4 (SignExtendedNumber(0x997F), SignExtendedNumber(0x9999)); + ir4.castUnsigned(0xFF); + assertPred(ir4.imin, SignExtendedNumber(0x7F)); + assertPred(ir4.imax, SignExtendedNumber(0x99)); + + IntRange ir5 (SignExtendedNumber(-1, true), SignExtendedNumber(1, false)); + ir5.castUnsigned(UINT64_MAX); + assertPred(ir5.imin, SignExtendedNumber(0)); + assertPred(ir5.imax, SignExtendedNumber::max()); + + IntRange ir6 (SignExtendedNumber::min(), SignExtendedNumber(0)); + ir6.castUnsigned(UINT64_MAX); + assertPred(ir6.imin, SignExtendedNumber(0)); + assertPred(ir6.imax, SignExtendedNumber::max()); + + IntRange ir7 (SignExtendedNumber::min(), SignExtendedNumber(-0x80, true)); + ir7.castUnsigned(UINT64_MAX); + assertPred(ir7.imin, SignExtendedNumber(0)); + assertPred(ir7.imax, SignExtendedNumber(-0x80, false)); + + IntRange ir8 = IntRange::widest(); + ir8.castUnsigned(0xFF); + assertPred(ir8.imin, SignExtendedNumber(0)); + assertPred(ir8.imax, SignExtendedNumber(0xFF)); + } + + { + IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0xFFFF)); + ir1.castSigned(0xFF); + assertPred(ir1.imin, SignExtendedNumber(-0x80, true)); + assertPred(ir1.imax, SignExtendedNumber(0x7F, false)); + + IntRange ir2 (SignExtendedNumber(0x101), SignExtendedNumber(0x105)); + ir2.castSigned(0xFF); + assertPred(ir2.imin, SignExtendedNumber(1)); + assertPred(ir2.imax, SignExtendedNumber(5)); + + IntRange ir3 (SignExtendedNumber(-7, true), SignExtendedNumber(7, false)); + ir3.castSigned(0xFF); + assertPred(ir3.imin, SignExtendedNumber(-7, true)); + assertPred(ir3.imax, SignExtendedNumber(7, false)); + + IntRange ir4 (SignExtendedNumber(0x997F), SignExtendedNumber(0x9999)); + ir4.castSigned(0xFF); + assertPred(ir4.imin, SignExtendedNumber(-0x80, true)); + assertPred(ir4.imax, SignExtendedNumber(0x7F, false)); + + IntRange ir5 (SignExtendedNumber(-0xFF, true), SignExtendedNumber(-0x80, true)); + ir5.castSigned(0xFF); + assertPred(ir5.imin, SignExtendedNumber(-0x80, true)); + assertPred(ir5.imax, SignExtendedNumber(0x7F, false)); + + IntRange ir6 (SignExtendedNumber(-0x80, true), SignExtendedNumber(-0x80, true)); + ir6.castSigned(0xFF); + assertPred(ir6.imin, SignExtendedNumber(-0x80, true)); + assertPred(ir6.imax, SignExtendedNumber(-0x80, true)); + + IntRange ir7 = IntRange::widest(); + ir7.castSigned(0xFFFFFFFFULL); + assertPred(ir7.imin, SignExtendedNumber(-0x80000000ULL, true)); + assertPred(ir7.imax, SignExtendedNumber( 0x7FFFFFFFULL, false)); + } + + { + IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0x9999)); + ir1.castDchar(); + assertPred(ir1.imin, SignExtendedNumber(0)); + assertPred(ir1.imax, SignExtendedNumber(0x9999)); + + IntRange ir2 (SignExtendedNumber(0xFFFF), SignExtendedNumber(0x7FFFFFFF)); + ir2.castDchar(); + assertPred(ir2.imin, SignExtendedNumber(0xFFFF)); + assertPred(ir2.imax, SignExtendedNumber(0x10FFFF)); + + IntRange ir3 = IntRange::widest(); + ir3.castDchar(); + assertPred(ir3.imin, SignExtendedNumber(0)); + assertPred(ir3.imax, SignExtendedNumber(0x10FFFF)); + } +} + +void testAbsNeg() { + IntRange ir1 = IntRange(SignExtendedNumber(5), SignExtendedNumber(104)).absNeg(); + assertPred(ir1.imin, SignExtendedNumber(-104, true)); + assertPred(ir1.imax, SignExtendedNumber(-5, true)); + + IntRange ir2 = IntRange(SignExtendedNumber(-46, true), SignExtendedNumber(-3, true)).absNeg(); + assertPred(ir2.imin, SignExtendedNumber(-46, true)); + assertPred(ir2.imax, SignExtendedNumber(-3, true)); + + IntRange ir3 = IntRange(SignExtendedNumber(-7, true), SignExtendedNumber(9)).absNeg(); + assertPred(ir3.imin, SignExtendedNumber(-9, true)); + assertPred(ir3.imax, SignExtendedNumber(0)); + + IntRange ir4 = IntRange(SignExtendedNumber(-12, true), SignExtendedNumber(2)).absNeg(); + assertPred(ir4.imin, SignExtendedNumber(-12, true)); + assertPred(ir4.imax, SignExtendedNumber(0)); + + IntRange ir5 = IntRange::widest().absNeg(); + assertPred(ir5.imin, SignExtendedNumber::min()); + assertPred(ir5.imax, SignExtendedNumber(0)); + + IntRange ir6 = IntRange(SignExtendedNumber(0), SignExtendedNumber::max()).absNeg(); + assertPred(ir6.imin, SignExtendedNumber(1, true)); + assertPred(ir6.imax, SignExtendedNumber(0)); +} + +int main() { + RUN(testAssertSanity); + RUN(testNegation); + RUN(testCompare); + RUN(testAddition); + RUN(testSubtraction); + RUN(testMultiplication); + RUN(testDivision); + RUN(testModulus); + RUN(testShift); + RUN(testFromNumbers); + RUN(testContainsZero); + RUN(testCast); + RUN(testAbsNeg); + printf("Finished all tests.\n"); +} + + +#endif + + diff --git a/intrange.h b/intrange.h new file mode 100644 index 00000000..77685b02 --- /dev/null +++ b/intrange.h @@ -0,0 +1,149 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by KennyTM +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#ifndef DMD_SXNUM_H +#define DMD_SXNUM_H + +#include "mars.h" // for uinteger_t +struct Type; +struct Expression; + +/** +This class represents a "sign-extended number", i.e. a 65-bit number, which can +represent all built-in integer types in D. This class is mainly used for +performing value-range propagation only, therefore all arithmetic are done with +saturation, not wrapping as usual. +*/ +struct SignExtendedNumber +{ + /// The lower 64-bit of the number. + uinteger_t value; + /// The sign (i.e. the most significant bit) of the number. + bool negative; + + /// Create an uninitialized sign-extended number. + SignExtendedNumber() {} + + /// Create a sign-extended number from an unsigned 64-bit number. + SignExtendedNumber(uinteger_t value_) + : value(value_), negative(false) {} + /// Create a sign-extended number from the lower 64-bit and the sign bit. + SignExtendedNumber(uinteger_t value_, bool negative_) + : value(value_), negative(negative_) {} + + /// Create a sign-extended number from a signed 64-bit number. + static SignExtendedNumber fromInteger(uinteger_t value_); + + /// Get the minimum or maximum value of a sign-extended number. + static SignExtendedNumber extreme(bool minimum); + static SignExtendedNumber max(); + static SignExtendedNumber min() { return SignExtendedNumber(0, true); } + + /// Check if the sign-extended number is minimum or zero. + bool isMinimum() const { return negative && value == 0; } + + /// Compare two sign-extended number. + bool operator==(const SignExtendedNumber&) const; + bool operator!=(const SignExtendedNumber& a) const { return !(*this == a); } + bool operator<(const SignExtendedNumber&) const; + bool operator>(const SignExtendedNumber& a) const { return a < *this; } + bool operator<=(const SignExtendedNumber& a) const { return !(a < *this); } + bool operator>=(const SignExtendedNumber& a) const { return !(*this < a); } + + /// Compute the saturated negation of a sign-extended number. + SignExtendedNumber operator-() const; + + /// Compute the saturated sum of two sign-extended number. + SignExtendedNumber operator+(const SignExtendedNumber&) const; + /// Compute the saturated difference of two sign-extended number. + SignExtendedNumber operator-(const SignExtendedNumber& a) const; + /// Compute the saturated product of two sign-extended number. + SignExtendedNumber operator*(const SignExtendedNumber&) const; + /// Compute the saturated quotient of two sign-extended number. + SignExtendedNumber operator/(const SignExtendedNumber&) const; + /// Compute the saturated modulus of two sign-extended number. + SignExtendedNumber operator%(const SignExtendedNumber&) const; + + /// Increase the sign-extended number by 1 (saturated). + SignExtendedNumber& operator++(); + + /// Compute the saturated shifts of two sign-extended number. + SignExtendedNumber operator<<(const SignExtendedNumber&) const; + SignExtendedNumber operator>>(const SignExtendedNumber&) const; +}; + +/** +This class represents a range of integers, denoted by its lower and upper bounds +(inclusive). +*/ +struct IntRange +{ + SignExtendedNumber imin, imax; + + /// Create an uninitialized range. + IntRange() {} + + /// Create a range consisting of a single number. + IntRange(const SignExtendedNumber& a) + : imin(a), imax(a) {} + /// Create a range with the lower and upper bounds. + IntRange(const SignExtendedNumber& lower, const SignExtendedNumber& upper) + : imin(lower), imax(upper) {} + + /// Create the tightest range containing all valid integers in the specified + /// type. + static IntRange fromType(Type *type); + /// Create the tightest range containing all valid integers in the type with + /// a forced signedness. + static IntRange fromType(Type *type, bool isUnsigned); + + + /// Create the tightest range containing all specified numbers. + static IntRange fromNumbers2(const SignExtendedNumber numbers[2]); + static IntRange fromNumbers4(const SignExtendedNumber numbers[4]); + + /// Create the widest range possible. + static IntRange widest(); + + /// Cast the integer range to a signed type with the given size mask. + IntRange& castSigned(uinteger_t mask); + /// Cast the integer range to an unsigned type with the given size mask. + IntRange& castUnsigned(uinteger_t mask); + /// Cast the integer range to the dchar type. + IntRange& castDchar(); + + /// Cast the integer range to a specific type. + IntRange& cast(Type *type); + /// Cast the integer range to a specific type, forcing it to be unsigned. + IntRange& castUnsigned(Type *type); + + /// Check if this range contains another range. + bool contains(const IntRange& a) const; + + /// Check if this range contains 0. + bool containsZero() const; + + /// Compute the range of the negated absolute values of the original range. + IntRange absNeg() const; + + /// Compute the union of two ranges. + IntRange unionWith(const IntRange& other) const; + void unionOrAssign(const IntRange& other, bool& union_); + + /// Dump the content of the integer range to the console. + const IntRange& dump(const char* funcName, Expression *e) const; + + /// Split the range into two nonnegative- and negative-only subintervals. + void splitBySign(IntRange& negRange, bool& hasNegRange, + IntRange& nonNegRange, bool& hasNonNegRange) const; +}; + +#endif diff --git a/irstate.c b/irstate.c new file mode 100644 index 00000000..42649bb0 --- /dev/null +++ b/irstate.c @@ -0,0 +1,191 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#include + +#include "mars.h" +#include "mtype.h" +#include "declaration.h" +#include "irstate.h" + +IRState::IRState(IRState *irs, Statement *s) +{ + prev = irs; + statement = s; + symbol = NULL; + breakBlock = NULL; + contBlock = NULL; + switchBlock = NULL; + defaultBlock = NULL; + ident = NULL; + ehidden = NULL; + startaddress = NULL; + if (irs) + { + m = irs->m; + shidden = irs->shidden; + sclosure = irs->sclosure; + sthis = irs->sthis; + blx = irs->blx; + deferToObj = irs->deferToObj; + varsInScope = irs->varsInScope; + } + else + { + m = NULL; + shidden = NULL; + sclosure = NULL; + sthis = NULL; + blx = NULL; + deferToObj = NULL; + varsInScope = NULL; + } +} + +IRState::IRState(IRState *irs, Dsymbol *s) +{ + prev = irs; + statement = NULL; + symbol = s; + breakBlock = NULL; + contBlock = NULL; + switchBlock = NULL; + defaultBlock = NULL; + ident = NULL; + ehidden = NULL; + startaddress = NULL; + if (irs) + { + m = irs->m; + shidden = irs->shidden; + sclosure = irs->sclosure; + sthis = irs->sthis; + blx = irs->blx; + deferToObj = irs->deferToObj; + varsInScope = irs->varsInScope; + } + else + { + m = NULL; + shidden = NULL; + sclosure = NULL; + sthis = NULL; + blx = NULL; + deferToObj = NULL; + varsInScope = NULL; + } +} + +IRState::IRState(Module *m, Dsymbol *s) +{ + prev = NULL; + statement = NULL; + this->m = m; + symbol = s; + breakBlock = NULL; + contBlock = NULL; + switchBlock = NULL; + defaultBlock = NULL; + ident = NULL; + ehidden = NULL; + shidden = NULL; + sclosure = NULL; + sthis = NULL; + blx = NULL; + deferToObj = NULL; + startaddress = NULL; + varsInScope = NULL; +} + +block *IRState::getBreakBlock(Identifier *ident) +{ + IRState *bc; + + for (bc = this; bc; bc = bc->prev) + { + if (ident) + { + if (bc->prev && bc->prev->ident == ident) + return bc->breakBlock; + } + else if (bc->breakBlock) + return bc->breakBlock; + } + return NULL; +} + +block *IRState::getContBlock(Identifier *ident) +{ + IRState *bc; + + for (bc = this; bc; bc = bc->prev) + { + if (ident) + { + if (bc->prev && bc->prev->ident == ident) + return bc->contBlock; + } + else if (bc->contBlock) + return bc->contBlock; + } + return NULL; +} + +block *IRState::getSwitchBlock() +{ + IRState *bc; + + for (bc = this; bc; bc = bc->prev) + { + if (bc->switchBlock) + return bc->switchBlock; + } + return NULL; +} + +block *IRState::getDefaultBlock() +{ + IRState *bc; + + for (bc = this; bc; bc = bc->prev) + { + if (bc->defaultBlock) + return bc->defaultBlock; + } + return NULL; +} + +FuncDeclaration *IRState::getFunc() +{ + IRState *bc; + + for (bc = this; bc->prev; bc = bc->prev) + { + } + return (FuncDeclaration *)(bc->symbol); +} + + +/********************** + * Return !=0 if do array bounds checking + */ +int IRState::arrayBoundsCheck() +{ + int result = global.params.useArrayBounds; + + if (result == 1) + { // For safe functions only + result = 0; + FuncDeclaration *fd = getFunc(); + if (fd) + { Type *t = fd->type; + if (t->ty == Tfunction && ((TypeFunction *)t)->trust == TRUSTsafe) + result = 1; + } + } + return result; +} diff --git a/irstate.h b/irstate.h new file mode 100644 index 00000000..75194b6f --- /dev/null +++ b/irstate.h @@ -0,0 +1,59 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#ifndef DMD_CONTEXT_H +#define DMD_CONTEXT_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +struct Module; +struct Statement; +struct block; +struct Dsymbol; +struct Identifier; +struct Symbol; +struct FuncDeclaration; +struct Blockx; +struct elem; +#include "arraytypes.h" + +struct IRState +{ + IRState *prev; + Statement *statement; + Module *m; // module + Dsymbol *symbol; + Identifier *ident; + Symbol *shidden; // hidden parameter to function + Symbol *sthis; // 'this' parameter to function (member and nested) + Symbol *sclosure; // pointer to closure instance + Blockx *blx; + Dsymbols *deferToObj; // array of Dsymbol's to run toObjFile(int multiobj) on later + elem *ehidden; // transmit hidden pointer to CallExp::toElem() + Symbol *startaddress; + VarDeclarations *varsInScope; // variables that are in scope that will need destruction later + + block *breakBlock; + block *contBlock; + block *switchBlock; + block *defaultBlock; + + IRState(IRState *irs, Statement *s); + IRState(IRState *irs, Dsymbol *s); + IRState(Module *m, Dsymbol *s); + + block *getBreakBlock(Identifier *ident); + block *getContBlock(Identifier *ident); + block *getSwitchBlock(); + block *getDefaultBlock(); + FuncDeclaration *getFunc(); + int arrayBoundsCheck(); +}; + +#endif /* DMD_CONTEXT_H */ diff --git a/json.c b/json.c new file mode 100644 index 00000000..d3efacf5 --- /dev/null +++ b/json.c @@ -0,0 +1,462 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// This implements the JSON capability. + +#include +#include +#include +#include +#include + +#include "rmem.h" +#include "root.h" + +#include "mars.h" +#include "dsymbol.h" +#include "macro.h" +#include "template.h" +#include "lexer.h" +#include "aggregate.h" +#include "declaration.h" +#include "enum.h" +#include "id.h" +#include "module.h" +#include "scope.h" +#include "hdrgen.h" +#include "json.h" +#include "mtype.h" +#include "attrib.h" +#include "cond.h" + +const char Pname[] = "name"; +const char Pkind[] = "kind"; +const char Pfile[] = "file"; +const char Pline[] = "line"; +const char Ptype[] = "type"; +const char Pcomment[] = "comment"; +const char Pmembers[] = "members"; +const char Pprotection[] = "protection"; +const char* Pprotectionnames[] = {NULL, "none", "private", "package", "protected", "public", "export"}; + +void JsonRemoveComma(OutBuffer *buf); + +void json_generate(Modules *modules) +{ OutBuffer buf; + + buf.writestring("[\n"); + for (size_t i = 0; i < modules->dim; i++) + { Module *m = modules->tdata()[i]; + if (global.params.verbose) + printf("json gen %s\n", m->toChars()); + m->toJsonBuffer(&buf); + buf.writestring(",\n"); + } + JsonRemoveComma(&buf); + buf.writestring("]\n"); + + // Write buf to file + char *arg = global.params.xfilename; + if (!arg || !*arg) + { // Generate lib file name from first obj name + char *n = global.params.objfiles->tdata()[0]; + + n = FileName::name(n); + FileName *fn = FileName::forceExt(n, global.json_ext); + arg = fn->toChars(); + } + else if (arg[0] == '-' && arg[1] == 0) + { // Write to stdout; assume it succeeds + int n = fwrite(buf.data, 1, buf.offset, stdout); + assert(n == buf.offset); // keep gcc happy about return values + return; + } +// if (!FileName::absolute(arg)) +// arg = FileName::combine(dir, arg); + FileName *jsonfilename = FileName::defaultExt(arg, global.json_ext); + File *jsonfile = new File(jsonfilename); + assert(jsonfile); + jsonfile->setbuffer(buf.data, buf.offset); + jsonfile->ref = 1; + char *pt = FileName::path(jsonfile->toChars()); + if (*pt) + FileName::ensurePathExists(pt); + mem.free(pt); + jsonfile->writev(); +} + + +/********************************* + * Encode string into buf, and wrap it in double quotes. + */ +void JsonString(OutBuffer *buf, const char *s) +{ + buf->writeByte('\"'); + for (; *s; s++) + { + unsigned char c = (unsigned char) *s; + switch (c) + { + case '\n': + buf->writestring("\\n"); + break; + + case '\r': + buf->writestring("\\r"); + break; + + case '\t': + buf->writestring("\\t"); + break; + + case '\"': + buf->writestring("\\\""); + break; + + case '\\': + buf->writestring("\\\\"); + break; + + case '/': + buf->writestring("\\/"); + break; + + case '\b': + buf->writestring("\\b"); + break; + + case '\f': + buf->writestring("\\f"); + break; + + default: + if (c < 0x20) + buf->printf("\\u%04x", c); + else + // Note that UTF-8 chars pass through here just fine + buf->writeByte(c); + break; + } + } + buf->writeByte('\"'); +} + +void JsonProperty(OutBuffer *buf, const char *name, const char *value) +{ + JsonString(buf, name); + buf->writestring(" : "); + JsonString(buf, value); + buf->writestring(",\n"); +} + +void JsonProperty(OutBuffer *buf, const char *name, int value) +{ + JsonString(buf, name); + buf->writestring(" : "); + buf->printf("%d", value); + buf->writestring(",\n"); +} + +void JsonRemoveComma(OutBuffer *buf) +{ + if (buf->offset >= 2 && + buf->data[buf->offset - 2] == ',' && + buf->data[buf->offset - 1] == '\n') + buf->offset -= 2; +} + +void Dsymbol::toJsonBuffer(OutBuffer *buf) +{ +} + +void Module::toJsonBuffer(OutBuffer *buf) +{ + buf->writestring("{\n"); + + if (md) + JsonProperty(buf, Pname, md->toChars()); + + JsonProperty(buf, Pkind, kind()); + + JsonProperty(buf, Pfile, srcfile->toChars()); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + JsonString(buf, Pmembers); + buf->writestring(" : [\n"); + + size_t offset = buf->offset; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + s->toJsonBuffer(buf); + } + + JsonRemoveComma(buf); + buf->writestring("]\n"); + + buf->writestring("}\n"); +} + +void AttribDeclaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("AttribDeclaration::toJsonBuffer()\n"); + + Dsymbols *d = include(NULL, NULL); + + if (d) + { + size_t offset = buf->offset; + for (unsigned i = 0; i < d->dim; i++) + { Dsymbol *s = d->tdata()[i]; + //printf("AttribDeclaration::toJsonBuffer %s\n", s->toChars()); + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + s->toJsonBuffer(buf); + } + JsonRemoveComma(buf); + } +} + + +void ConditionalDeclaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("ConditionalDeclaration::toJsonBuffer()\n"); + if (condition->inc) + { + AttribDeclaration::toJsonBuffer(buf); + } +} + + +void InvariantDeclaration::toJsonBuffer(OutBuffer *buf) { } +void DtorDeclaration::toJsonBuffer(OutBuffer *buf) { } +void StaticCtorDeclaration::toJsonBuffer(OutBuffer *buf) { } +void StaticDtorDeclaration::toJsonBuffer(OutBuffer *buf) { } +void ClassInfoDeclaration::toJsonBuffer(OutBuffer *buf) { } +void ModuleInfoDeclaration::toJsonBuffer(OutBuffer *buf) { } +void TypeInfoDeclaration::toJsonBuffer(OutBuffer *buf) { } +void UnitTestDeclaration::toJsonBuffer(OutBuffer *buf) { } +#if DMDV2 +void PostBlitDeclaration::toJsonBuffer(OutBuffer *buf) { } +#endif + +void Declaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("Declaration::toJsonBuffer()\n"); + buf->writestring("{\n"); + + JsonProperty(buf, Pname, toChars()); + JsonProperty(buf, Pkind, kind()); + + if (prot()) + JsonProperty(buf, Pprotection, Pprotectionnames[prot()]); + + if (type) + JsonProperty(buf, Ptype, type->toChars()); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + if (loc.linnum) + JsonProperty(buf, Pline, loc.linnum); + + TypedefDeclaration *td = isTypedefDeclaration(); + if (td) + { + JsonProperty(buf, "base", td->basetype->toChars()); + } + + JsonRemoveComma(buf); + buf->writestring("}\n"); +} + +void AggregateDeclaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("AggregateDeclaration::toJsonBuffer()\n"); + buf->writestring("{\n"); + + JsonProperty(buf, Pname, toChars()); + JsonProperty(buf, Pkind, kind()); + + if (prot()) + JsonProperty(buf, Pprotection, Pprotectionnames[prot()]); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + if (loc.linnum) + JsonProperty(buf, Pline, loc.linnum); + + ClassDeclaration *cd = isClassDeclaration(); + if (cd) + { + if (cd->baseClass) + { + JsonProperty(buf, "base", cd->baseClass->toChars()); + } + if (cd->interfaces_dim) + { + JsonString(buf, "interfaces"); + buf->writestring(" : [\n"); + size_t offset = buf->offset; + for (size_t i = 0; i < cd->interfaces_dim; i++) + { BaseClass *b = cd->interfaces[i]; + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + JsonString(buf, b->base->toChars()); + } + JsonRemoveComma(buf); + buf->writestring("],\n"); + } + } + + if (members) + { + JsonString(buf, Pmembers); + buf->writestring(" : [\n"); + size_t offset = buf->offset; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + s->toJsonBuffer(buf); + } + JsonRemoveComma(buf); + buf->writestring("]\n"); + } + JsonRemoveComma(buf); + + buf->writestring("}\n"); +} + +void TemplateDeclaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("TemplateDeclaration::toJsonBuffer()\n"); + + buf->writestring("{\n"); + + JsonProperty(buf, Pname, toChars()); + JsonProperty(buf, Pkind, kind()); + + if (prot()) + JsonProperty(buf, Pprotection, Pprotectionnames[prot()]); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + if (loc.linnum) + JsonProperty(buf, Pline, loc.linnum); + + JsonString(buf, Pmembers); + buf->writestring(" : [\n"); + size_t offset = buf->offset; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + s->toJsonBuffer(buf); + } + JsonRemoveComma(buf); + buf->writestring("]\n"); + + buf->writestring("}\n"); +} + +void EnumDeclaration::toJsonBuffer(OutBuffer *buf) +{ + //printf("EnumDeclaration::toJsonBuffer()\n"); + if (isAnonymous()) + { + if (members) + { + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->toJsonBuffer(buf); + buf->writestring(",\n"); + } + JsonRemoveComma(buf); + } + return; + } + + buf->writestring("{\n"); + + JsonProperty(buf, Pname, toChars()); + JsonProperty(buf, Pkind, kind()); + + if (prot()) + JsonProperty(buf, Pprotection, Pprotectionnames[prot()]); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + if (loc.linnum) + JsonProperty(buf, Pline, loc.linnum); + + if (memtype) + JsonProperty(buf, "base", memtype->toChars()); + + if (members) + { + JsonString(buf, Pmembers); + buf->writestring(" : [\n"); + size_t offset = buf->offset; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + if (offset != buf->offset) + { buf->writestring(",\n"); + offset = buf->offset; + } + s->toJsonBuffer(buf); + } + JsonRemoveComma(buf); + buf->writestring("]\n"); + } + JsonRemoveComma(buf); + + buf->writestring("}\n"); +} + +void EnumMember::toJsonBuffer(OutBuffer *buf) +{ + //printf("EnumMember::toJsonBuffer()\n"); + buf->writestring("{\n"); + + JsonProperty(buf, Pname, toChars()); + JsonProperty(buf, Pkind, kind()); + + if (prot()) + JsonProperty(buf, Pprotection, Pprotectionnames[prot()]); + + if (comment) + JsonProperty(buf, Pcomment, (const char *)comment); + + if (loc.linnum) + JsonProperty(buf, Pline, loc.linnum); + + JsonRemoveComma(buf); + buf->writestring("}\n"); +} + + diff --git a/json.h b/json.h new file mode 100644 index 00000000..2c7e2e60 --- /dev/null +++ b/json.h @@ -0,0 +1,24 @@ + + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2008 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_JSON_H +#define DMD_JSON_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "arraytypes.h" + +void json_generate(Modules *); + +#endif /* DMD_JSON_H */ + diff --git a/lexer.c b/lexer.c new file mode 100644 index 00000000..8070f820 --- /dev/null +++ b/lexer.c @@ -0,0 +1,3211 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* Lexical Analyzer */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include // for time() and ctime() + +#include "rmem.h" + +#include "stringtable.h" + +#include "lexer.h" +#include "utf.h" +#include "identifier.h" +#include "id.h" +#include "module.h" + +#if _WIN32 && __DMC__ +// from \dm\src\include\setlocal.h +extern "C" char * __cdecl __locale_decpoint; +#endif + +extern int HtmlNamedEntity(unsigned char *p, int length); + +#define LS 0x2028 // UTF line separator +#define PS 0x2029 // UTF paragraph separator + +void unittest_lexer(); + +/******************************************** + * Do our own char maps + */ + +static unsigned char cmtable[256]; + +const int CMoctal = 0x1; +const int CMhex = 0x2; +const int CMidchar = 0x4; + +inline unsigned char isoctal (unsigned char c) { return cmtable[c] & CMoctal; } +inline unsigned char ishex (unsigned char c) { return cmtable[c] & CMhex; } +inline unsigned char isidchar(unsigned char c) { return cmtable[c] & CMidchar; } + +static void cmtable_init() +{ + for (unsigned c = 0; c < sizeof(cmtable) / sizeof(cmtable[0]); c++) + { + if ('0' <= c && c <= '7') + cmtable[c] |= CMoctal; + if (isdigit(c) || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) + cmtable[c] |= CMhex; + if (isalnum(c) || c == '_') + cmtable[c] |= CMidchar; + } +} + + +/************************* Token **********************************************/ + +const char *Token::tochars[TOKMAX]; + +void *Token::operator new(size_t size) +{ Token *t; + + if (Lexer::freelist) + { + t = Lexer::freelist; + Lexer::freelist = t->next; + return t; + } + + return ::operator new(size); +} + +#ifdef DEBUG +void Token::print() +{ + fprintf(stdmsg, "%s\n", toChars()); +} +#endif + +const char *Token::toChars() +{ const char *p; + static char buffer[3 + 3 * sizeof(float80value) + 1]; + + p = buffer; + switch (value) + { + case TOKint32v: +#if IN_GCC + sprintf(buffer,"%d",(d_int32)int64value); +#else + sprintf(buffer,"%d",int32value); +#endif + break; + + case TOKuns32v: + case TOKcharv: + case TOKwcharv: + case TOKdcharv: +#if IN_GCC + sprintf(buffer,"%uU",(d_uns32)uns64value); +#else + sprintf(buffer,"%uU",uns32value); +#endif + break; + + case TOKint64v: + sprintf(buffer,"%jdL",(intmax_t)int64value); + break; + + case TOKuns64v: + sprintf(buffer,"%juUL",(uintmax_t)uns64value); + break; + +#if IN_GCC + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + float80value.format(buffer, sizeof(buffer)); + break; + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + float80value.format(buffer, sizeof(buffer)); + // %% buffer + strcat(buffer, "i"); + break; +#else + case TOKfloat32v: + sprintf(buffer,"%Lgf", float80value); + break; + + case TOKfloat64v: + sprintf(buffer,"%Lg", float80value); + break; + + case TOKfloat80v: + sprintf(buffer,"%LgL", float80value); + break; + + case TOKimaginary32v: + sprintf(buffer,"%Lgfi", float80value); + break; + + case TOKimaginary64v: + sprintf(buffer,"%Lgi", float80value); + break; + + case TOKimaginary80v: + sprintf(buffer,"%LgLi", float80value); + break; +#endif + + case TOKstring: +#if CSTRINGS + p = string; +#else + { OutBuffer buf; + + buf.writeByte('"'); + for (size_t i = 0; i < len; ) + { unsigned c; + + utf_decodeChar((unsigned char *)ustring, len, &i, &c); + switch (c) + { + case 0: + break; + + case '"': + case '\\': + buf.writeByte('\\'); + default: + if (isprint(c)) + buf.writeByte(c); + else if (c <= 0x7F) + buf.printf("\\x%02x", c); + else if (c <= 0xFFFF) + buf.printf("\\u%04x", c); + else + buf.printf("\\U%08x", c); + continue; + } + break; + } + buf.writeByte('"'); + if (postfix) + buf.writeByte('"'); + buf.writeByte(0); + p = (char *)buf.extractData(); + } +#endif + break; + + case TOKidentifier: + case TOKenum: + case TOKstruct: + case TOKimport: + case BASIC_TYPES: + p = ident->toChars(); + break; + + default: + p = toChars(value); + break; + } + return p; +} + +const char *Token::toChars(enum TOK value) +{ const char *p; + static char buffer[3 + 3 * sizeof(value) + 1]; + + p = tochars[value]; + if (!p) + { sprintf(buffer,"TOK%d",value); + p = buffer; + } + return p; +} + +/*************************** Lexer ********************************************/ + +Token *Lexer::freelist = NULL; +StringTable Lexer::stringtable; +OutBuffer Lexer::stringbuffer; + +Lexer::Lexer(Module *mod, + unsigned char *base, unsigned begoffset, unsigned endoffset, + int doDocComment, int commentToken) + : loc(mod, 1) +{ + //printf("Lexer::Lexer(%p,%d)\n",base,length); + //printf("lexer.mod = %p, %p\n", mod, this->loc.mod); + memset(&token,0,sizeof(token)); + this->base = base; + this->end = base + endoffset; + p = base + begoffset; + this->mod = mod; + this->doDocComment = doDocComment; + this->anyToken = 0; + this->commentToken = commentToken; + //initKeywords(); + + /* If first line starts with '#!', ignore the line + */ + + if (p[0] == '#' && p[1] =='!') + { + p += 2; + while (1) + { unsigned char c = *p; + switch (c) + { + case '\n': + p++; + break; + + case '\r': + p++; + if (*p == '\n') + p++; + break; + + case 0: + case 0x1A: + break; + + default: + if (c & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + break; + } + p++; + continue; + } + break; + } + loc.linnum = 2; + } +} + + +void Lexer::error(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end(ap); +} + +void Lexer::error(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end(ap); +} + +void Lexer::verror(Loc loc, const char *format, va_list ap) +{ + if (mod && !global.gag) + { + char *p = loc.toChars(); + if (*p) + fprintf(stdmsg, "%s: ", p); + mem.free(p); + + vfprintf(stdmsg, format, ap); + + fprintf(stdmsg, "\n"); + fflush(stdmsg); + + if (global.errors >= 20) // moderate blizzard of cascading messages + fatal(); + } + else + { + global.gaggedErrors++; + } + global.errors++; +} + +TOK Lexer::nextToken() +{ Token *t; + + if (token.next) + { + t = token.next; + memcpy(&token,t,sizeof(Token)); + t->next = freelist; + freelist = t; + } + else + { + scan(&token); + } + //token.print(); + return token.value; +} + +Token *Lexer::peek(Token *ct) +{ Token *t; + + if (ct->next) + t = ct->next; + else + { + t = new Token(); + scan(t); + t->next = NULL; + ct->next = t; + } + return t; +} + +/*********************** + * Look ahead at next token's value. + */ + +TOK Lexer::peekNext() +{ + return peek(&token)->value; +} + +/*********************** + * Look 2 tokens ahead at value. + */ + +TOK Lexer::peekNext2() +{ + Token *t = peek(&token); + return peek(t)->value; +} + +/********************************* + * tk is on the opening (. + * Look ahead and return token that is past the closing ). + */ + +Token *Lexer::peekPastParen(Token *tk) +{ + //printf("peekPastParen()\n"); + int parens = 1; + int curlynest = 0; + while (1) + { + tk = peek(tk); + //tk->print(); + switch (tk->value) + { + case TOKlparen: + parens++; + continue; + + case TOKrparen: + --parens; + if (parens) + continue; + tk = peek(tk); + break; + + case TOKlcurly: + curlynest++; + continue; + + case TOKrcurly: + if (--curlynest >= 0) + continue; + break; + + case TOKsemicolon: + if (curlynest) + continue; + break; + + case TOKeof: + break; + + default: + continue; + } + return tk; + } +} + +/********************************** + * Determine if string is a valid Identifier. + * Placed here because of commonality with Lexer functionality. + * Returns: + * 0 invalid + */ + +int Lexer::isValidIdentifier(char *p) +{ + size_t len; + size_t idx; + + if (!p || !*p) + goto Linvalid; + + if (*p >= '0' && *p <= '9') // beware of isdigit() on signed chars + goto Linvalid; + + len = strlen(p); + idx = 0; + while (p[idx]) + { dchar_t dc; + + const char *q = utf_decodeChar((unsigned char *)p, len, &idx, &dc); + if (q) + goto Linvalid; + + if (!((dc >= 0x80 && isUniAlpha(dc)) || isalnum(dc) || dc == '_')) + goto Linvalid; + } + return 1; + +Linvalid: + return 0; +} + +/**************************** + * Turn next token in buffer into a token. + */ + +void Lexer::scan(Token *t) +{ + unsigned lastLine = loc.linnum; + unsigned linnum; + + t->blockComment = NULL; + t->lineComment = NULL; + while (1) + { + t->ptr = p; + //printf("p = %p, *p = '%c'\n",p,*p); + switch (*p) + { + case 0: + case 0x1A: + t->value = TOKeof; // end of file + return; + + case ' ': + case '\t': + case '\v': + case '\f': + p++; + continue; // skip white space + + case '\r': + p++; + if (*p != '\n') // if CR stands by itself + loc.linnum++; + continue; // skip white space + + case '\n': + p++; + loc.linnum++; + continue; // skip white space + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + t->value = number(t); + return; + +#if CSTRINGS + case '\'': + t->value = charConstant(t, 0); + return; + + case '"': + t->value = stringConstant(t,0); + return; + + case 'l': + case 'L': + if (p[1] == '\'') + { + p++; + t->value = charConstant(t, 1); + return; + } + else if (p[1] == '"') + { + p++; + t->value = stringConstant(t, 1); + return; + } +#else + case '\'': + t->value = charConstant(t,0); + return; + + case 'r': + if (p[1] != '"') + goto case_ident; + p++; + case '`': + t->value = wysiwygStringConstant(t, *p); + return; + + case 'x': + if (p[1] != '"') + goto case_ident; + p++; + t->value = hexStringConstant(t); + return; + +#if DMDV2 + case 'q': + if (p[1] == '"') + { + p++; + t->value = delimitedStringConstant(t); + return; + } + else if (p[1] == '{') + { + p++; + t->value = tokenStringConstant(t); + return; + } + else + goto case_ident; +#endif + + case '"': + t->value = escapeStringConstant(t,0); + return; + +#if ! TEXTUAL_ASSEMBLY_OUT + case '\\': // escaped string literal + { unsigned c; + unsigned char *pstart = p; + + stringbuffer.reset(); + do + { + p++; + switch (*p) + { + case 'u': + case 'U': + case '&': + c = escapeSequence(); + stringbuffer.writeUTF8(c); + break; + + default: + c = escapeSequence(); + stringbuffer.writeByte(c); + break; + } + } while (*p == '\\'); + t->len = stringbuffer.offset; + stringbuffer.writeByte(0); + t->ustring = (unsigned char *)mem.malloc(stringbuffer.offset); + memcpy(t->ustring, stringbuffer.data, stringbuffer.offset); + t->postfix = 0; + t->value = TOKstring; +#if DMDV2 + if (!global.params.useDeprecated) + error("Escape String literal %.*s is deprecated, use double quoted string literal \"%.*s\" instead", p - pstart, pstart, p - pstart, pstart); +#endif + return; + } +#endif + + case 'l': + case 'L': +#endif + case 'a': case 'b': case 'c': case 'd': case 'e': + case 'f': case 'g': case 'h': case 'i': case 'j': + case 'k': case 'm': case 'n': case 'o': +#if DMDV2 + case 'p': /*case 'q': case 'r':*/ case 's': case 't': +#else + case 'p': case 'q': /*case 'r':*/ case 's': case 't': +#endif + case 'u': case 'v': case 'w': /*case 'x':*/ case 'y': + case 'z': + case 'A': case 'B': case 'C': case 'D': case 'E': + case 'F': case 'G': case 'H': case 'I': case 'J': + case 'K': case 'M': case 'N': case 'O': + case 'P': case 'Q': case 'R': case 'S': case 'T': + case 'U': case 'V': case 'W': case 'X': case 'Y': + case 'Z': + case '_': + case_ident: + { unsigned char c; + + while (1) + { + c = *++p; + if (isidchar(c)) + continue; + else if (c & 0x80) + { unsigned char *s = p; + unsigned u = decodeUTF(); + if (isUniAlpha(u)) + continue; + error("char 0x%04x not allowed in identifier", u); + p = s; + } + break; + } + + StringValue *sv = stringtable.update((char *)t->ptr, p - t->ptr); + Identifier *id = (Identifier *) sv->ptrvalue; + if (!id) + { id = new Identifier(sv->lstring.string,TOKidentifier); + sv->ptrvalue = id; + } + t->ident = id; + t->value = (enum TOK) id->value; + anyToken = 1; + if (*t->ptr == '_') // if special identifier token + { + static char date[11+1]; + static char time[8+1]; + static char timestamp[24+1]; + + if (!date[0]) // lazy evaluation + { time_t t; + char *p; + + ::time(&t); + p = ctime(&t); + assert(p); + sprintf(date, "%.6s %.4s", p + 4, p + 20); + sprintf(time, "%.8s", p + 11); + sprintf(timestamp, "%.24s", p); + } + +#if DMDV1 + if (mod && id == Id::FILE) + { + t->ustring = (unsigned char *)(loc.filename ? loc.filename : mod->ident->toChars()); + goto Lstr; + } + else if (mod && id == Id::LINE) + { + t->value = TOKint64v; + t->uns64value = loc.linnum; + } + else +#endif + if (id == Id::DATE) + { + t->ustring = (unsigned char *)date; + goto Lstr; + } + else if (id == Id::TIME) + { + t->ustring = (unsigned char *)time; + goto Lstr; + } + else if (id == Id::VENDOR) + { + t->ustring = (unsigned char *)"Digital Mars D"; + goto Lstr; + } + else if (id == Id::TIMESTAMP) + { + t->ustring = (unsigned char *)timestamp; + Lstr: + t->value = TOKstring; + t->postfix = 0; + t->len = strlen((char *)t->ustring); + } + else if (id == Id::VERSIONX) + { unsigned major = 0; + unsigned minor = 0; + + for (const char *p = global.version + 1; 1; p++) + { + char c = *p; + if (isdigit((unsigned char)c)) + minor = minor * 10 + c - '0'; + else if (c == '.') + { major = minor; + minor = 0; + } + else + break; + } + t->value = TOKint64v; + t->uns64value = major * 1000 + minor; + } +#if DMDV2 + else if (id == Id::EOFX) + { + t->value = TOKeof; + // Advance scanner to end of file + while (!(*p == 0 || *p == 0x1A)) + p++; + } +#endif + } + //printf("t->value = %d\n",t->value); + return; + } + + case '/': + p++; + switch (*p) + { + case '=': + p++; + t->value = TOKdivass; + return; + + case '*': + p++; + linnum = loc.linnum; + while (1) + { + while (1) + { unsigned char c = *p; + switch (c) + { + case '/': + break; + + case '\n': + loc.linnum++; + p++; + continue; + + case '\r': + p++; + if (*p != '\n') + loc.linnum++; + continue; + + case 0: + case 0x1A: + error("unterminated /* */ comment"); + p = end; + t->value = TOKeof; + return; + + default: + if (c & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + loc.linnum++; + } + p++; + continue; + } + break; + } + p++; + if (p[-2] == '*' && p - 3 != t->ptr) + break; + } + if (commentToken) + { + t->value = TOKcomment; + return; + } + else if (doDocComment && t->ptr[2] == '*' && p - 4 != t->ptr) + { // if /** but not /**/ + getDocComment(t, lastLine == linnum); + } + continue; + + case '/': // do // style comments + linnum = loc.linnum; + while (1) + { unsigned char c = *++p; + switch (c) + { + case '\n': + break; + + case '\r': + if (p[1] == '\n') + p++; + break; + + case 0: + case 0x1A: + if (commentToken) + { + p = end; + t->value = TOKcomment; + return; + } + if (doDocComment && t->ptr[2] == '/') + getDocComment(t, lastLine == linnum); + p = end; + t->value = TOKeof; + return; + + default: + if (c & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + break; + } + continue; + } + break; + } + + if (commentToken) + { + p++; + loc.linnum++; + t->value = TOKcomment; + return; + } + if (doDocComment && t->ptr[2] == '/') + getDocComment(t, lastLine == linnum); + + p++; + loc.linnum++; + continue; + + case '+': + { int nest; + + linnum = loc.linnum; + p++; + nest = 1; + while (1) + { unsigned char c = *p; + switch (c) + { + case '/': + p++; + if (*p == '+') + { + p++; + nest++; + } + continue; + + case '+': + p++; + if (*p == '/') + { + p++; + if (--nest == 0) + break; + } + continue; + + case '\r': + p++; + if (*p != '\n') + loc.linnum++; + continue; + + case '\n': + loc.linnum++; + p++; + continue; + + case 0: + case 0x1A: + error("unterminated /+ +/ comment"); + p = end; + t->value = TOKeof; + return; + + default: + if (c & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + loc.linnum++; + } + p++; + continue; + } + break; + } + if (commentToken) + { + t->value = TOKcomment; + return; + } + if (doDocComment && t->ptr[2] == '+' && p - 4 != t->ptr) + { // if /++ but not /++/ + getDocComment(t, lastLine == linnum); + } + continue; + } + } + t->value = TOKdiv; + return; + + case '.': + p++; + if (isdigit(*p)) + { /* Note that we don't allow ._1 and ._ as being + * valid floating point numbers. + */ + p--; + t->value = inreal(t); + } + else if (p[0] == '.') + { + if (p[1] == '.') + { p += 2; + t->value = TOKdotdotdot; + } + else + { p++; + t->value = TOKslice; + } + } + else + t->value = TOKdot; + return; + + case '&': + p++; + if (*p == '=') + { p++; + t->value = TOKandass; + } + else if (*p == '&') + { p++; + t->value = TOKandand; + } + else + t->value = TOKand; + return; + + case '|': + p++; + if (*p == '=') + { p++; + t->value = TOKorass; + } + else if (*p == '|') + { p++; + t->value = TOKoror; + } + else + t->value = TOKor; + return; + + case '-': + p++; + if (*p == '=') + { p++; + t->value = TOKminass; + } +#if 0 + else if (*p == '>') + { p++; + t->value = TOKarrow; + } +#endif + else if (*p == '-') + { p++; + t->value = TOKminusminus; + } + else + t->value = TOKmin; + return; + + case '+': + p++; + if (*p == '=') + { p++; + t->value = TOKaddass; + } + else if (*p == '+') + { p++; + t->value = TOKplusplus; + } + else + t->value = TOKadd; + return; + + case '<': + p++; + if (*p == '=') + { p++; + t->value = TOKle; // <= + } + else if (*p == '<') + { p++; + if (*p == '=') + { p++; + t->value = TOKshlass; // <<= + } + else + t->value = TOKshl; // << + } + else if (*p == '>') + { p++; + if (*p == '=') + { p++; + t->value = TOKleg; // <>= + } + else + t->value = TOKlg; // <> + } + else + t->value = TOKlt; // < + return; + + case '>': + p++; + if (*p == '=') + { p++; + t->value = TOKge; // >= + } + else if (*p == '>') + { p++; + if (*p == '=') + { p++; + t->value = TOKshrass; // >>= + } + else if (*p == '>') + { p++; + if (*p == '=') + { p++; + t->value = TOKushrass; // >>>= + } + else + t->value = TOKushr; // >>> + } + else + t->value = TOKshr; // >> + } + else + t->value = TOKgt; // > + return; + + case '!': + p++; + if (*p == '=') + { p++; + if (*p == '=' && global.params.Dversion == 1) + { p++; + t->value = TOKnotidentity; // !== + } + else + t->value = TOKnotequal; // != + } + else if (*p == '<') + { p++; + if (*p == '>') + { p++; + if (*p == '=') + { p++; + t->value = TOKunord; // !<>= + } + else + t->value = TOKue; // !<> + } + else if (*p == '=') + { p++; + t->value = TOKug; // !<= + } + else + t->value = TOKuge; // !< + } + else if (*p == '>') + { p++; + if (*p == '=') + { p++; + t->value = TOKul; // !>= + } + else + t->value = TOKule; // !> + } + else + t->value = TOKnot; // ! + return; + + case '=': + p++; + if (*p == '=') + { p++; + if (*p == '=' && global.params.Dversion == 1) + { p++; + t->value = TOKidentity; // === + } + else + t->value = TOKequal; // == + } +#if DMDV2 + else if (*p == '>') + { p++; + t->value = TOKgoesto; // => + } +#endif + else + t->value = TOKassign; // = + return; + + case '~': + p++; + if (*p == '=') + { p++; + t->value = TOKcatass; // ~= + } + else + t->value = TOKtilde; // ~ + return; + +#if DMDV2 + case '^': + p++; + if (*p == '^') + { p++; + if (*p == '=') + { p++; + t->value = TOKpowass; // ^^= + } + else + t->value = TOKpow; // ^^ + } + else if (*p == '=') + { p++; + t->value = TOKxorass; // ^= + } + else + t->value = TOKxor; // ^ + return; +#endif + +#define SINGLE(c,tok) case c: p++; t->value = tok; return; + + SINGLE('(', TOKlparen) + SINGLE(')', TOKrparen) + SINGLE('[', TOKlbracket) + SINGLE(']', TOKrbracket) + SINGLE('{', TOKlcurly) + SINGLE('}', TOKrcurly) + SINGLE('?', TOKquestion) + SINGLE(',', TOKcomma) + SINGLE(';', TOKsemicolon) + SINGLE(':', TOKcolon) + SINGLE('$', TOKdollar) +#if DMDV2 + SINGLE('@', TOKat) +#endif +#undef SINGLE + +#define DOUBLE(c1,tok1,c2,tok2) \ + case c1: \ + p++; \ + if (*p == c2) \ + { p++; \ + t->value = tok2; \ + } \ + else \ + t->value = tok1; \ + return; + + DOUBLE('*', TOKmul, '=', TOKmulass) + DOUBLE('%', TOKmod, '=', TOKmodass) +#if DMDV1 + DOUBLE('^', TOKxor, '=', TOKxorass) +#endif +#undef DOUBLE + + case '#': + p++; + pragma(); + continue; + + default: + { unsigned c = *p; + + if (c & 0x80) + { c = decodeUTF(); + + // Check for start of unicode identifier + if (isUniAlpha(c)) + goto case_ident; + + if (c == PS || c == LS) + { + loc.linnum++; + p++; + continue; + } + } + if (c < 0x80 && isprint(c)) + error("unsupported char '%c'", c); + else + error("unsupported char 0x%02x", c); + p++; + continue; + } + } + } +} + +/******************************************* + * Parse escape sequence. + */ + +unsigned Lexer::escapeSequence() +{ unsigned c = *p; + +#ifdef TEXTUAL_ASSEMBLY_OUT + return c; +#endif + int n; + int ndigits; + + switch (c) + { + case '\'': + case '"': + case '?': + case '\\': + Lconsume: + p++; + break; + + case 'a': c = 7; goto Lconsume; + case 'b': c = 8; goto Lconsume; + case 'f': c = 12; goto Lconsume; + case 'n': c = 10; goto Lconsume; + case 'r': c = 13; goto Lconsume; + case 't': c = 9; goto Lconsume; + case 'v': c = 11; goto Lconsume; + + case 'u': + ndigits = 4; + goto Lhex; + case 'U': + ndigits = 8; + goto Lhex; + case 'x': + ndigits = 2; + Lhex: + p++; + c = *p; + if (ishex(c)) + { unsigned v; + + n = 0; + v = 0; + while (1) + { + if (isdigit(c)) + c -= '0'; + else if (islower(c)) + c -= 'a' - 10; + else + c -= 'A' - 10; + v = v * 16 + c; + c = *++p; + if (++n == ndigits) + break; + if (!ishex(c)) + { error("escape hex sequence has %d hex digits instead of %d", n, ndigits); + break; + } + } + if (ndigits != 2 && !utf_isValidDchar(v)) + { error("invalid UTF character \\U%08x", v); + v = '?'; // recover with valid UTF character + } + c = v; + } + else + error("undefined escape hex sequence \\%c\n",c); + break; + + case '&': // named character entity + for (unsigned char *idstart = ++p; 1; p++) + { + switch (*p) + { + case ';': + c = HtmlNamedEntity(idstart, p - idstart); + if (c == ~0) + { error("unnamed character entity &%.*s;", (int)(p - idstart), idstart); + c = ' '; + } + p++; + break; + + default: + if (isalpha(*p) || + (p != idstart + 1 && isdigit(*p))) + continue; + error("unterminated named entity"); + break; + } + break; + } + break; + + case 0: + case 0x1A: // end of file + c = '\\'; + break; + + default: + if (isoctal(c)) + { unsigned v; + + n = 0; + v = 0; + do + { + v = v * 8 + (c - '0'); + c = *++p; + } while (++n < 3 && isoctal(c)); + c = v; + if (c > 0xFF) + error("0%03o is larger than a byte", c); + } + else + error("undefined escape sequence \\%c\n",c); + break; + } + return c; +} + +/************************************** + */ + +TOK Lexer::wysiwygStringConstant(Token *t, int tc) +{ unsigned c; + Loc start = loc; + + p++; + stringbuffer.reset(); + while (1) + { + c = *p++; + switch (c) + { + case '\n': + loc.linnum++; + break; + + case '\r': + if (*p == '\n') + continue; // ignore + c = '\n'; // treat EndOfLine as \n character + loc.linnum++; + break; + + case 0: + case 0x1A: + error("unterminated string constant starting at %s", start.toChars()); + t->ustring = (unsigned char *)""; + t->len = 0; + t->postfix = 0; + return TOKstring; + + case '"': + case '`': + if (c == tc) + { + t->len = stringbuffer.offset; + stringbuffer.writeByte(0); + t->ustring = (unsigned char *)mem.malloc(stringbuffer.offset); + memcpy(t->ustring, stringbuffer.data, stringbuffer.offset); + stringPostfix(t); + return TOKstring; + } + break; + + default: + if (c & 0x80) + { p--; + unsigned u = decodeUTF(); + p++; + if (u == PS || u == LS) + loc.linnum++; + stringbuffer.writeUTF8(u); + continue; + } + break; + } + stringbuffer.writeByte(c); + } +} + +/************************************** + * Lex hex strings: + * x"0A ae 34FE BD" + */ + +TOK Lexer::hexStringConstant(Token *t) +{ unsigned c; + Loc start = loc; + unsigned n = 0; + unsigned v; + + p++; + stringbuffer.reset(); + while (1) + { + c = *p++; + switch (c) + { + case ' ': + case '\t': + case '\v': + case '\f': + continue; // skip white space + + case '\r': + if (*p == '\n') + continue; // ignore + // Treat isolated '\r' as if it were a '\n' + case '\n': + loc.linnum++; + continue; + + case 0: + case 0x1A: + error("unterminated string constant starting at %s", start.toChars()); + t->ustring = (unsigned char *)""; + t->len = 0; + t->postfix = 0; + return TOKstring; + + case '"': + if (n & 1) + { error("odd number (%d) of hex characters in hex string", n); + stringbuffer.writeByte(v); + } + t->len = stringbuffer.offset; + stringbuffer.writeByte(0); + t->ustring = (unsigned char *)mem.malloc(stringbuffer.offset); + memcpy(t->ustring, stringbuffer.data, stringbuffer.offset); + stringPostfix(t); + return TOKstring; + + default: + if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'a' && c <= 'f') + c -= 'a' - 10; + else if (c >= 'A' && c <= 'F') + c -= 'A' - 10; + else if (c & 0x80) + { p--; + unsigned u = decodeUTF(); + p++; + if (u == PS || u == LS) + loc.linnum++; + else + error("non-hex character \\u%04x", u); + } + else + error("non-hex character '%c'", c); + if (n & 1) + { v = (v << 4) | c; + stringbuffer.writeByte(v); + } + else + v = c; + n++; + break; + } + } +} + + +#if DMDV2 +/************************************** + * Lex delimited strings: + * q"(foo(xxx))" // "foo(xxx)" + * q"[foo(]" // "foo(" + * q"/foo]/" // "foo]" + * q"HERE + * foo + * HERE" // "foo\n" + * Input: + * p is on the " + */ + +TOK Lexer::delimitedStringConstant(Token *t) +{ unsigned c; + Loc start = loc; + unsigned delimleft = 0; + unsigned delimright = 0; + unsigned nest = 1; + unsigned nestcount; + Identifier *hereid = NULL; + unsigned blankrol = 0; + unsigned startline = 0; + + p++; + stringbuffer.reset(); + while (1) + { + c = *p++; + //printf("c = '%c'\n", c); + switch (c) + { + case '\n': + Lnextline: + loc.linnum++; + startline = 1; + if (blankrol) + { blankrol = 0; + continue; + } + if (hereid) + { + stringbuffer.writeUTF8(c); + continue; + } + break; + + case '\r': + if (*p == '\n') + continue; // ignore + c = '\n'; // treat EndOfLine as \n character + goto Lnextline; + + case 0: + case 0x1A: + goto Lerror; + + default: + if (c & 0x80) + { p--; + c = decodeUTF(); + p++; + if (c == PS || c == LS) + goto Lnextline; + } + break; + } + if (delimleft == 0) + { delimleft = c; + nest = 1; + nestcount = 1; + if (c == '(') + delimright = ')'; + else if (c == '{') + delimright = '}'; + else if (c == '[') + delimright = ']'; + else if (c == '<') + delimright = '>'; + else if (isalpha(c) || c == '_' || (c >= 0x80 && isUniAlpha(c))) + { // Start of identifier; must be a heredoc + Token t; + p--; + scan(&t); // read in heredoc identifier + if (t.value != TOKidentifier) + { error("identifier expected for heredoc, not %s", t.toChars()); + delimright = c; + } + else + { hereid = t.ident; + //printf("hereid = '%s'\n", hereid->toChars()); + blankrol = 1; + } + nest = 0; + } + else + { delimright = c; + nest = 0; +#if DMDV2 + if (isspace(c)) + error("delimiter cannot be whitespace"); +#endif + } + } + else + { + if (blankrol) + { error("heredoc rest of line should be blank"); + blankrol = 0; + continue; + } + if (nest == 1) + { + if (c == delimleft) + nestcount++; + else if (c == delimright) + { nestcount--; + if (nestcount == 0) + goto Ldone; + } + } + else if (c == delimright) + goto Ldone; + if (startline && isalpha(c) +#if DMDV2 + && hereid +#endif + ) + { Token t; + unsigned char *psave = p; + p--; + scan(&t); // read in possible heredoc identifier + //printf("endid = '%s'\n", t.ident->toChars()); + if (t.value == TOKidentifier && t.ident->equals(hereid)) + { /* should check that rest of line is blank + */ + goto Ldone; + } + p = psave; + } + stringbuffer.writeUTF8(c); + startline = 0; + } + } + +Ldone: + if (*p == '"') + p++; + else + error("delimited string must end in %c\"", delimright); + t->len = stringbuffer.offset; + stringbuffer.writeByte(0); + t->ustring = (unsigned char *)mem.malloc(stringbuffer.offset); + memcpy(t->ustring, stringbuffer.data, stringbuffer.offset); + stringPostfix(t); + return TOKstring; + +Lerror: + error("unterminated string constant starting at %s", start.toChars()); + t->ustring = (unsigned char *)""; + t->len = 0; + t->postfix = 0; + return TOKstring; +} + +/************************************** + * Lex delimited strings: + * q{ foo(xxx) } // " foo(xxx) " + * q{foo(} // "foo(" + * q{{foo}"}"} // "{foo}"}"" + * Input: + * p is on the q + */ + +TOK Lexer::tokenStringConstant(Token *t) +{ + unsigned nest = 1; + Loc start = loc; + unsigned char *pstart = ++p; + + while (1) + { Token tok; + + scan(&tok); + switch (tok.value) + { + case TOKlcurly: + nest++; + continue; + + case TOKrcurly: + if (--nest == 0) + goto Ldone; + continue; + + case TOKeof: + goto Lerror; + + default: + continue; + } + } + +Ldone: + t->len = p - 1 - pstart; + t->ustring = (unsigned char *)mem.malloc(t->len + 1); + memcpy(t->ustring, pstart, t->len); + t->ustring[t->len] = 0; + stringPostfix(t); + return TOKstring; + +Lerror: + error("unterminated token string constant starting at %s", start.toChars()); + t->ustring = (unsigned char *)""; + t->len = 0; + t->postfix = 0; + return TOKstring; +} + +#endif + + +/************************************** + */ + +TOK Lexer::escapeStringConstant(Token *t, int wide) +{ unsigned c; + Loc start = loc; + + p++; + stringbuffer.reset(); + while (1) + { + c = *p++; + switch (c) + { +#if !( TEXTUAL_ASSEMBLY_OUT ) + case '\\': + switch (*p) + { + case 'u': + case 'U': + case '&': + c = escapeSequence(); + stringbuffer.writeUTF8(c); + continue; + + default: + c = escapeSequence(); + break; + } + break; +#endif + case '\n': + loc.linnum++; + break; + + case '\r': + if (*p == '\n') + continue; // ignore + c = '\n'; // treat EndOfLine as \n character + loc.linnum++; + break; + + case '"': + t->len = stringbuffer.offset; + stringbuffer.writeByte(0); + t->ustring = (unsigned char *)mem.malloc(stringbuffer.offset); + memcpy(t->ustring, stringbuffer.data, stringbuffer.offset); + stringPostfix(t); + return TOKstring; + + case 0: + case 0x1A: + p--; + error("unterminated string constant starting at %s", start.toChars()); + t->ustring = (unsigned char *)""; + t->len = 0; + t->postfix = 0; + return TOKstring; + + default: + if (c & 0x80) + { + p--; + c = decodeUTF(); + if (c == LS || c == PS) + { c = '\n'; + loc.linnum++; + } + p++; + stringbuffer.writeUTF8(c); + continue; + } + break; + } + stringbuffer.writeByte(c); + } +} + +/************************************** + */ + +TOK Lexer::charConstant(Token *t, int wide) +{ + unsigned c; + TOK tk = TOKcharv; + + //printf("Lexer::charConstant\n"); + p++; + c = *p++; + switch (c) + { +#if ! TEXTUAL_ASSEMBLY_OUT + case '\\': + switch (*p) + { + case 'u': + t->uns64value = escapeSequence(); + tk = TOKwcharv; + break; + + case 'U': + case '&': + t->uns64value = escapeSequence(); + tk = TOKdcharv; + break; + + default: + t->uns64value = escapeSequence(); + break; + } + break; +#endif + case '\n': + L1: + loc.linnum++; + case '\r': + case 0: + case 0x1A: + case '\'': + error("unterminated character constant"); + return tk; + + default: + if (c & 0x80) + { + p--; + c = decodeUTF(); + p++; + if (c == LS || c == PS) + goto L1; + if (c < 0xD800 || (c >= 0xE000 && c < 0xFFFE)) + tk = TOKwcharv; + else + tk = TOKdcharv; + } + t->uns64value = c; + break; + } + + if (*p != '\'') + { error("unterminated character constant"); + return tk; + } + p++; + return tk; +} + +/*************************************** + * Get postfix of string literal. + */ + +void Lexer::stringPostfix(Token *t) +{ + switch (*p) + { + case 'c': + case 'w': + case 'd': + t->postfix = *p; + p++; + break; + + default: + t->postfix = 0; + break; + } +} + +/*************************************** + * Read \u or \U unicode sequence + * Input: + * u 'u' or 'U' + */ + +#if 0 +unsigned Lexer::wchar(unsigned u) +{ + unsigned value; + unsigned n; + unsigned char c; + unsigned nchars; + + nchars = (u == 'U') ? 8 : 4; + value = 0; + for (n = 0; 1; n++) + { + ++p; + if (n == nchars) + break; + c = *p; + if (!ishex(c)) + { error("\\%c sequence must be followed by %d hex characters", u, nchars); + break; + } + if (isdigit(c)) + c -= '0'; + else if (islower(c)) + c -= 'a' - 10; + else + c -= 'A' - 10; + value <<= 4; + value |= c; + } + return value; +} +#endif + +/************************************** + * Read in a number. + * If it's an integer, store it in tok.TKutok.Vlong. + * integers can be decimal, octal or hex + * Handle the suffixes U, UL, LU, L, etc. + * If it's double, store it in tok.TKutok.Vdouble. + * Returns: + * TKnum + * TKdouble,... + */ + +TOK Lexer::number(Token *t) +{ + // We use a state machine to collect numbers + enum STATE { STATE_initial, STATE_0, STATE_decimal, STATE_octal, STATE_octale, + STATE_hex, STATE_binary, STATE_hex0, STATE_binary0, + STATE_hexh, STATE_error }; + enum STATE state; + + enum FLAGS + { FLAGS_decimal = 1, // decimal + FLAGS_unsigned = 2, // u or U suffix + FLAGS_long = 4, // l or L suffix + }; + enum FLAGS flags = FLAGS_decimal; + + int base; + unsigned c; + unsigned char *start; + TOK result; + + //printf("Lexer::number()\n"); + state = STATE_initial; + base = 0; + stringbuffer.reset(); + start = p; + while (1) + { + c = *p; + switch (state) + { + case STATE_initial: // opening state + if (c == '0') + state = STATE_0; + else + state = STATE_decimal; + break; + + case STATE_0: + flags = (FLAGS) (flags & ~FLAGS_decimal); + switch (c) + { +#if ZEROH + case 'H': // 0h + case 'h': + goto hexh; +#endif + case 'X': + case 'x': + state = STATE_hex0; + break; + + case '.': + if (p[1] == '.') // .. is a separate token + goto done; + case 'i': + case 'f': + case 'F': + goto real; +#if ZEROH + case 'E': + case 'e': + goto case_hex; +#endif + case 'B': + case 'b': + state = STATE_binary0; + break; + + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + state = STATE_octal; + break; + +#if ZEROH + case '8': case '9': case 'A': + case 'C': case 'D': case 'F': + case 'a': case 'c': case 'd': case 'f': + case_hex: + state = STATE_hexh; + break; +#endif + case '_': + state = STATE_octal; + p++; + continue; + + case 'L': + if (p[1] == 'i') + goto real; + goto done; + + default: + goto done; + } + break; + + case STATE_decimal: // reading decimal number + if (!isdigit(c)) + { +#if ZEROH + if (ishex(c) + || c == 'H' || c == 'h' + ) + goto hexh; +#endif + if (c == '_') // ignore embedded _ + { p++; + continue; + } + if (c == '.' && p[1] != '.') + { +#if DMDV2 + if (isalpha(p[1]) || p[1] == '_') + goto done; +#endif + goto real; + } + else if (c == 'i' || c == 'f' || c == 'F' || + c == 'e' || c == 'E') + { + real: // It's a real number. Back up and rescan as a real + p = start; + return inreal(t); + } + else if (c == 'L' && p[1] == 'i') + goto real; + goto done; + } + break; + + case STATE_hex0: // reading hex number + case STATE_hex: + if (!ishex(c)) + { + if (c == '_') // ignore embedded _ + { p++; + continue; + } + if (c == '.' && p[1] != '.') + goto real; + if (c == 'P' || c == 'p' || c == 'i') + goto real; + if (state == STATE_hex0) + error("Hex digit expected, not '%c'", c); + goto done; + } + state = STATE_hex; + break; + +#if ZEROH + hexh: + state = STATE_hexh; + case STATE_hexh: // parse numbers like 0FFh + if (!ishex(c)) + { + if (c == 'H' || c == 'h') + { + p++; + base = 16; + goto done; + } + else + { + // Check for something like 1E3 or 0E24 + if (memchr((char *)stringbuffer.data, 'E', stringbuffer.offset) || + memchr((char *)stringbuffer.data, 'e', stringbuffer.offset)) + goto real; + error("Hex digit expected, not '%c'", c); + goto done; + } + } + break; +#endif + + case STATE_octal: // reading octal number + case STATE_octale: // reading octal number with non-octal digits + if (!isoctal(c)) + { +#if ZEROH + if (ishex(c) + || c == 'H' || c == 'h' + ) + goto hexh; +#endif + if (c == '_') // ignore embedded _ + { p++; + continue; + } + if (c == '.' && p[1] != '.') + goto real; + if (c == 'i') + goto real; + if (isdigit(c)) + { + state = STATE_octale; + } + else + goto done; + } + break; + + case STATE_binary0: // starting binary number + case STATE_binary: // reading binary number + if (c != '0' && c != '1') + { +#if ZEROH + if (ishex(c) + || c == 'H' || c == 'h' + ) + goto hexh; +#endif + if (c == '_') // ignore embedded _ + { p++; + continue; + } + if (state == STATE_binary0) + { error("binary digit expected"); + state = STATE_error; + break; + } + else + goto done; + } + state = STATE_binary; + break; + + case STATE_error: // for error recovery + if (!isdigit(c)) // scan until non-digit + goto done; + break; + + default: + assert(0); + } + stringbuffer.writeByte(c); + p++; + } +done: + stringbuffer.writeByte(0); // terminate string + if (state == STATE_octale) + error("Octal digit expected"); + + uinteger_t n; // unsigned >=64 bit integer type + + if (stringbuffer.offset == 2 && (state == STATE_decimal || state == STATE_0)) + n = stringbuffer.data[0] - '0'; + else + { + // Convert string to integer +#if __DMC__ + errno = 0; + n = strtoull((char *)stringbuffer.data,NULL,base); + if (errno == ERANGE) + error("integer overflow"); +#else + // Not everybody implements strtoull() + char *p = (char *)stringbuffer.data; + int r = 10, d; + + if (*p == '0') + { + if (p[1] == 'x' || p[1] == 'X') + p += 2, r = 16; + else if (p[1] == 'b' || p[1] == 'B') + p += 2, r = 2; + else if (isdigit((unsigned char)p[1])) + p += 1, r = 8; + } + + n = 0; + while (1) + { + if (*p >= '0' && *p <= '9') + d = *p - '0'; + else if (*p >= 'a' && *p <= 'z') + d = *p - 'a' + 10; + else if (*p >= 'A' && *p <= 'Z') + d = *p - 'A' + 10; + else + break; + if (d >= r) + break; + uinteger_t n2 = n * r; + //printf("n2 / r = %llx, n = %llx\n", n2/r, n); + if (n2 / r != n || n2 + d < n) + { + error ("integer overflow"); + break; + } + + n = n2 + d; + p++; + } +#endif + if (sizeof(n) > 8 && + n > 0xFFFFFFFFFFFFFFFFULL) // if n needs more than 64 bits + error("integer overflow"); + } + + // Parse trailing 'u', 'U', 'l' or 'L' in any combination + const unsigned char *psuffix = p; + while (1) + { unsigned char f; + + switch (*p) + { case 'U': + case 'u': + f = FLAGS_unsigned; + goto L1; + + case 'l': + if (1 || !global.params.useDeprecated) + error("'l' suffix is deprecated, use 'L' instead"); + case 'L': + f = FLAGS_long; + L1: + p++; + if (flags & f) + error("unrecognized token"); + flags = (FLAGS) (flags | f); + continue; + default: + break; + } + break; + } + +#if DMDV2 + if (state == STATE_octal && n >= 8 && !global.params.useDeprecated) + error("octal literals 0%llo%.*s are deprecated, use std.conv.octal!%llo%.*s instead", + n, p - psuffix, psuffix, n, p - psuffix, psuffix); +#endif + + switch (flags) + { + case 0: + /* Octal or Hexadecimal constant. + * First that fits: int, uint, long, ulong + */ + if (n & 0x8000000000000000LL) + result = TOKuns64v; + else if (n & 0xFFFFFFFF00000000LL) + result = TOKint64v; + else if (n & 0x80000000) + result = TOKuns32v; + else + result = TOKint32v; + break; + + case FLAGS_decimal: + /* First that fits: int, long, long long + */ + if (n & 0x8000000000000000LL) + { error("signed integer overflow"); + result = TOKuns64v; + } + else if (n & 0xFFFFFFFF80000000LL) + result = TOKint64v; + else + result = TOKint32v; + break; + + case FLAGS_unsigned: + case FLAGS_decimal | FLAGS_unsigned: + /* First that fits: uint, ulong + */ + if (n & 0xFFFFFFFF00000000LL) + result = TOKuns64v; + else + result = TOKuns32v; + break; + + case FLAGS_decimal | FLAGS_long: + if (n & 0x8000000000000000LL) + { error("signed integer overflow"); + result = TOKuns64v; + } + else + result = TOKint64v; + break; + + case FLAGS_long: + if (n & 0x8000000000000000LL) + result = TOKuns64v; + else + result = TOKint64v; + break; + + case FLAGS_unsigned | FLAGS_long: + case FLAGS_decimal | FLAGS_unsigned | FLAGS_long: + result = TOKuns64v; + break; + + default: + #ifdef DEBUG + printf("%x\n",flags); + #endif + assert(0); + } + t->uns64value = n; + return result; +} + +/************************************** + * Read in characters, converting them to real. + * Bugs: + * Exponent overflow not detected. + * Too much requested precision is not detected. + */ + +TOK Lexer::inreal(Token *t) +#ifdef __DMC__ +__in +{ + assert(*p == '.' || isdigit(*p)); +} +__out (result) +{ + switch (result) + { + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + break; + + default: + assert(0); + } +} +__body +#endif /* __DMC__ */ +{ int dblstate; + unsigned c; + char hex; // is this a hexadecimal-floating-constant? + TOK result; + + //printf("Lexer::inreal()\n"); + stringbuffer.reset(); + dblstate = 0; + hex = 0; +Lnext: + while (1) + { + // Get next char from input + c = *p++; + //printf("dblstate = %d, c = '%c'\n", dblstate, c); + while (1) + { + switch (dblstate) + { + case 0: // opening state + if (c == '0') + dblstate = 9; + else if (c == '.') + dblstate = 3; + else + dblstate = 1; + break; + + case 9: + dblstate = 1; + if (c == 'X' || c == 'x') + { hex++; + break; + } + case 1: // digits to left of . + case 3: // digits to right of . + case 7: // continuing exponent digits + if (!isdigit(c) && !(hex && isxdigit(c))) + { + if (c == '_') + goto Lnext; // ignore embedded '_' + dblstate++; + continue; + } + break; + + case 2: // no more digits to left of . + if (c == '.') + { dblstate++; + break; + } + case 4: // no more digits to right of . + if ((c == 'E' || c == 'e') || + hex && (c == 'P' || c == 'p')) + { dblstate = 5; + hex = 0; // exponent is always decimal + break; + } + if (hex) + error("binary-exponent-part required"); + goto done; + + case 5: // looking immediately to right of E + dblstate++; + if (c == '-' || c == '+') + break; + case 6: // 1st exponent digit expected + if (!isdigit(c)) + error("exponent expected"); + dblstate++; + break; + + case 8: // past end of exponent digits + goto done; + } + break; + } + stringbuffer.writeByte(c); + } +done: + p--; + + stringbuffer.writeByte(0); + +#if _WIN32 && __DMC__ + char *save = __locale_decpoint; + __locale_decpoint = "."; +#endif +#ifdef IN_GCC + t->float80value = real_t::parse((char *)stringbuffer.data, real_t::LongDouble); +#else + t->float80value = strtold((char *)stringbuffer.data, NULL); +#endif + errno = 0; + switch (*p) + { + case 'F': + case 'f': +#ifdef IN_GCC + real_t::parse((char *)stringbuffer.data, real_t::Float); +#else + { // Only interested in errno return + double d = strtof((char *)stringbuffer.data, NULL); + // Assign to f to keep gcc warnings at bay + } +#endif + result = TOKfloat32v; + p++; + break; + + default: +#ifdef IN_GCC + real_t::parse((char *)stringbuffer.data, real_t::Double); +#else + /* Should do our own strtod(), since dmc and linux gcc + * accept 2.22507e-308, while apple gcc will only take + * 2.22508e-308. Not sure who is right. + */ + { // Only interested in errno return + double d = strtod((char *)stringbuffer.data, NULL); + // Assign to d to keep gcc warnings at bay + } +#endif + result = TOKfloat64v; + break; + + case 'l': + if (!global.params.useDeprecated) + error("'l' suffix is deprecated, use 'L' instead"); + case 'L': + result = TOKfloat80v; + p++; + break; + } + if (*p == 'i' || *p == 'I') + { + if (!global.params.useDeprecated && *p == 'I') + error("'I' suffix is deprecated, use 'i' instead"); + p++; + switch (result) + { + case TOKfloat32v: + result = TOKimaginary32v; + break; + case TOKfloat64v: + result = TOKimaginary64v; + break; + case TOKfloat80v: + result = TOKimaginary80v; + break; + } + } +#if _WIN32 && __DMC__ + __locale_decpoint = save; +#endif + if (errno == ERANGE) + error("number is not representable"); + return result; +} + +/********************************************* + * Do pragma. + * Currently, the only pragma supported is: + * #line linnum [filespec] + */ + +void Lexer::pragma() +{ + Token tok; + int linnum; + char *filespec = NULL; + Loc loc = this->loc; + + scan(&tok); + if (tok.value != TOKidentifier || tok.ident != Id::line) + goto Lerr; + + scan(&tok); + if (tok.value == TOKint32v || tok.value == TOKint64v) + { linnum = tok.uns64value - 1; + if (linnum != tok.uns64value - 1) + error("line number out of range"); + } + else + goto Lerr; + + while (1) + { + switch (*p) + { + case 0: + case 0x1A: + case '\n': + Lnewline: + this->loc.linnum = linnum; + if (filespec) + this->loc.filename = filespec; + return; + + case '\r': + p++; + if (*p != '\n') + { p--; + goto Lnewline; + } + continue; + + case ' ': + case '\t': + case '\v': + case '\f': + p++; + continue; // skip white space + + case '_': + if (mod && memcmp(p, "__FILE__", 8) == 0) + { + p += 8; + filespec = mem.strdup(loc.filename ? loc.filename : mod->ident->toChars()); + } + continue; + + case '"': + if (filespec) + goto Lerr; + stringbuffer.reset(); + p++; + while (1) + { unsigned c; + + c = *p; + switch (c) + { + case '\n': + case '\r': + case 0: + case 0x1A: + goto Lerr; + + case '"': + stringbuffer.writeByte(0); + filespec = mem.strdup((char *)stringbuffer.data); + p++; + break; + + default: + if (c & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + goto Lerr; + } + stringbuffer.writeByte(c); + p++; + continue; + } + break; + } + continue; + + default: + if (*p & 0x80) + { unsigned u = decodeUTF(); + if (u == PS || u == LS) + goto Lnewline; + } + goto Lerr; + } + } + +Lerr: + error(loc, "#line integer [\"filespec\"]\\n expected"); +} + + +/******************************************** + * Decode UTF character. + * Issue error messages for invalid sequences. + * Return decoded character, advance p to last character in UTF sequence. + */ + +unsigned Lexer::decodeUTF() +{ + dchar_t u; + unsigned char c; + unsigned char *s = p; + size_t len; + size_t idx; + const char *msg; + + c = *s; + assert(c & 0x80); + + // Check length of remaining string up to 6 UTF-8 characters + for (len = 1; len < 6 && s[len]; len++) + ; + + idx = 0; + msg = utf_decodeChar(s, len, &idx, &u); + p += idx - 1; + if (msg) + { + error("%s", msg); + } + return u; +} + + +/*************************************************** + * Parse doc comment embedded between t->ptr and p. + * Remove trailing blanks and tabs from lines. + * Replace all newlines with \n. + * Remove leading comment character from each line. + * Decide if it's a lineComment or a blockComment. + * Append to previous one for this token. + */ + +void Lexer::getDocComment(Token *t, unsigned lineComment) +{ + /* ct tells us which kind of comment it is: '/', '*', or '+' + */ + unsigned char ct = t->ptr[2]; + + /* Start of comment text skips over / * *, / + +, or / / / + */ + unsigned char *q = t->ptr + 3; // start of comment text + + unsigned char *qend = p; + if (ct == '*' || ct == '+') + qend -= 2; + + /* Scan over initial row of ****'s or ++++'s or ////'s + */ + for (; q < qend; q++) + { + if (*q != ct) + break; + } + + /* Remove trailing row of ****'s or ++++'s + */ + if (ct != '/') + { + for (; q < qend; qend--) + { + if (qend[-1] != ct) + break; + } + } + + /* Comment is now [q .. qend]. + * Canonicalize it into buf[]. + */ + OutBuffer buf; + int linestart = 0; + + for (; q < qend; q++) + { + unsigned char c = *q; + + switch (c) + { + case '*': + case '+': + if (linestart && c == ct) + { linestart = 0; + /* Trim preceding whitespace up to preceding \n + */ + while (buf.offset && (buf.data[buf.offset - 1] == ' ' || buf.data[buf.offset - 1] == '\t')) + buf.offset--; + continue; + } + break; + + case ' ': + case '\t': + break; + + case '\r': + if (q[1] == '\n') + continue; // skip the \r + goto Lnewline; + + default: + if (c == 226) + { + // If LS or PS + if (q[1] == 128 && + (q[2] == 168 || q[2] == 169)) + { + q += 2; + goto Lnewline; + } + } + linestart = 0; + break; + + Lnewline: + c = '\n'; // replace all newlines with \n + case '\n': + linestart = 1; + + /* Trim trailing whitespace + */ + while (buf.offset && (buf.data[buf.offset - 1] == ' ' || buf.data[buf.offset - 1] == '\t')) + buf.offset--; + + break; + } + buf.writeByte(c); + } + + // Always end with a newline + if (!buf.offset || buf.data[buf.offset - 1] != '\n') + buf.writeByte('\n'); + + buf.writeByte(0); + + // It's a line comment if the start of the doc comment comes + // after other non-whitespace on the same line. + unsigned char** dc = (lineComment && anyToken) + ? &t->lineComment + : &t->blockComment; + + // Combine with previous doc comment, if any + if (*dc) + *dc = combineComments(*dc, (unsigned char *)buf.data); + else + *dc = (unsigned char *)buf.extractData(); +} + +/******************************************** + * Combine two document comments into one, + * separated by a newline. + */ + +unsigned char *Lexer::combineComments(unsigned char *c1, unsigned char *c2) +{ + //printf("Lexer::combineComments('%s', '%s')\n", c1, c2); + + unsigned char *c = c2; + + if (c1) + { c = c1; + if (c2) + { size_t len1 = strlen((char *)c1); + size_t len2 = strlen((char *)c2); + + c = (unsigned char *)mem.malloc(len1 + 1 + len2 + 1); + memcpy(c, c1, len1); + if (len1 && c1[len1 - 1] != '\n') + { c[len1] = '\n'; + len1++; + } + memcpy(c + len1, c2, len2); + c[len1 + len2] = 0; + } + } + return c; +} + +/******************************************** + * Create an identifier in the string table. + */ + +Identifier *Lexer::idPool(const char *s) +{ + size_t len = strlen(s); + StringValue *sv = stringtable.update(s, len); + Identifier *id = (Identifier *) sv->ptrvalue; + if (!id) + { + id = new Identifier(sv->lstring.string, TOKidentifier); + sv->ptrvalue = id; + } + return id; +} + +/********************************************* + * Create a unique identifier using the prefix s. + */ + +Identifier *Lexer::uniqueId(const char *s, int num) +{ char buffer[32]; + size_t slen = strlen(s); + + assert(slen + sizeof(num) * 3 + 1 <= sizeof(buffer)); + sprintf(buffer, "%s%d", s, num); + return idPool(buffer); +} + +Identifier *Lexer::uniqueId(const char *s) +{ + static int num; + return uniqueId(s, ++num); +} + +/**************************************** + */ + +struct Keyword +{ const char *name; + enum TOK value; +}; + +static Keyword keywords[] = +{ +// { "", TOK }, + + { "this", TOKthis }, + { "super", TOKsuper }, + { "assert", TOKassert }, + { "null", TOKnull }, + { "true", TOKtrue }, + { "false", TOKfalse }, + { "cast", TOKcast }, + { "new", TOKnew }, + { "delete", TOKdelete }, + { "throw", TOKthrow }, + { "module", TOKmodule }, + { "pragma", TOKpragma }, + { "typeof", TOKtypeof }, + { "typeid", TOKtypeid }, + + { "template", TOKtemplate }, + + { "void", TOKvoid }, + { "byte", TOKint8 }, + { "ubyte", TOKuns8 }, + { "short", TOKint16 }, + { "ushort", TOKuns16 }, + { "int", TOKint32 }, + { "uint", TOKuns32 }, + { "long", TOKint64 }, + { "ulong", TOKuns64 }, + { "cent", TOKcent, }, + { "ucent", TOKucent, }, + { "float", TOKfloat32 }, + { "double", TOKfloat64 }, + { "real", TOKfloat80 }, + + { "bool", TOKbool }, + { "char", TOKchar }, + { "wchar", TOKwchar }, + { "dchar", TOKdchar }, + + { "ifloat", TOKimaginary32 }, + { "idouble", TOKimaginary64 }, + { "ireal", TOKimaginary80 }, + + { "cfloat", TOKcomplex32 }, + { "cdouble", TOKcomplex64 }, + { "creal", TOKcomplex80 }, + + { "delegate", TOKdelegate }, + { "function", TOKfunction }, + + { "is", TOKis }, + { "if", TOKif }, + { "else", TOKelse }, + { "while", TOKwhile }, + { "for", TOKfor }, + { "do", TOKdo }, + { "switch", TOKswitch }, + { "case", TOKcase }, + { "default", TOKdefault }, + { "break", TOKbreak }, + { "continue", TOKcontinue }, + { "synchronized", TOKsynchronized }, + { "return", TOKreturn }, + { "goto", TOKgoto }, + { "try", TOKtry }, + { "catch", TOKcatch }, + { "finally", TOKfinally }, + { "with", TOKwith }, + { "asm", TOKasm }, + { "foreach", TOKforeach }, + { "foreach_reverse", TOKforeach_reverse }, + { "scope", TOKscope }, + + { "struct", TOKstruct }, + { "class", TOKclass }, + { "interface", TOKinterface }, + { "union", TOKunion }, + { "enum", TOKenum }, + { "import", TOKimport }, + { "mixin", TOKmixin }, + { "static", TOKstatic }, + { "final", TOKfinal }, + { "const", TOKconst }, + { "typedef", TOKtypedef }, + { "alias", TOKalias }, + { "override", TOKoverride }, + { "abstract", TOKabstract }, + { "volatile", TOKvolatile }, + { "debug", TOKdebug }, + { "deprecated", TOKdeprecated }, + { "in", TOKin }, + { "out", TOKout }, + { "inout", TOKinout }, + { "lazy", TOKlazy }, + { "auto", TOKauto }, + + { "align", TOKalign }, + { "extern", TOKextern }, + { "private", TOKprivate }, + { "package", TOKpackage }, + { "protected", TOKprotected }, + { "public", TOKpublic }, + { "export", TOKexport }, + + { "body", TOKbody }, + { "invariant", TOKinvariant }, + { "unittest", TOKunittest }, + { "version", TOKversion }, + //{ "manifest", TOKmanifest }, + + // Added after 1.0 + { "__argTypes", TOKargTypes }, + { "ref", TOKref }, + { "macro", TOKmacro }, +#if DMDV2 + { "pure", TOKpure }, + { "nothrow", TOKnothrow }, + { "__thread", TOKtls }, + { "__gshared", TOKgshared }, + { "__traits", TOKtraits }, + { "__vector", TOKvector }, + { "__overloadset", TOKoverloadset }, + { "__FILE__", TOKfile }, + { "__LINE__", TOKline }, + { "shared", TOKshared }, + { "immutable", TOKimmutable }, +#endif +}; + +int Token::isKeyword() +{ + for (unsigned u = 0; u < sizeof(keywords) / sizeof(keywords[0]); u++) + { + if (keywords[u].value == value) + return 1; + } + return 0; +} + +void Lexer::initKeywords() +{ + unsigned nkeywords = sizeof(keywords) / sizeof(keywords[0]); + + stringtable.init(6151); + + if (global.params.Dversion == 1) + nkeywords -= 2; + + cmtable_init(); + + for (unsigned u = 0; u < nkeywords; u++) + { + //printf("keyword[%d] = '%s'\n",u, keywords[u].name); + const char *s = keywords[u].name; + enum TOK v = keywords[u].value; + StringValue *sv = stringtable.insert(s, strlen(s)); + sv->ptrvalue = (void *) new Identifier(sv->lstring.string,v); + + //printf("tochars[%d] = '%s'\n",v, s); + Token::tochars[v] = s; + } + + Token::tochars[TOKeof] = "EOF"; + Token::tochars[TOKlcurly] = "{"; + Token::tochars[TOKrcurly] = "}"; + Token::tochars[TOKlparen] = "("; + Token::tochars[TOKrparen] = ")"; + Token::tochars[TOKlbracket] = "["; + Token::tochars[TOKrbracket] = "]"; + Token::tochars[TOKsemicolon] = ";"; + Token::tochars[TOKcolon] = ":"; + Token::tochars[TOKcomma] = ","; + Token::tochars[TOKdot] = "."; + Token::tochars[TOKxor] = "^"; + Token::tochars[TOKxorass] = "^="; + Token::tochars[TOKassign] = "="; + Token::tochars[TOKconstruct] = "="; +#if DMDV2 + Token::tochars[TOKblit] = "="; +#endif + Token::tochars[TOKlt] = "<"; + Token::tochars[TOKgt] = ">"; + Token::tochars[TOKle] = "<="; + Token::tochars[TOKge] = ">="; + Token::tochars[TOKequal] = "=="; + Token::tochars[TOKnotequal] = "!="; + Token::tochars[TOKnotidentity] = "!is"; + Token::tochars[TOKtobool] = "!!"; + + Token::tochars[TOKunord] = "!<>="; + Token::tochars[TOKue] = "!<>"; + Token::tochars[TOKlg] = "<>"; + Token::tochars[TOKleg] = "<>="; + Token::tochars[TOKule] = "!>"; + Token::tochars[TOKul] = "!>="; + Token::tochars[TOKuge] = "!<"; + Token::tochars[TOKug] = "!<="; + + Token::tochars[TOKnot] = "!"; + Token::tochars[TOKtobool] = "!!"; + Token::tochars[TOKshl] = "<<"; + Token::tochars[TOKshr] = ">>"; + Token::tochars[TOKushr] = ">>>"; + Token::tochars[TOKadd] = "+"; + Token::tochars[TOKmin] = "-"; + Token::tochars[TOKmul] = "*"; + Token::tochars[TOKdiv] = "/"; + Token::tochars[TOKmod] = "%"; + Token::tochars[TOKslice] = ".."; + Token::tochars[TOKdotdotdot] = "..."; + Token::tochars[TOKand] = "&"; + Token::tochars[TOKandand] = "&&"; + Token::tochars[TOKor] = "|"; + Token::tochars[TOKoror] = "||"; + Token::tochars[TOKarray] = "[]"; + Token::tochars[TOKindex] = "[i]"; + Token::tochars[TOKaddress] = "&"; + Token::tochars[TOKstar] = "*"; + Token::tochars[TOKtilde] = "~"; + Token::tochars[TOKdollar] = "$"; + Token::tochars[TOKcast] = "cast"; + Token::tochars[TOKplusplus] = "++"; + Token::tochars[TOKminusminus] = "--"; + Token::tochars[TOKpreplusplus] = "++"; + Token::tochars[TOKpreminusminus] = "--"; + Token::tochars[TOKtype] = "type"; + Token::tochars[TOKquestion] = "?"; + Token::tochars[TOKneg] = "-"; + Token::tochars[TOKuadd] = "+"; + Token::tochars[TOKvar] = "var"; + Token::tochars[TOKaddass] = "+="; + Token::tochars[TOKminass] = "-="; + Token::tochars[TOKmulass] = "*="; + Token::tochars[TOKdivass] = "/="; + Token::tochars[TOKmodass] = "%="; + Token::tochars[TOKshlass] = "<<="; + Token::tochars[TOKshrass] = ">>="; + Token::tochars[TOKushrass] = ">>>="; + Token::tochars[TOKandass] = "&="; + Token::tochars[TOKorass] = "|="; + Token::tochars[TOKcatass] = "~="; + Token::tochars[TOKcat] = "~"; + Token::tochars[TOKcall] = "call"; + Token::tochars[TOKidentity] = "is"; + Token::tochars[TOKnotidentity] = "!is"; + + Token::tochars[TOKorass] = "|="; + Token::tochars[TOKidentifier] = "identifier"; +#if DMDV2 + Token::tochars[TOKat] = "@"; + Token::tochars[TOKpow] = "^^"; + Token::tochars[TOKpowass] = "^^="; + Token::tochars[TOKgoesto] = "=>"; +#endif + + // For debugging + Token::tochars[TOKerror] = "error"; + Token::tochars[TOKdotexp] = "dotexp"; + Token::tochars[TOKdotti] = "dotti"; + Token::tochars[TOKdotvar] = "dotvar"; + Token::tochars[TOKdottype] = "dottype"; + Token::tochars[TOKsymoff] = "symoff"; + Token::tochars[TOKarraylength] = "arraylength"; + Token::tochars[TOKarrayliteral] = "arrayliteral"; + Token::tochars[TOKassocarrayliteral] = "assocarrayliteral"; + Token::tochars[TOKstructliteral] = "structliteral"; + Token::tochars[TOKstring] = "string"; + Token::tochars[TOKdsymbol] = "symbol"; + Token::tochars[TOKtuple] = "tuple"; + Token::tochars[TOKdeclaration] = "declaration"; + Token::tochars[TOKdottd] = "dottd"; + Token::tochars[TOKon_scope_exit] = "scope(exit)"; + Token::tochars[TOKon_scope_success] = "scope(success)"; + Token::tochars[TOKon_scope_failure] = "scope(failure)"; + +#if UNITTEST + unittest_lexer(); +#endif +} + +#if UNITTEST + +void unittest_lexer() +{ + //printf("unittest_lexer()\n"); + + /* Not much here, just trying things out. + */ + const unsigned char text[] = "int"; + Lexer lex1(NULL, (unsigned char *)text, 0, sizeof(text), 0, 0); + TOK tok; + tok = lex1.nextToken(); + //printf("tok == %s, %d, %d\n", Token::toChars(tok), tok, TOKint32); + assert(tok == TOKint32); + tok = lex1.nextToken(); + assert(tok == TOKeof); + tok = lex1.nextToken(); + assert(tok == TOKeof); +} + +#endif + diff --git a/lexer.h b/lexer.h new file mode 100644 index 00000000..9b1e132e --- /dev/null +++ b/lexer.h @@ -0,0 +1,316 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_LEXER_H +#define DMD_LEXER_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "mars.h" + +struct StringTable; +struct Identifier; +struct Module; + +/* Tokens: + ( ) + [ ] + { } + < > <= >= == != === !== + << >> <<= >>= >>> >>>= + + - += -= + * / % *= /= %= + & | ^ &= |= ^= + = ! ~ @ + ^^ ^^= + ++ -- + . -> : , => + ? && || + */ + +enum TOK +{ + TOKreserved, + + // Other + TOKlparen, TOKrparen, + TOKlbracket, TOKrbracket, + TOKlcurly, TOKrcurly, + TOKcolon, TOKneg, + TOKsemicolon, TOKdotdotdot, + TOKeof, TOKcast, + TOKnull, TOKassert, + TOKtrue, TOKfalse, + TOKarray, TOKcall, + TOKaddress, + TOKtype, TOKthrow, + TOKnew, TOKdelete, + TOKstar, TOKsymoff, + TOKvar, TOKdotvar, + TOKdotti, TOKdotexp, + TOKdottype, TOKslice, + TOKarraylength, TOKversion, + TOKmodule, TOKdollar, + TOKtemplate, TOKdottd, + TOKdeclaration, TOKtypeof, + TOKpragma, TOKdsymbol, + TOKtypeid, TOKuadd, + TOKremove, + TOKnewanonclass, TOKcomment, + TOKarrayliteral, TOKassocarrayliteral, + TOKstructliteral, + + // Operators + TOKlt, TOKgt, + TOKle, TOKge, + TOKequal, TOKnotequal, + TOKidentity, TOKnotidentity, + TOKindex, TOKis, + TOKtobool, + +// 60 + // NCEG floating point compares + // !<>= <> <>= !> !>= !< !<= !<> + TOKunord,TOKlg,TOKleg,TOKule,TOKul,TOKuge,TOKug,TOKue, + + TOKshl, TOKshr, + TOKshlass, TOKshrass, + TOKushr, TOKushrass, + TOKcat, TOKcatass, // ~ ~= + TOKadd, TOKmin, TOKaddass, TOKminass, + TOKmul, TOKdiv, TOKmod, + TOKmulass, TOKdivass, TOKmodass, + TOKand, TOKor, TOKxor, + TOKandass, TOKorass, TOKxorass, + TOKassign, TOKnot, TOKtilde, + TOKplusplus, TOKminusminus, TOKconstruct, TOKblit, + TOKdot, TOKarrow, TOKcomma, + TOKquestion, TOKandand, TOKoror, + TOKpreplusplus, TOKpreminusminus, + +// 106 + // Numeric literals + TOKint32v, TOKuns32v, + TOKint64v, TOKuns64v, + TOKfloat32v, TOKfloat64v, TOKfloat80v, + TOKimaginary32v, TOKimaginary64v, TOKimaginary80v, + + // Char constants + TOKcharv, TOKwcharv, TOKdcharv, + + // Leaf operators + TOKidentifier, TOKstring, + TOKthis, TOKsuper, + TOKhalt, TOKtuple, + TOKerror, + + // Basic types + TOKvoid, + TOKint8, TOKuns8, + TOKint16, TOKuns16, + TOKint32, TOKuns32, + TOKint64, TOKuns64, + TOKfloat32, TOKfloat64, TOKfloat80, + TOKimaginary32, TOKimaginary64, TOKimaginary80, + TOKcomplex32, TOKcomplex64, TOKcomplex80, + TOKchar, TOKwchar, TOKdchar, TOKbit, TOKbool, + TOKcent, TOKucent, + +// 152 + // Aggregates + TOKstruct, TOKclass, TOKinterface, TOKunion, TOKenum, TOKimport, + TOKtypedef, TOKalias, TOKoverride, TOKdelegate, TOKfunction, + TOKmixin, + + TOKalign, TOKextern, TOKprivate, TOKprotected, TOKpublic, TOKexport, + TOKstatic, /*TOKvirtual,*/ TOKfinal, TOKconst, TOKabstract, TOKvolatile, + TOKdebug, TOKdeprecated, TOKin, TOKout, TOKinout, TOKlazy, + TOKauto, TOKpackage, TOKmanifest, TOKimmutable, + + // Statements + TOKif, TOKelse, TOKwhile, TOKfor, TOKdo, TOKswitch, + TOKcase, TOKdefault, TOKbreak, TOKcontinue, TOKwith, + TOKsynchronized, TOKreturn, TOKgoto, TOKtry, TOKcatch, TOKfinally, + TOKasm, TOKforeach, TOKforeach_reverse, + TOKscope, + TOKon_scope_exit, TOKon_scope_failure, TOKon_scope_success, + + // Contracts + TOKbody, TOKinvariant, + + // Testing + TOKunittest, + + // Added after 1.0 + TOKargTypes, + TOKref, + TOKmacro, +#if DMDV2 + TOKtraits, + TOKoverloadset, + TOKpure, + TOKnothrow, + TOKtls, + TOKgshared, + TOKline, + TOKfile, + TOKshared, + TOKat, + TOKpow, + TOKpowass, + TOKgoesto, + TOKvector, +#endif + + TOKMAX +}; + +#define TOKwild TOKinout + +#define BASIC_TYPES \ + TOKwchar: case TOKdchar: \ + case TOKbit: case TOKbool: case TOKchar: \ + case TOKint8: case TOKuns8: \ + case TOKint16: case TOKuns16: \ + case TOKint32: case TOKuns32: \ + case TOKint64: case TOKuns64: \ + case TOKfloat32: case TOKfloat64: case TOKfloat80: \ + case TOKimaginary32: case TOKimaginary64: case TOKimaginary80: \ + case TOKcomplex32: case TOKcomplex64: case TOKcomplex80: \ + case TOKvoid + +#define BASIC_TYPES_X(t) \ + TOKvoid: t = Type::tvoid; goto LabelX; \ + case TOKint8: t = Type::tint8; goto LabelX; \ + case TOKuns8: t = Type::tuns8; goto LabelX; \ + case TOKint16: t = Type::tint16; goto LabelX; \ + case TOKuns16: t = Type::tuns16; goto LabelX; \ + case TOKint32: t = Type::tint32; goto LabelX; \ + case TOKuns32: t = Type::tuns32; goto LabelX; \ + case TOKint64: t = Type::tint64; goto LabelX; \ + case TOKuns64: t = Type::tuns64; goto LabelX; \ + case TOKfloat32: t = Type::tfloat32; goto LabelX; \ + case TOKfloat64: t = Type::tfloat64; goto LabelX; \ + case TOKfloat80: t = Type::tfloat80; goto LabelX; \ + case TOKimaginary32: t = Type::timaginary32; goto LabelX; \ + case TOKimaginary64: t = Type::timaginary64; goto LabelX; \ + case TOKimaginary80: t = Type::timaginary80; goto LabelX; \ + case TOKcomplex32: t = Type::tcomplex32; goto LabelX; \ + case TOKcomplex64: t = Type::tcomplex64; goto LabelX; \ + case TOKcomplex80: t = Type::tcomplex80; goto LabelX; \ + case TOKbool: t = Type::tbool; goto LabelX; \ + case TOKchar: t = Type::tchar; goto LabelX; \ + case TOKwchar: t = Type::twchar; goto LabelX; \ + case TOKdchar: t = Type::tdchar; goto LabelX; \ + LabelX + +struct Token +{ + Token *next; + unsigned char *ptr; // pointer to first character of this token within buffer + enum TOK value; + unsigned char *blockComment; // doc comment string prior to this token + unsigned char *lineComment; // doc comment for previous token + union + { + // Integers + d_int32 int32value; + d_uns32 uns32value; + d_int64 int64value; + d_uns64 uns64value; + + // Floats +#ifdef IN_GCC + // real_t float80value; // can't use this in a union! +#else + d_float80 float80value; +#endif + + struct + { unsigned char *ustring; // UTF8 string + unsigned len; + unsigned char postfix; // 'c', 'w', 'd' + }; + + Identifier *ident; + }; +#ifdef IN_GCC + real_t float80value; // can't use this in a union! +#endif + + static const char *tochars[TOKMAX]; + static void *operator new(size_t sz); + + int isKeyword(); + void print(); + const char *toChars(); + static const char *toChars(enum TOK); +}; + +struct Lexer +{ + static StringTable stringtable; + static OutBuffer stringbuffer; + static Token *freelist; + + Loc loc; // for error messages + + unsigned char *base; // pointer to start of buffer + unsigned char *end; // past end of buffer + unsigned char *p; // current character + Token token; + Module *mod; + int doDocComment; // collect doc comment information + int anyToken; // !=0 means seen at least one token + int commentToken; // !=0 means comments are TOKcomment's + + Lexer(Module *mod, + unsigned char *base, unsigned begoffset, unsigned endoffset, + int doDocComment, int commentToken); + + static void initKeywords(); + static Identifier *idPool(const char *s); + static Identifier *uniqueId(const char *s); + static Identifier *uniqueId(const char *s, int num); + + TOK nextToken(); + TOK peekNext(); + TOK peekNext2(); + void scan(Token *t); + Token *peek(Token *t); + Token *peekPastParen(Token *t); + unsigned escapeSequence(); + TOK wysiwygStringConstant(Token *t, int tc); + TOK hexStringConstant(Token *t); +#if DMDV2 + TOK delimitedStringConstant(Token *t); + TOK tokenStringConstant(Token *t); +#endif + TOK escapeStringConstant(Token *t, int wide); + TOK charConstant(Token *t, int wide); + void stringPostfix(Token *t); + unsigned wchar(unsigned u); + TOK number(Token *t); + TOK inreal(Token *t); + void error(const char *format, ...); + void error(Loc loc, const char *format, ...); + void verror(Loc loc, const char *format, va_list ap); + void pragma(); + unsigned decodeUTF(); + void getDocComment(Token *t, unsigned lineComment); + + static int isValidIdentifier(char *p); + static unsigned char *combineComments(unsigned char *c1, unsigned char *c2); +}; + +#endif /* DMD_LEXER_H */ diff --git a/lib.h b/lib.h new file mode 100644 index 00000000..abd31cb2 --- /dev/null +++ b/lib.h @@ -0,0 +1,54 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2008 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_LIB_H +#define DMD_LIB_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +struct ObjModule; + +struct ObjSymbol +{ + char *name; + ObjModule *om; +}; + +#include "arraytypes.h" + +typedef ArrayBase ObjModules; +typedef ArrayBase ObjSymbols; + +struct Library +{ + File *libfile; + ObjModules objmodules; // ObjModule[] + ObjSymbols objsymbols; // ObjSymbol[] + + StringTable tab; + + Library(); + void setFilename(char *dir, char *filename); + void addObject(const char *module_name, void *buf, size_t buflen); + void addLibrary(void *buf, size_t buflen); + void write(); + + private: + void addSymbol(ObjModule *om, char *name, int pickAny = 0); + void scanObjModule(ObjModule *om); + unsigned short numDictPages(unsigned padding); + int FillDict(unsigned char *bucketsP, unsigned short uNumPages); + void WriteLibToBuffer(OutBuffer *libbuf); +}; + +#endif /* DMD_LIB_H */ + diff --git a/libelf.c b/libelf.c new file mode 100644 index 00000000..cf56fd39 --- /dev/null +++ b/libelf.c @@ -0,0 +1,773 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include +#include +#include + +#include "rmem.h" +#include "root.h" +#include "stringtable.h" + +#include "mars.h" +#include "lib.h" +#include "melf.h" + +#define LOG 0 + +Library::Library() +{ + libfile = NULL; + tab.init(); +} + +/*********************************** + * Set the library file name based on the output directory + * and the filename. + * Add default library file name extension. + */ + +void Library::setFilename(char *dir, char *filename) +{ +#if LOG + printf("Library::setFilename(dir = '%s', filename = '%s')\n", + dir ? dir : "", filename ? filename : ""); +#endif + char *arg = filename; + if (!arg || !*arg) + { // Generate lib file name from first obj name + char *n = global.params.objfiles->tdata()[0]; + + n = FileName::name(n); + FileName *fn = FileName::forceExt(n, global.lib_ext); + arg = fn->toChars(); + } + if (!FileName::absolute(arg)) + arg = FileName::combine(dir, arg); + FileName *libfilename = FileName::defaultExt(arg, global.lib_ext); + + libfile = new File(libfilename); +} + +void Library::write() +{ + if (global.params.verbose) + printf("library %s\n", libfile->name->toChars()); + + OutBuffer libbuf; + WriteLibToBuffer(&libbuf); + + // Transfer image to file + libfile->setbuffer(libbuf.data, libbuf.offset); + libbuf.extractData(); + + + char *p = FileName::path(libfile->name->toChars()); + FileName::ensurePathExists(p); + //mem.free(p); + + libfile->writev(); +} + +/*****************************************************************************/ + +void Library::addLibrary(void *buf, size_t buflen) +{ + addObject(NULL, buf, buflen); +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +static char elf[4] = { 0x7F, 'E', 'L', 'F' }; // ELF file signature + +void sputl(int value, void* buffer) +{ + unsigned char *p = (unsigned char*)buffer; + p[0] = (unsigned char)(value >> 24); + p[1] = (unsigned char)(value >> 16); + p[2] = (unsigned char)(value >> 8); + p[3] = (unsigned char)(value); +} + +int sgetl(void* buffer) +{ + unsigned char *p = (unsigned char*)buffer; + return (((((p[0] << 8) | p[1]) << 8) | p[2]) << 8) | p[3]; +} + + +struct ObjModule +{ + unsigned char *base; // where are we holding it in memory + unsigned length; // in bytes + unsigned offset; // offset from start of library + char *name; // module name (file name) + int name_offset; // if not -1, offset into string table of name + time_t file_time; // file time + unsigned user_id; + unsigned group_id; + unsigned file_mode; + int scan; // 1 means scan for symbols +}; + +struct Header +{ + #define OBJECT_NAME_SIZE 16 + char object_name[OBJECT_NAME_SIZE]; + char file_time[12]; + char user_id[6]; + char group_id[6]; + char file_mode[8]; // in octal + char file_size[10]; + char trailer[2]; +}; + +void OmToHeader(Header *h, ObjModule *om) +{ + size_t len; + if (om->name_offset == -1) + { + len = strlen(om->name); + memcpy(h->object_name, om->name, len); + h->object_name[len] = '/'; + } + else + { + len = sprintf(h->object_name, "/%d", om->name_offset); + h->object_name[len] = ' '; + } + assert(len < OBJECT_NAME_SIZE); + memset(h->object_name + len + 1, ' ', OBJECT_NAME_SIZE - (len + 1)); + + /* In the following sprintf's, don't worry if the trailing 0 + * that sprintf writes goes off the end of the field. It will + * write into the next field, which we will promptly overwrite + * anyway. (So make sure to write the fields in ascending order.) + */ + + len = sprintf(h->file_time, "%lu", om->file_time); + assert(len <= 12); + memset(h->file_time + len, ' ', 12 - len); + + if (om->user_id > 999999) + om->user_id = 0; + len = sprintf(h->user_id, "%u", om->user_id); + assert(len <= 6); + memset(h->user_id + len, ' ', 6 - len); + + len = sprintf(h->group_id, "%u", om->group_id); + assert(len <= 6); + memset(h->group_id + len, ' ', 6 - len); + + len = sprintf(h->file_mode, "%o", om->file_mode); + assert(len <= 8); + memset(h->file_mode + len, ' ', 8 - len); + + len = sprintf(h->file_size, "%u", om->length); + assert(len <= 10); + memset(h->file_size + len, ' ', 10 - len); + + h->trailer[0] = '`'; + h->trailer[1] = '\n'; +} + +void Library::addSymbol(ObjModule *om, char *name, int pickAny) +{ +#if LOG + printf("Library::addSymbol(%s, %s, %d)\n", om->name, name, pickAny); +#endif + StringValue *s = tab.insert(name, strlen(name)); + if (!s) + { // already in table + if (!pickAny) + { s = tab.lookup(name, strlen(name)); + assert(s); + ObjSymbol *os = (ObjSymbol *)s->ptrvalue; + error("multiple definition of %s: %s and %s: %s", + om->name, name, os->om->name, os->name); + } + } + else + { + ObjSymbol *os = new ObjSymbol(); + os->name = strdup(name); + os->om = om; + s->ptrvalue = (void *)os; + + objsymbols.push(os); + } +} + +/************************************ + * Scan single object module for dictionary symbols. + * Send those symbols to Library::addSymbol(). + */ + +void Library::scanObjModule(ObjModule *om) +{ +#if LOG + printf("Library::scanObjModule(%s)\n", om->name); +#endif + unsigned char *buf = (unsigned char *)om->base; + size_t buflen = om->length; + int reason = 0; + + if (buflen < EI_NIDENT + sizeof(Elf32_Hdr)) + { + Lcorrupt: + error("corrupt ELF object module %s %d", om->name, reason); + return; + } + + if (memcmp(buf, elf, 4)) + { reason = 1; + goto Lcorrupt; + } + if (buf[EI_VERSION] != EV_CURRENT) + { + error("ELF object module %s has EI_VERSION = %d, should be %d", om->name, buf[EI_VERSION], EV_CURRENT); + return; + } + if (buf[EI_DATA] != ELFDATA2LSB) + { + error("ELF object module %s is byte swapped and unsupported", om->name); + return; + } + if (buf[EI_CLASS] == ELFCLASS32) + { + Elf32_Hdr *eh = (Elf32_Hdr *)(buf + EI_NIDENT); + if (eh->e_type != ET_REL) + { + error("ELF object module %s is not relocatable", om->name); + return; // not relocatable object module + } + if (eh->e_version != EV_CURRENT) + goto Lcorrupt; + + /* For each Section + */ + for (unsigned u = 0; u < eh->e_shnum; u++) + { Elf32_Shdr *section = (Elf32_Shdr *)(buf + eh->e_shoff + eh->e_shentsize * u); + + if (section->sh_type == SHT_SYMTAB) + { /* sh_link gives the particular string table section + * used for the symbol names. + */ + Elf32_Shdr *string_section = (Elf32_Shdr *)(buf + eh->e_shoff + + eh->e_shentsize * section->sh_link); + if (string_section->sh_type != SHT_STRTAB) + { + reason = 3; + goto Lcorrupt; + } + char *string_tab = (char *)(buf + string_section->sh_offset); + + for (unsigned offset = 0; offset < section->sh_size; offset += sizeof(Elf32_Sym)) + { Elf32_Sym *sym = (Elf32_Sym *)(buf + section->sh_offset + offset); + + if (((sym->st_info >> 4) == STB_GLOBAL || + (sym->st_info >> 4) == STB_WEAK) && + sym->st_shndx != SHT_UNDEF) // not extern + { + char *name = string_tab + sym->st_name; + //printf("sym st_name = x%x\n", sym->st_name); + addSymbol(om, name, 1); + } + } + } + } + } + else if (buf[EI_CLASS] == ELFCLASS64) + { + Elf64_Ehdr *eh = (Elf64_Ehdr *)(buf + EI_NIDENT); + if (buflen < EI_NIDENT + sizeof(Elf64_Ehdr)) + goto Lcorrupt; + if (eh->e_type != ET_REL) + { + error("ELF object module %s is not relocatable", om->name); + return; // not relocatable object module + } + if (eh->e_version != EV_CURRENT) + goto Lcorrupt; + + /* For each Section + */ + for (unsigned u = 0; u < eh->e_shnum; u++) + { Elf64_Shdr *section = (Elf64_Shdr *)(buf + eh->e_shoff + eh->e_shentsize * u); + + if (section->sh_type == SHT_SYMTAB) + { /* sh_link gives the particular string table section + * used for the symbol names. + */ + Elf64_Shdr *string_section = (Elf64_Shdr *)(buf + eh->e_shoff + + eh->e_shentsize * section->sh_link); + if (string_section->sh_type != SHT_STRTAB) + { + reason = 3; + goto Lcorrupt; + } + char *string_tab = (char *)(buf + string_section->sh_offset); + + for (unsigned offset = 0; offset < section->sh_size; offset += sizeof(Elf64_Sym)) + { Elf64_Sym *sym = (Elf64_Sym *)(buf + section->sh_offset + offset); + + if (((sym->st_info >> 4) == STB_GLOBAL || + (sym->st_info >> 4) == STB_WEAK) && + sym->st_shndx != SHT_UNDEF) // not extern + { + char *name = string_tab + sym->st_name; + //printf("sym st_name = x%x\n", sym->st_name); + addSymbol(om, name, 1); + } + } + } + } + } + else + { + error("ELF object module %s is unrecognized class %d", om->name, buf[EI_CLASS]); + return; + } + +#if 0 + /* String table section + */ + Elf32_Shdr *string_section = (Elf32_Shdr *)(buf + eh->e_shoff + + eh->e_shentsize * eh->e_shstrndx); + if (string_section->sh_type != SHT_STRTAB) + { + //printf("buf = %p, e_shentsize = %d, e_shstrndx = %d\n", buf, eh->e_shentsize, eh->e_shstrndx); + //printf("sh_type = %d, SHT_STRTAB = %d\n", string_section->sh_type, SHT_STRTAB); + reason = 2; + goto Lcorrupt; + } + printf("strtab sh_offset = x%x\n", string_section->sh_offset); + char *string_tab = (char *)(buf + string_section->sh_offset); +#endif + +} + +/*************************************** + * Add object module or library to the library. + * Examine the buffer to see which it is. + * If the buffer is NULL, use module_name as the file name + * and load the file. + */ + +void Library::addObject(const char *module_name, void *buf, size_t buflen) +{ + if (!module_name) + module_name = ""; +#if LOG + printf("Library::addObject(%s)\n", module_name); +#endif + int fromfile = 0; + if (!buf) + { assert(module_name[0]); + FileName f((char *)module_name, 0); + File file(&f); + file.readv(); + buf = file.buffer; + buflen = file.len; + file.ref = 1; + fromfile = 1; + } + int reason = 0; + + if (buflen < 16) + { +#if LOG + printf("buf = %p, buflen = %d\n", buf, buflen); +#endif + Lcorrupt: + error("corrupt object module %s %d", module_name, reason); + return; + } + + if (memcmp(buf, "!\n", 8) == 0) + { /* Library file. + * Pull each object module out of the library and add it + * to the object module array. + */ +#if LOG + printf("archive, buf = %p, buflen = %d\n", buf, buflen); +#endif + unsigned offset = 8; + char *symtab = NULL; + unsigned symtab_size = 0; + char *filenametab = NULL; + unsigned filenametab_size = 0; + unsigned mstart = objmodules.dim; + while (offset < buflen) + { + if (offset + sizeof(Header) >= buflen) + { reason = 1; + goto Lcorrupt; + } + Header *header = (Header *)((unsigned char *)buf + offset); + offset += sizeof(Header); + char *endptr = NULL; + unsigned long size = strtoul(header->file_size, &endptr, 10); + if (endptr >= &header->file_size[10] || *endptr != ' ') + { reason = 2; + goto Lcorrupt; + } + if (offset + size > buflen) + { reason = 3; + goto Lcorrupt; + } + + if (header->object_name[0] == '/' && + header->object_name[1] == ' ') + { + /* Instead of rescanning the object modules we pull from a + * library, just use the already created symbol table. + */ + if (symtab) + { reason = 4; + goto Lcorrupt; + } + symtab = (char *)buf + offset; + symtab_size = size; + if (size < 4) + { reason = 5; + goto Lcorrupt; + } + } + else if (header->object_name[0] == '/' && + header->object_name[1] == '/') + { + /* This is the file name table, save it for later. + */ + if (filenametab) + { reason = 6; + goto Lcorrupt; + } + filenametab = (char *)buf + offset; + filenametab_size = size; + } + else + { + ObjModule *om = new ObjModule(); + om->base = (unsigned char *)buf + offset /*- sizeof(Header)*/; + om->length = size; + om->offset = 0; + if (header->object_name[0] == '/') + { /* Pick long name out of file name table + */ + unsigned foff = strtoul(header->object_name + 1, &endptr, 10); + unsigned i; + for (i = 0; 1; i++) + { if (foff + i >= filenametab_size) + { reason = 7; + goto Lcorrupt; + } + char c = filenametab[foff + i]; + if (c == '/') + break; + } + om->name = (char *)malloc(i + 1); + assert(om->name); + memcpy(om->name, filenametab + foff, i); + om->name[i] = 0; + } + else + { /* Pick short name out of header + */ + om->name = (char *)malloc(OBJECT_NAME_SIZE); + assert(om->name); + for (int i = 0; 1; i++) + { if (i == OBJECT_NAME_SIZE) + { reason = 8; + goto Lcorrupt; + } + char c = header->object_name[i]; + if (c == '/') + { om->name[i] = 0; + break; + } + om->name[i] = c; + } + } + om->name_offset = -1; + om->file_time = strtoul(header->file_time, &endptr, 10); + om->user_id = strtoul(header->user_id, &endptr, 10); + om->group_id = strtoul(header->group_id, &endptr, 10); + om->file_mode = strtoul(header->file_mode, &endptr, 8); + om->scan = 0; + objmodules.push(om); + } + offset += (size + 1) & ~1; + } + if (offset != buflen) + { reason = 9; + goto Lcorrupt; + } + + /* Scan the library's symbol table, and insert it into our own. + * We use this instead of rescanning the object module, because + * the library's creator may have a different idea of what symbols + * go into the symbol table than we do. + * This is also probably faster. + */ + unsigned nsymbols = sgetl(symtab); + char *s = symtab + 4 + nsymbols * 4; + if (4 + nsymbols * (4 + 1) > symtab_size) + { reason = 10; + goto Lcorrupt; + } + for (unsigned i = 0; i < nsymbols; i++) + { char *name = s; + s += strlen(name) + 1; + if (s - symtab > symtab_size) + { reason = 11; + goto Lcorrupt; + } + unsigned moff = sgetl(symtab + 4 + i * 4); +//printf("symtab[%d] moff = %x %x, name = %s\n", i, moff, moff + sizeof(Header), name); + for (unsigned m = mstart; 1; m++) + { if (m == objmodules.dim) + { reason = 12; + goto Lcorrupt; // didn't find it + } + ObjModule *om = objmodules.tdata()[m]; +//printf("\t%x\n", (char *)om->base - (char *)buf); + if (moff + sizeof(Header) == (char *)om->base - (char *)buf) + { + addSymbol(om, name, 1); +// if (mstart == m) +// mstart++; + break; + } + } + } + + return; + } + + if (memcmp(buf, elf, 4) != 0) + { reason = 13; + goto Lcorrupt; + } + + /* It's an ELF object module + */ + ObjModule *om = new ObjModule(); + om->base = (unsigned char *)buf; + om->length = buflen; + om->offset = 0; + om->name = FileName::name(module_name); // remove path, but not extension + om->name_offset = -1; + om->scan = 1; + if (fromfile) + { struct stat statbuf; + int i = stat(module_name, &statbuf); + if (i == -1) // error, errno is set + { reason = 14; + goto Lcorrupt; + } + om->file_time = statbuf.st_ctime; + om->user_id = statbuf.st_uid; + om->group_id = statbuf.st_gid; + om->file_mode = statbuf.st_mode; + } + else + { /* Mock things up for the object module file that never was + * actually written out. + */ + static uid_t uid; + static gid_t gid; + static int init; + if (!init) + { init = 1; + uid = getuid(); + gid = getgid(); + } + time(&om->file_time); + om->user_id = uid; + om->group_id = gid; + om->file_mode = 0100640; + } + objmodules.push(om); +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +/********************************************** + * Create and write library to libbuf. + * The library consists of: + * !\n + * header + * dictionary + * object modules... + */ + +void Library::WriteLibToBuffer(OutBuffer *libbuf) +{ +#if LOG + printf("Library::WriteLibToBuffer()\n"); +#endif + + /************* Scan Object Modules for Symbols ******************/ + + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + if (om->scan) + { + scanObjModule(om); + } + } + + /************* Determine string section ******************/ + + /* The string section is where we store long file names. + */ + unsigned noffset = 0; + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + size_t len = strlen(om->name); + if (len >= OBJECT_NAME_SIZE) + { + om->name_offset = noffset; + noffset += len + 2; + } + else + om->name_offset = -1; + } + +#if LOG + printf("\tnoffset = x%x\n", noffset); +#endif + + /************* Determine module offsets ******************/ + + unsigned moffset = 8 + sizeof(Header) + 4; + + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + moffset += 4 + strlen(os->name) + 1; + } + unsigned hoffset = moffset; + +#if LOG + printf("\tmoffset = x%x\n", moffset); +#endif + + moffset += moffset & 1; + if (noffset) + moffset += sizeof(Header) + noffset; + + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + moffset += moffset & 1; + om->offset = moffset; + moffset += sizeof(Header) + om->length; + } + + libbuf->reserve(moffset); + + /************* Write the library ******************/ + libbuf->write("!\n", 8); + + ObjModule om; + om.name_offset = -1; + om.base = NULL; + om.length = hoffset - (8 + sizeof(Header)); + om.offset = 8; + om.name = (char*)""; + ::time(&om.file_time); + om.user_id = 0; + om.group_id = 0; + om.file_mode = 0; + + Header h; + OmToHeader(&h, &om); + libbuf->write(&h, sizeof(h)); + char buf[4]; + sputl(objsymbols.dim, buf); + libbuf->write(buf, 4); + + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + sputl(os->om->offset, buf); + libbuf->write(buf, 4); + } + + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + libbuf->writestring(os->name); + libbuf->writeByte(0); + } + +#if LOG + printf("\tlibbuf->moffset = x%x\n", libbuf->offset); +#endif + + /* Write out the string section + */ + if (noffset) + { + if (libbuf->offset & 1) + libbuf->writeByte('\n'); + + // header + memset(&h, ' ', sizeof(Header)); + h.object_name[0] = '/'; + h.object_name[1] = '/'; + size_t len = sprintf(h.file_size, "%u", noffset); + assert(len < 10); + h.file_size[len] = ' '; + h.trailer[0] = '`'; + h.trailer[1] = '\n'; + libbuf->write(&h, sizeof(h)); + + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + if (om->name_offset >= 0) + { libbuf->writestring(om->name); + libbuf->writeByte('/'); + libbuf->writeByte('\n'); + } + } + } + + /* Write out each of the object modules + */ + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + if (libbuf->offset & 1) + libbuf->writeByte('\n'); // module alignment + + assert(libbuf->offset == om->offset); + + OmToHeader(&h, om); + libbuf->write(&h, sizeof(h)); // module header + + libbuf->write(om->base, om->length); // module contents + } + +#if LOG + printf("moffset = x%x, libbuf->offset = x%x\n", moffset, libbuf->offset); +#endif + assert(libbuf->offset == moffset); +} diff --git a/libmach.c b/libmach.c new file mode 100644 index 00000000..8748a312 --- /dev/null +++ b/libmach.c @@ -0,0 +1,798 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* Implements object library reading and writing in the Mach-O object + * module format. While the format is + * equivalent to the Linux arch format, it differs in many details. + * This format is described in the Apple document + * "Mac OS X ABI Mach-O File Format Reference" dated 2007-04-26 + * in the section "Static Archive Libraries". + * That specification is only about half complete and has numerous + * errors, so use the source code here as a better guide. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "mach.h" + +#include "rmem.h" +#include "root.h" +#include "stringtable.h" + +#include "mars.h" +#include "lib.h" + +#define LOG 0 + +Library::Library() +{ + libfile = NULL; + tab.init(); +} + +/*********************************** + * Set the library file name based on the output directory + * and the filename. + * Add default library file name extension. + */ + +void Library::setFilename(char *dir, char *filename) +{ +#if LOG + printf("Library::setFilename(dir = '%s', filename = '%s')\n", + dir ? dir : "", filename ? filename : ""); +#endif + char *arg = filename; + if (!arg || !*arg) + { // Generate lib file name from first obj name + char *n = global.params.objfiles->tdata()[0]; + + n = FileName::name(n); + FileName *fn = FileName::forceExt(n, global.lib_ext); + arg = fn->toChars(); + } + if (!FileName::absolute(arg)) + arg = FileName::combine(dir, arg); + FileName *libfilename = FileName::defaultExt(arg, global.lib_ext); + + libfile = new File(libfilename); +} + +void Library::write() +{ + if (global.params.verbose) + printf("library %s\n", libfile->name->toChars()); + + OutBuffer libbuf; + WriteLibToBuffer(&libbuf); + + // Transfer image to file + libfile->setbuffer(libbuf.data, libbuf.offset); + libbuf.extractData(); + + + char *p = FileName::path(libfile->name->toChars()); + FileName::ensurePathExists(p); + //mem.free(p); + + libfile->writev(); +} + +/*****************************************************************************/ + +void Library::addLibrary(void *buf, size_t buflen) +{ + addObject(NULL, buf, buflen); +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +static uint32_t mach_signature = MH_MAGIC; // Mach-O file signature for 32 bit files +static uint32_t mach_signature64 = MH_MAGIC_64; // Mach-O file signature for 64 bit files + +void sputl(int value, void* buffer) +{ + unsigned char *p = (unsigned char*)buffer; + p[3] = (unsigned char)(value >> 24); + p[2] = (unsigned char)(value >> 16); + p[1] = (unsigned char)(value >> 8); + p[0] = (unsigned char)(value); +} + +int sgetl(void* buffer) +{ + unsigned char *p = (unsigned char*)buffer; + return (((((p[3] << 8) | p[2]) << 8) | p[1]) << 8) | p[0]; +} + + +struct ObjModule +{ + unsigned char *base; // where are we holding it in memory + unsigned length; // in bytes + unsigned offset; // offset from start of library + char *name; // module name (file name) + long file_time; // file time + unsigned user_id; + unsigned group_id; + unsigned file_mode; + int scan; // 1 means scan for symbols +}; + +struct Header +{ + #define OBJECT_NAME_SIZE 16 + char object_name[OBJECT_NAME_SIZE]; + char file_time[12]; + char user_id[6]; + char group_id[6]; + char file_mode[8]; // in octal + char file_size[10]; + char trailer[2]; +}; + +void OmToHeader(Header *h, ObjModule *om) +{ + size_t slen = strlen(om->name); + int nzeros = 8 - ((slen + 4) & 7); + if (nzeros < 4) + nzeros += 8; // emulate mysterious behavior of ar + + size_t len = sprintf(h->object_name, "#1/%ld", slen + nzeros); + memset(h->object_name + len, ' ', OBJECT_NAME_SIZE - len); + + /* In the following sprintf's, don't worry if the trailing 0 + * that sprintf writes goes off the end of the field. It will + * write into the next field, which we will promptly overwrite + * anyway. (So make sure to write the fields in ascending order.) + */ + + len = sprintf(h->file_time, "%lu", om->file_time); + assert(len <= 12); + memset(h->file_time + len, ' ', 12 - len); + + if (om->user_id > 999999) // yes, it happens + om->user_id = 0; // don't really know what to do here + len = sprintf(h->user_id, "%u", om->user_id); + assert(len <= 6); + memset(h->user_id + len, ' ', 6 - len); + + if (om->group_id > 999999) // yes, it happens + om->group_id = 0; // don't really know what to do here + len = sprintf(h->group_id, "%u", om->group_id); + assert(len <= 6); + memset(h->group_id + len, ' ', 6 - len); + + len = sprintf(h->file_mode, "%o", om->file_mode); + assert(len <= 8); + memset(h->file_mode + len, ' ', 8 - len); + + int filesize = om->length; + filesize = (filesize + 7) & ~7; + len = sprintf(h->file_size, "%lu", slen + nzeros + filesize); + assert(len <= 10); + memset(h->file_size + len, ' ', 10 - len); + + h->trailer[0] = '`'; + h->trailer[1] = '\n'; +} + +void Library::addSymbol(ObjModule *om, char *name, int pickAny) +{ +#if LOG + printf("Library::addSymbol(%s, %s, %d)\n", om->name, name, pickAny); +#endif +#if 0 // let linker sort out duplicates + StringValue *s = tab.insert(name, strlen(name)); + if (!s) + { // already in table + if (!pickAny) + { s = tab.lookup(name, strlen(name)); + assert(s); + ObjSymbol *os = (ObjSymbol *)s->ptrvalue; + error("multiple definition of %s: %s and %s: %s", + om->name, name, os->om->name, os->name); + } + } + else + { + ObjSymbol *os = new ObjSymbol(); + os->name = strdup(name); + os->om = om; + s->ptrvalue = (void *)os; + + objsymbols.push(os); + } +#else + ObjSymbol *os = new ObjSymbol(); + os->name = strdup(name); + os->om = om; + objsymbols.push(os); +#endif +} + +/************************************ + * Scan single object module for dictionary symbols. + * Send those symbols to Library::addSymbol(). + */ + +void Library::scanObjModule(ObjModule *om) +{ +#if LOG + printf("Library::scanObjModule(%s)\n", om->name); +#endif + unsigned char *buf = (unsigned char *)om->base; + size_t buflen = om->length; + int reason = 0; + uint32_t ncmds; + + struct mach_header *header = (struct mach_header *)buf; + struct mach_header_64 *header64 = NULL; + + /* First do sanity checks on object file + */ + if (buflen < sizeof(struct mach_header)) + { + Lcorrupt: + error("Mach-O object module %s corrupt, %d", om->name, reason); + return; + } + if (header->magic == MH_MAGIC) + { + if (header->cputype != CPU_TYPE_I386) + { + error("Mach-O object module %s has cputype = %d, should be %d", + om->name, header->cputype, CPU_TYPE_I386); + return; + } + if (header->filetype != MH_OBJECT) + { + error("Mach-O object module %s has file type = %d, should be %d", + om->name, header->filetype, MH_OBJECT); + return; + } + if (buflen < sizeof(struct mach_header) + header->sizeofcmds) + { reason = 2; + goto Lcorrupt; + } + ncmds = header->ncmds; + } + else if (header->magic == MH_MAGIC_64) + { + header64 = (struct mach_header_64 *)buf; + if (buflen < sizeof(struct mach_header_64)) + goto Lcorrupt; + if (header64->cputype != CPU_TYPE_X86_64) + { + error("Mach-O object module %s has cputype = %d, should be %d", + om->name, header64->cputype, CPU_TYPE_X86_64); + return; + } + if (header64->filetype != MH_OBJECT) + { + error("Mach-O object module %s has file type = %d, should be %d", + om->name, header64->filetype, MH_OBJECT); + return; + } + if (buflen < sizeof(struct mach_header_64) + header64->sizeofcmds) + { reason = 2; + goto Lcorrupt; + } + ncmds = header64->ncmds; + } + else + { reason = 1; + goto Lcorrupt; + } + + struct segment_command *segment_commands = NULL; + struct segment_command_64 *segment_commands64 = NULL; + struct symtab_command *symtab_commands = NULL; + struct dysymtab_command *dysymtab_commands = NULL; + + // Commands immediately follow mach_header + char *commands = (char *)buf + + (header->magic == MH_MAGIC_64 + ? sizeof(struct mach_header_64) + : sizeof(struct mach_header)); + for (uint32_t i = 0; i < ncmds; i++) + { struct load_command *command = (struct load_command *)commands; + //printf("cmd = 0x%02x, cmdsize = %u\n", command->cmd, command->cmdsize); + switch (command->cmd) + { + case LC_SEGMENT: + segment_commands = (struct segment_command *)command; + break; + case LC_SEGMENT_64: + segment_commands64 = (struct segment_command_64 *)command; + break; + case LC_SYMTAB: + symtab_commands = (struct symtab_command *)command; + break; + case LC_DYSYMTAB: + dysymtab_commands = (struct dysymtab_command *)command; + break; + } + commands += command->cmdsize; + } + + if (symtab_commands) + { + // Get pointer to string table + char *strtab = (char *)buf + symtab_commands->stroff; + if (buflen < symtab_commands->stroff + symtab_commands->strsize) + { reason = 3; + goto Lcorrupt; + } + + if (header->magic == MH_MAGIC_64) + { + // Get pointer to symbol table + struct nlist_64 *symtab = (struct nlist_64 *)((char *)buf + symtab_commands->symoff); + if (buflen < symtab_commands->symoff + symtab_commands->nsyms * sizeof(struct nlist_64)) + { reason = 4; + goto Lcorrupt; + } + + // For each symbol + for (int i = 0; i < symtab_commands->nsyms; i++) + { struct nlist_64 *s = symtab + i; + char *name = strtab + s->n_un.n_strx; + + if (s->n_type & N_STAB) + // values in /usr/include/mach-o/stab.h + ; //printf(" N_STAB"); + else + { + if (s->n_type & N_PEXT) + ; + if (s->n_type & N_EXT) + ; + switch (s->n_type & N_TYPE) + { + case N_UNDF: + break; + case N_ABS: + break; + case N_SECT: + if (s->n_type & N_EXT /*&& !(s->n_desc & N_REF_TO_WEAK)*/) + addSymbol(om, name, 1); + break; + case N_PBUD: + break; + case N_INDR: + break; + } + } + } + } + else + { + // Get pointer to symbol table + struct nlist *symtab = (struct nlist *)((char *)buf + symtab_commands->symoff); + if (buflen < symtab_commands->symoff + symtab_commands->nsyms * sizeof(struct nlist)) + { reason = 4; + goto Lcorrupt; + } + + // For each symbol + for (int i = 0; i < symtab_commands->nsyms; i++) + { struct nlist *s = symtab + i; + char *name = strtab + s->n_un.n_strx; + + if (s->n_type & N_STAB) + // values in /usr/include/mach-o/stab.h + ; //printf(" N_STAB"); + else + { + if (s->n_type & N_PEXT) + ; + if (s->n_type & N_EXT) + ; + switch (s->n_type & N_TYPE) + { + case N_UNDF: + break; + case N_ABS: + break; + case N_SECT: + if (s->n_type & N_EXT /*&& !(s->n_desc & N_REF_TO_WEAK)*/) + addSymbol(om, name, 1); + break; + case N_PBUD: + break; + case N_INDR: + break; + } + } + } + } + } +} + +/*************************************** + * Add object module or library to the library. + * Examine the buffer to see which it is. + * If the buffer is NULL, use module_name as the file name + * and load the file. + */ + +void Library::addObject(const char *module_name, void *buf, size_t buflen) +{ + if (!module_name) + module_name = ""; +#if LOG + printf("Library::addObject(%s)\n", module_name); +#endif + int fromfile = 0; + if (!buf) + { assert(module_name[0]); + FileName f((char *)module_name, 0); + File file(&f); + file.readv(); + buf = file.buffer; + buflen = file.len; + file.ref = 1; + fromfile = 1; + } + int reason = 0; + + if (buflen < 16) + { +#if LOG + printf("buf = %p, buflen = %d\n", buf, buflen); +#endif + Lcorrupt: + error("corrupt object module %s %d", module_name, reason); + return; + } + + if (memcmp(buf, "!\n", 8) == 0) + { /* Library file. + * Pull each object module out of the library and add it + * to the object module array. + */ +#if LOG + printf("archive, buf = %p, buflen = %d\n", buf, buflen); +#endif + unsigned offset = 8; + char *symtab = NULL; + unsigned symtab_size = 0; + char *filenametab = NULL; + unsigned filenametab_size = 0; + unsigned mstart = objmodules.dim; + while (offset < buflen) + { + if (offset + sizeof(Header) >= buflen) + { reason = 1; + goto Lcorrupt; + } + Header *header = (Header *)((unsigned char *)buf + offset); + offset += sizeof(Header); + char *endptr = NULL; + unsigned long size = strtoul(header->file_size, &endptr, 10); + if (endptr >= &header->file_size[10] || *endptr != ' ') + { reason = 2; + goto Lcorrupt; + } + if (offset + size > buflen) + { reason = 3; + goto Lcorrupt; + } + + if (memcmp(header->object_name, "__.SYMDEF ", 16) == 0 || + memcmp(header->object_name, "__.SYMDEF SORTED", 16) == 0) + { + /* Instead of rescanning the object modules we pull from a + * library, just use the already created symbol table. + */ + if (symtab) + { reason = 4; + goto Lcorrupt; + } + symtab = (char *)buf + offset; + symtab_size = size; + if (size < 4) + { reason = 5; + goto Lcorrupt; + } + } + else + { + ObjModule *om = new ObjModule(); + om->base = (unsigned char *)buf + offset - sizeof(Header); + om->length = size + sizeof(Header); + om->offset = 0; + om->name = (char *)(om->base + sizeof(Header)); + om->file_time = strtoul(header->file_time, &endptr, 10); + om->user_id = strtoul(header->user_id, &endptr, 10); + om->group_id = strtoul(header->group_id, &endptr, 10); + om->file_mode = strtoul(header->file_mode, &endptr, 8); + om->scan = 0; + objmodules.push(om); + } + offset += (size + 1) & ~1; + } + if (offset != buflen) + { reason = 9; + goto Lcorrupt; + } + + /* Scan the library's symbol table, and insert it into our own. + * We use this instead of rescanning the object module, because + * the library's creator may have a different idea of what symbols + * go into the symbol table than we do. + * This is also probably faster. + */ + unsigned nsymbols = sgetl(symtab) / 8; + char *s = symtab + 4 + nsymbols * 8 + 4; + if (4 + nsymbols * 8 + 4 > symtab_size) + { reason = 10; + goto Lcorrupt; + } + for (unsigned i = 0; i < nsymbols; i++) + { + unsigned soff = sgetl(symtab + 4 + i * 8); + char *name = s + soff; + //printf("soff = x%x name = %s\n", soff, name); + if (s + strlen(name) + 1 - symtab > symtab_size) + { reason = 11; + goto Lcorrupt; + } + unsigned moff = sgetl(symtab + 4 + i * 8 + 4); + //printf("symtab[%d] moff = x%x x%x, name = %s\n", i, moff, moff + sizeof(Header), name); + for (unsigned m = mstart; 1; m++) + { if (m == objmodules.dim) + { reason = 12; + goto Lcorrupt; // didn't find it + } + ObjModule *om = objmodules.tdata()[m]; + //printf("\tom offset = x%x\n", (char *)om->base - (char *)buf); + if (moff == (char *)om->base - (char *)buf) + { + addSymbol(om, name, 1); +// if (mstart == m) +// mstart++; + break; + } + } + } + + return; + } + + if (memcmp(buf, &mach_signature, sizeof(mach_signature)) != 0 && + memcmp(buf, &mach_signature64, sizeof(mach_signature64)) != 0) + { reason = 13; + goto Lcorrupt; + } + + /* It's a Mach-O object module + */ + ObjModule *om = new ObjModule(); + om->base = (unsigned char *)buf; + om->length = buflen; + om->offset = 0; + om->name = FileName::name(module_name); // remove path, but not extension + om->scan = 1; + if (fromfile) + { struct stat statbuf; + int i = stat(module_name, &statbuf); + if (i == -1) // error, errno is set + { reason = 14; + goto Lcorrupt; + } + om->file_time = statbuf.st_ctime; + om->user_id = statbuf.st_uid; + om->group_id = statbuf.st_gid; + om->file_mode = statbuf.st_mode; + } + else + { /* Mock things up for the object module file that never was + * actually written out. + */ + static uid_t uid; + static gid_t gid; + static int init; + if (!init) + { init = 1; + uid = getuid(); + gid = getgid(); + } + time(&om->file_time); + om->user_id = uid; + om->group_id = gid; + om->file_mode = 0100644; + } + objmodules.push(om); +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +/********************************************** + * Create and write library to libbuf. + * The library consists of: + * !\n + * header + * dictionary + * object modules... + */ + +void Library::WriteLibToBuffer(OutBuffer *libbuf) +{ +#if LOG + printf("Library::WriteLibToBuffer()\n"); +#endif + static char pad[7] = { 0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A, }; + + /************* Scan Object Modules for Symbols ******************/ + + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + if (om->scan) + { + scanObjModule(om); + } + } + + /************* Determine module offsets ******************/ + + unsigned moffset = 8 + sizeof(Header) + 4 + 4; + + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + moffset += 8 + strlen(os->name) + 1; + } + moffset = (moffset + 3) & ~3; +// if (moffset & 4) +// moffset += 4; + unsigned hoffset = moffset; + +#if LOG + printf("\tmoffset = x%x\n", moffset); +#endif + + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + moffset += moffset & 1; + om->offset = moffset; + if (om->scan) + { + size_t slen = strlen(om->name); + int nzeros = 8 - ((slen + 4) & 7); + if (nzeros < 4) + nzeros += 8; // emulate mysterious behavior of ar + int filesize = om->length; + filesize = (filesize + 7) & ~7; + moffset += sizeof(Header) + slen + nzeros + filesize; + } + else + { + moffset += om->length; + } + } + + libbuf->reserve(moffset); + + /************* Write the library ******************/ + libbuf->write("!\n", 8); + + ObjModule om; + om.base = NULL; + om.length = hoffset - (8 + sizeof(Header)); + om.offset = 8; + om.name = (char*)""; + ::time(&om.file_time); + om.user_id = getuid(); + om.group_id = getgid(); + om.file_mode = 0100644; + + Header h; + OmToHeader(&h, &om); + memcpy(h.object_name, "__.SYMDEF", 9); + int len = sprintf(h.file_size, "%u", om.length); + assert(len <= 10); + memset(h.file_size + len, ' ', 10 - len); + + libbuf->write(&h, sizeof(h)); + + char buf[4]; + + sputl(objsymbols.dim * 8, buf); + libbuf->write(buf, 4); + + int stringoff = 0; + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + sputl(stringoff, buf); + libbuf->write(buf, 4); + + sputl(os->om->offset, buf); + libbuf->write(buf, 4); + + stringoff += strlen(os->name) + 1; + } + + sputl(stringoff, buf); + libbuf->write(buf, 4); + + for (int i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + libbuf->writestring(os->name); + libbuf->writeByte(0); + } + while (libbuf->offset & 3) + libbuf->writeByte(0); + +// if (libbuf->offset & 4) +// libbuf->write(pad, 4); + +#if LOG + printf("\tlibbuf->moffset = x%x\n", libbuf->offset); +#endif + assert(libbuf->offset == hoffset); + + /* Write out each of the object modules + */ + for (int i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + if (libbuf->offset & 1) + libbuf->writeByte('\n'); // module alignment + + assert(libbuf->offset == om->offset); + + if (om->scan) + { + OmToHeader(&h, om); + libbuf->write(&h, sizeof(h)); // module header + + size_t len = strlen(om->name); + libbuf->write(om->name, len); + + int nzeros = 8 - ((len + 4) & 7); + if (nzeros < 4) + nzeros += 8; // emulate mysterious behavior of ar + libbuf->fill0(nzeros); + + libbuf->write(om->base, om->length); // module contents + + // obj modules are padded out to 8 bytes in length with 0x0A + int filealign = om->length & 7; + if (filealign) + { + libbuf->write(pad, 8 - filealign); + } + } + else + { + libbuf->write(om->base, om->length); // module contents + } + } + +#if LOG + printf("moffset = x%x, libbuf->offset = x%x\n", moffset, libbuf->offset); +#endif + assert(libbuf->offset == moffset); +} diff --git a/libomf.c b/libomf.c new file mode 100644 index 00000000..b3703c6a --- /dev/null +++ b/libomf.c @@ -0,0 +1,959 @@ + +/* + * Copyright (c) 1986-1995 by Symantec + * Copyright (c) 2000-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * Written by Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Compiler implementation of the D programming language + +#include +#include +#include + +#include "rmem.h" +#include "root.h" +#include "stringtable.h" + +#include "mars.h" +#include "lib.h" + +#define LOG 0 + +Library::Library() +{ + libfile = NULL; + tab.init(); +} + +/*********************************** + * Set the library file name based on the output directory + * and the filename. + * Add default library file name extension. + */ + +void Library::setFilename(char *dir, char *filename) +{ + char *arg = filename; + if (!arg || !*arg) + { // Generate lib file name from first obj name + char *n = global.params.objfiles->tdata()[0]; + + n = FileName::name(n); + FileName *fn = FileName::forceExt(n, global.lib_ext); + arg = fn->toChars(); + } + if (!FileName::absolute(arg)) + arg = FileName::combine(dir, arg); + FileName *libfilename = FileName::defaultExt(arg, global.lib_ext); + + libfile = new File(libfilename); +} + +void Library::write() +{ + if (global.params.verbose) + printf("library %s\n", libfile->name->toChars()); + + OutBuffer libbuf; + WriteLibToBuffer(&libbuf); + + // Transfer image to file + libfile->setbuffer(libbuf.data, libbuf.offset); + libbuf.extractData(); + + + char *p = FileName::path(libfile->name->toChars()); + FileName::ensurePathExists(p); + //mem.free(p); + + libfile->writev(); +} + +/*****************************************************************************/ + +void Library::addLibrary(void *buf, size_t buflen) +{ + addObject(NULL, buf, buflen); +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +/************************** + * Record types: + */ + +#define RHEADR 0x6E +#define REGINT 0x70 +#define REDATA 0x72 +#define RIDATA 0x74 +#define OVLDEF 0x76 +#define ENDREC 0x78 +#define BLKDEF 0x7A +#define BLKEND 0x7C +#define DEBSYM 0x7E +#define THEADR 0x80 +#define LHEADR 0x82 +#define PEDATA 0x84 +#define PIDATA 0x86 +#define COMENT 0x88 +#define MODEND 0x8A +#define M386END 0x8B /* 32 bit module end record */ +#define EXTDEF 0x8C +#define TYPDEF 0x8E +#define PUBDEF 0x90 +#define PUB386 0x91 +#define LOCSYM 0x92 +#define LINNUM 0x94 +#define LNAMES 0x96 +#define SEGDEF 0x98 +#define GRPDEF 0x9A +#define FIXUPP 0x9C +/*#define (none) 0x9E */ +#define LEDATA 0xA0 +#define LIDATA 0xA2 +#define LIBHED 0xA4 +#define LIBNAM 0xA6 +#define LIBLOC 0xA8 +#define LIBDIC 0xAA +#define COMDEF 0xB0 +#define LEXTDEF 0xB4 +#define LPUBDEF 0xB6 +#define LCOMDEF 0xB8 +#define CEXTDEF 0xBC +#define COMDAT 0xC2 +#define LINSYM 0xC4 +#define ALIAS 0xC6 +#define LLNAMES 0xCA + + +#define LIBIDMAX (512 - 0x25 - 3 - 4) // max size that will fit in dictionary + + +struct ObjModule +{ + unsigned char *base; // where are we holding it in memory + unsigned length; // in bytes + unsigned short page; // page module starts in output file + unsigned char flags; +#define MFgentheadr 1 // generate THEADR record +#define MFtheadr 2 // module name comes from THEADR record + char *name; // module name +}; + +static void parseName(unsigned char **pp, char *name) +{ + unsigned char *p = *pp; + unsigned len = *p++; + if (len == 0xFF && *p == 0) // if long name + { + len = p[1] & 0xFF; + len |= (unsigned)p[2] << 8; + p += 3; + assert(len <= LIBIDMAX); + } + memcpy(name, p, len); + name[len] = 0; + *pp = p + len; +} + +static unsigned short parseIdx(unsigned char **pp) +{ + unsigned char *p = *pp; + unsigned char c = *p++; + + unsigned short idx = (0x80 & c) ? ((0x7F & c) << 8) + *p++ : c; + *pp = p; + return idx; +} + +void Library::addSymbol(ObjModule *om, char *name, int pickAny) +{ +#if LOG + printf("Library::addSymbol(%s, %s, %d)\n", om->name, name, pickAny); +#endif + StringValue *s = tab.insert(name, strlen(name)); + if (!s) + { // already in table + if (!pickAny) + { s = tab.lookup(name, strlen(name)); + assert(s); + ObjSymbol *os = (ObjSymbol *)s->ptrvalue; + error("multiple definition of %s: %s and %s: %s", + om->name, name, os->om->name, os->name); + } + } + else + { + ObjSymbol *os = new ObjSymbol(); + os->name = strdup(name); + os->om = om; + s->ptrvalue = (void *)os; + + objsymbols.push(os); + } +} + +/************************************ + * Scan single object module for dictionary symbols. + * Send those symbols to Library::addSymbol(). + */ + +void Library::scanObjModule(ObjModule *om) +{ int easyomf; + unsigned u; + unsigned char result = 0; + char name[LIBIDMAX + 1]; + + Strings names; + names.push(NULL); // don't use index 0 + + assert(om); + easyomf = 0; // assume not EASY-OMF + unsigned char *pend = om->base + om->length; + + unsigned char *pnext; + for (unsigned char *p = om->base; 1; p = pnext) + { + assert(p < pend); + unsigned char recTyp = *p++; + unsigned short recLen = *(unsigned short *)p; + p += 2; + pnext = p + recLen; + recLen--; // forget the checksum + + switch (recTyp) + { + case LNAMES: + case LLNAMES: + while (p + 1 < pnext) + { + parseName(&p, name); + names.push(strdup(name)); + } + break; + + case PUBDEF: + if (easyomf) + recTyp = PUB386; // convert to MS format + case PUB386: + if (!(parseIdx(&p) | parseIdx(&p))) + p += 2; // skip seg, grp, frame + while (p + 1 < pnext) + { + parseName(&p, name); + p += (recTyp == PUBDEF) ? 2 : 4; // skip offset + parseIdx(&p); // skip type index + addSymbol(om, name); + } + break; + + case COMDAT: + if (easyomf) + recTyp = COMDAT+1; // convert to MS format + case COMDAT+1: + int pickAny = 0; + + if (*p++ & 5) // if continuation or local comdat + break; + + unsigned char attr = *p++; + if (attr & 0xF0) // attr: if multiple instances allowed + pickAny = 1; + p++; // align + + p += 2; // enum data offset + if (recTyp == COMDAT+1) + p += 2; // enum data offset + + parseIdx(&p); // type index + + if ((attr & 0x0F) == 0) // if explicit allocation + { parseIdx(&p); // base group + parseIdx(&p); // base segment + } + + unsigned idx = parseIdx(&p); // public name index + if( idx == 0 || idx >= names.dim) + { + //debug(printf("[s] name idx=%d, uCntNames=%d\n", idx, uCntNames)); + error("corrupt COMDAT"); + return; + } + + //printf("[s] name='%s'\n",name); + addSymbol(om, names.tdata()[idx],pickAny); + break; + + case ALIAS: + while (p + 1 < pnext) + { + parseName(&p, name); + addSymbol(om, name); + parseName(&p, name); + } + break; + + case MODEND: + case M386END: + result = 1; + goto Ret; + + case COMENT: + // Recognize Phar Lap EASY-OMF format + { static unsigned char omfstr[7] = + {0x80,0xAA,'8','0','3','8','6'}; + + if (recLen == sizeof(omfstr)) + { + for (unsigned i = 0; i < sizeof(omfstr); i++) + if (*p++ != omfstr[i]) + goto L1; + easyomf = 1; + break; + L1: ; + } + } + // Recognize .IMPDEF Import Definition Records + { static unsigned char omfstr[] = + {0,0xA0,1}; + + if (recLen >= 7) + { + p++; + for (unsigned i = 1; i < sizeof(omfstr); i++) + if (*p++ != omfstr[i]) + goto L2; + p++; // skip OrdFlag field + parseName(&p, name); + addSymbol(om, name); + break; + L2: ; + } + } + break; + + default: + // ignore + ; + } + } +Ret: + for (u = 1; u < names.dim; u++) + free(names.tdata()[u]); +} + +/*************************************** + * Add object module or library to the library. + * Examine the buffer to see which it is. + * If the buffer is NULL, use module_name as the file name + * and load the file. + */ + +void Library::addObject(const char *module_name, void *buf, size_t buflen) +{ +#if LOG + printf("Library::addObject(%s)\n", module_name ? module_name : ""); +#endif + if (!buf) + { assert(module_name); + FileName f((char *)module_name, 0); + File file(&f); + file.readv(); + buf = file.buffer; + buflen = file.len; + file.ref = 1; + } + + unsigned g_page_size; + unsigned char *pstart = (unsigned char *)buf; + int islibrary = 0; + + /* See if it's an OMF library. + * Don't go by file extension. + */ + + #pragma pack(1) + struct LibHeader + { + unsigned char recTyp; // 0xF0 + unsigned short pagesize; + unsigned long lSymSeek; + unsigned short ndicpages; + unsigned char flags; + }; + #pragma pack() + + /* Determine if it is an OMF library, an OMF object module, + * or something else. + */ + if (buflen < sizeof(LibHeader)) + { + Lcorrupt: + error("corrupt object module"); + } + LibHeader *lh = (LibHeader *)buf; + if (lh->recTyp == 0xF0) + { /* OMF library + * The modules are all at buf[g_page_size .. lh->lSymSeek] + */ + islibrary = 1; + g_page_size = lh->pagesize + 3; + buf = (void *)(pstart + g_page_size); + if (lh->lSymSeek > buflen || + g_page_size > buflen) + goto Lcorrupt; + buflen = lh->lSymSeek - g_page_size; + } + else if (lh->recTyp == '!' && memcmp(lh, "!\n", 8) == 0) + { + error("COFF libraries not supported"); + return; + } + else + { // Not a library, assume OMF object module + g_page_size = 16; + } + + /* Split up the buffer buf[0..buflen] into multiple object modules, + * each aligned on a g_page_size boundary. + */ + + ObjModule *om = NULL; + int first_module = 1; + + unsigned char *p = (unsigned char *)buf; + unsigned char *pend = p + buflen; + unsigned char *pnext; + for (; p < pend; p = pnext) // for each OMF record + { + if (p + 3 >= pend) + goto Lcorrupt; + unsigned char recTyp = *p; + unsigned short recLen = *(unsigned short *)(p + 1); + pnext = p + 3 + recLen; + if (pnext > pend) + goto Lcorrupt; + recLen--; /* forget the checksum */ + + switch (recTyp) + { + case LHEADR : + case THEADR : + if (!om) + { char name[LIBIDMAX + 1]; + om = new ObjModule(); + om->flags = 0; + om->base = p; + p += 3; + parseName(&p, name); + if (first_module && module_name && !islibrary) + { // Remove path and extension + om->name = strdup(FileName::name(module_name)); + char *ext = FileName::ext(om->name); + if (ext) + ext[-1] = 0; + } + else + { /* Use THEADR name as module name, + * removing path and extension. + */ + om->name = strdup(FileName::name(name)); + char *ext = FileName::ext(om->name); + if (ext) + ext[-1] = 0; + + om->flags |= MFtheadr; + } + if (strcmp(name, "C") == 0) // old C compilers did this + { om->flags |= MFgentheadr; // generate our own THEADR + om->base = pnext; // skip past THEADR + } + objmodules.push(om); + first_module = 0; + } + break; + + case MODEND : + case M386END: + if (om) + { om->page = (om->base - pstart) / g_page_size; + om->length = pnext - om->base; + om = NULL; + } + // Round up to next page + unsigned t = pnext - pstart; + t = (t + g_page_size - 1) & ~(unsigned)(g_page_size - 1); + pnext = pstart + t; + break; + + default: + // ignore + ; + } + } + + if (om) + goto Lcorrupt; // missing MODEND record +} + + +/*****************************************************************************/ +/*****************************************************************************/ + +typedef int (__cdecl * cmpfunc_t)(const void *,const void *); + +extern "C" int NameCompare(ObjSymbol **p1, ObjSymbol **p2) +{ + return strcmp((*p1)->name, (*p2)->name); +} + +#define HASHMOD 0x25 +#define BUCKETPAGE 512 +#define BUCKETSIZE (BUCKETPAGE - HASHMOD - 1) + + +/*********************************** + * Calculates number of pages needed for dictionary + * Returns: + * number of pages + */ + +unsigned short Library::numDictPages(unsigned padding) +{ + unsigned short ndicpages; + unsigned short bucksForHash; + unsigned short bucksForSize; + unsigned symSize = 0; + + for (size_t i = 0; i < objsymbols.dim; i++) + { ObjSymbol *s = objsymbols.tdata()[i]; + + symSize += ( strlen(s->name) + 4 ) & ~1; + } + + for (size_t i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + size_t len = strlen(om->name); + if (len > 0xFF) + len += 2; // Digital Mars long name extension + symSize += ( len + 4 + 1 ) & ~1; + } + + bucksForHash = (objsymbols.dim + objmodules.dim + HASHMOD - 3) / + (HASHMOD - 2); + bucksForSize = (symSize + BUCKETSIZE - padding - padding - 1) / + (BUCKETSIZE - padding); + + ndicpages = (bucksForHash > bucksForSize ) ? bucksForHash : bucksForSize; + //printf("ndicpages = %u\n",ndicpages); + + // Find prime number greater than ndicpages + static unsigned primes[] = + { 1,2,3,5,7,11,13,17,19,23,29,31,37,41,43, + 47,53,59,61,67,71,73,79,83,89,97,101,103, + 107,109,113,127,131,137,139,149,151,157, + 163,167,173,179,181,191,193,197,199,211, + 223,227,229,233,239,241,251,257,263,269, + 271,277,281,283,293,307,311,313,317,331, + 337,347,349,353,359,367,373,379,383,389, + 397,401,409,419,421,431,433,439,443,449, + 457,461,463,467,479,487,491,499,503,509, + //521,523,541,547, + 0 + }; + + for (size_t i = 0; 1; i++) + { + if ( primes[i] == 0 ) + { // Quick and easy way is out. + // Now try and find first prime number > ndicpages + unsigned prime; + + for (prime = (ndicpages + 1) | 1; 1; prime += 2) + { // Determine if prime is prime + for (unsigned u = 3; u < prime / 2; u += 2) + { + if ((prime / u) * u == prime) + goto L1; + } + break; + + L1: ; + } + ndicpages = prime; + break; + } + + if (primes[i] > ndicpages) + { + ndicpages = primes[i]; + break; + } + } + + return ndicpages; +} + + +/******************************************* + * Write a single entry into dictionary. + * Returns: + * 0 failure + */ + +static int EnterDict( unsigned char *bucketsP, unsigned short ndicpages, unsigned char *entry, unsigned entrylen ) +{ + unsigned short uStartIndex; + unsigned short uStep; + unsigned short uStartPage; + unsigned short uPageStep; + unsigned short uIndex; + unsigned short uPage; + unsigned short n; + unsigned u; + unsigned nbytes; + unsigned char *aP; + unsigned char *zP; + + aP = entry; + zP = aP + entrylen; // point at last char in identifier + + uStartPage = 0; + uPageStep = 0; + uStartIndex = 0; + uStep = 0; + + u = entrylen; + while ( u-- ) + { + uStartPage = _rotl( uStartPage, 2 ) ^ ( *aP | 0x20 ); + uStep = _rotr( uStep, 2 ) ^ ( *aP++ | 0x20 ); + uStartIndex = _rotr( uStartIndex, 2 ) ^ ( *zP | 0x20 ); + uPageStep = _rotl( uPageStep, 2 ) ^ ( *zP-- | 0x20 ); + } + + uStartPage %= ndicpages; + uPageStep %= ndicpages; + if ( uPageStep == 0 ) + uPageStep++; + uStartIndex %= HASHMOD; + uStep %= HASHMOD; + if ( uStep == 0 ) + uStep++; + + uPage = uStartPage; + uIndex = uStartIndex; + + // number of bytes in entry + nbytes = 1 + entrylen + 2; + if (entrylen > 255) + nbytes += 2; + + while (1) + { + aP = &bucketsP[uPage * BUCKETPAGE]; + uStartIndex = uIndex; + while (1) + { + if ( 0 == aP[ uIndex ] ) + { + // n = next available position in this page + n = aP[ HASHMOD ] << 1; + assert(n > HASHMOD); + + // if off end of this page + if (n + nbytes > BUCKETPAGE ) + { aP[ HASHMOD ] = 0xFF; + break; // next page + } + else + { + aP[ uIndex ] = n >> 1; + memcpy( (aP + n), entry, nbytes ); + aP[ HASHMOD ] += (nbytes + 1) >> 1; + if (aP[HASHMOD] == 0) + aP[HASHMOD] = 0xFF; + return 1; + } + } + uIndex += uStep; + uIndex %= 0x25; + /*if (uIndex > 0x25) + uIndex -= 0x25;*/ + if( uIndex == uStartIndex ) + break; + } + uPage += uPageStep; + if (uPage >= ndicpages) + uPage -= ndicpages; + if( uPage == uStartPage ) + break; + } + + return 0; +} + +/******************************************* + * Write the module and symbol names to the dictionary. + * Returns: + * 0 failure + */ + +int Library::FillDict(unsigned char *bucketsP, unsigned short ndicpages) +{ + unsigned char entry[4 + LIBIDMAX + 2 + 1]; + + //printf("FillDict()\n"); + + // Add each of the module names + for (size_t i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + unsigned short n = strlen( om->name ); + if (n > 255) + { entry[0] = 0xFF; + entry[1] = 0; + *(unsigned short *)(entry + 2) = n + 1; + memcpy(entry + 4, om->name, n); + n += 3; + } + else + { entry[ 0 ] = 1 + n; + memcpy(entry + 1, om->name, n ); + } + entry[ n + 1 ] = '!'; + *((unsigned short *)( n + 2 + entry )) = om->page; + if ( n & 1 ) + entry[ n + 2 + 2 ] = 0; + if ( !EnterDict( bucketsP, ndicpages, entry, n + 1 ) ) + return 0; + } + + // Sort the symbols + qsort( objsymbols.tdata(), objsymbols.dim, 4, (cmpfunc_t)NameCompare ); + + // Add each of the symbols + for (size_t i = 0; i < objsymbols.dim; i++) + { ObjSymbol *os = objsymbols.tdata()[i]; + + unsigned short n = strlen( os->name ); + if (n > 255) + { entry[0] = 0xFF; + entry[1] = 0; + *(unsigned short *)(entry + 2) = n; + memcpy(entry + 4, os->name, n); + n += 3; + } + else + { entry[ 0 ] = n; + memcpy( entry + 1, os->name, n ); + } + *((unsigned short *)( n + 1 + entry )) = os->om->page; + if ( (n & 1) == 0 ) + entry[ n + 3] = 0; + if ( !EnterDict( bucketsP, ndicpages, entry, n ) ) + { + return 0; + } + } + return 1; +} + + +/********************************************** + * Create and write library to libbuf. + * The library consists of: + * library header + * object modules... + * dictionary header + * dictionary pages... + */ + +void Library::WriteLibToBuffer(OutBuffer *libbuf) +{ + /* Scan each of the object modules for symbols + * to go into the dictionary + */ + for (size_t i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + scanObjModule(om); + } + + unsigned g_page_size = 16; + + /* Calculate page size so that the number of pages + * fits in 16 bits. This is because object modules + * are indexed by page number, stored as an unsigned short. + */ + while (1) + { + Lagain: +#if LOG + printf("g_page_size = %d\n", g_page_size); +#endif + unsigned offset = g_page_size; + + for (size_t i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + unsigned page = offset / g_page_size; + if (page > 0xFFFF) + { // Page size is too small, double it and try again + g_page_size *= 2; + goto Lagain; + } + + // Write out the object module m + if (om->flags & MFgentheadr) // if generate THEADR record + { + size_t size = strlen(om->name); + assert(size <= LIBIDMAX); + + offset += size + 5; + //offset += om->length - (size + 5); + offset += om->length; + } + else + offset += om->length; + + // Round the size of the file up to the next page size + // by filling with 0s + unsigned n = (g_page_size - 1) & offset; + if (n) + offset += g_page_size - n; + } + break; + } + + + /* Leave one page of 0s at start as a dummy library header. + * Fill it in later with the real data. + */ + libbuf->fill0(g_page_size); + + /* Write each object module into the library + */ + for (size_t i = 0; i < objmodules.dim; i++) + { ObjModule *om = objmodules.tdata()[i]; + + unsigned page = libbuf->offset / g_page_size; + assert(page <= 0xFFFF); + om->page = page; + + // Write out the object module om + if (om->flags & MFgentheadr) // if generate THEADR record + { + unsigned size = strlen(om->name); + unsigned char header[4 + LIBIDMAX + 1]; + + header [0] = THEADR; + header [1] = 2 + size; + header [2] = 0; + header [3] = size; + assert(size <= 0xFF - 2); + + memcpy(4 + header, om->name, size); + + // Compute and store record checksum + unsigned n = size + 4; + unsigned char checksum = 0; + unsigned char *p = header; + while (n--) + { checksum -= *p; + p++; + } + *p = checksum; + + libbuf->write(header, size + 5); + //libbuf->write(om->base, om->length - (size + 5)); + libbuf->write(om->base, om->length); + } + else + libbuf->write(om->base, om->length); + + // Round the size of the file up to the next page size + // by filling with 0s + unsigned n = (g_page_size - 1) & libbuf->offset; + if (n) + libbuf->fill0(g_page_size - n); + } + + // File offset of start of dictionary + unsigned offset = libbuf->offset; + + // Write dictionary header, then round it to a BUCKETPAGE boundary + unsigned short size = (BUCKETPAGE - ((short)offset + 3)) & (BUCKETPAGE - 1); + libbuf->writeByte(0xF1); + libbuf->writeword(size); + libbuf->fill0(size); + + // Create dictionary + unsigned char *bucketsP = NULL; + unsigned short ndicpages; + unsigned short padding = 32; + for (;;) + { + ndicpages = numDictPages(padding); + +#if LOG + printf("ndicpages = %d\n", ndicpages); +#endif + // Allocate dictionary + if (bucketsP) + bucketsP = (unsigned char *)realloc(bucketsP, ndicpages * BUCKETPAGE); + else + bucketsP = (unsigned char *)malloc(ndicpages * BUCKETPAGE); + assert(bucketsP); + memset(bucketsP, 0, ndicpages * BUCKETPAGE); + for (unsigned u = 0; u < ndicpages; u++) + { + // 'next available' slot + bucketsP[u * BUCKETPAGE + HASHMOD] = (HASHMOD + 1) >> 1; + } + + if (FillDict(bucketsP, ndicpages)) + break; + padding += 16; // try again with more margins + } + + // Write dictionary + libbuf->write(bucketsP, ndicpages * BUCKETPAGE); + if (bucketsP) + free(bucketsP); + + // Create library header + #pragma pack(1) + struct Libheader + { + unsigned char recTyp; + unsigned short recLen; + long trailerPosn; + unsigned short ndicpages; + unsigned char flags; + char filler[ 6 ]; + }; + #pragma pack() + + Libheader libHeader; + memset(&libHeader, 0, sizeof(Libheader)); + libHeader.recTyp = 0xF0; + libHeader.recLen = 0x0D; + libHeader.trailerPosn = offset + (3 + size); + libHeader.recLen = g_page_size - 3; + libHeader.ndicpages = ndicpages; + libHeader.flags = 1; // always case sensitive + + // Write library header at start of buffer + memcpy(libbuf->data, &libHeader, sizeof(libHeader)); +} diff --git a/link.c b/link.c new file mode 100644 index 00000000..7e1c86f3 --- /dev/null +++ b/link.c @@ -0,0 +1,636 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include +#include +#include +#include + +#if _WIN32 +#include +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#include +#endif + +#if linux || __APPLE__ + #define HAS_POSIX_SPAWN 1 + #include + #if __APPLE__ + #include + #define environ (*(_NSGetEnviron())) + #endif +#else + #define HAS_POSIX_SPAWN 0 +#endif + +#include "root.h" + +#include "mars.h" + +#include "rmem.h" + +#include "arraytypes.h" + +int executecmd(char *cmd, char *args, int useenv); +int executearg0(char *cmd, char *args); + +/**************************************** + * Write filename to cmdbuf, quoting if necessary. + */ + +void writeFilename(OutBuffer *buf, char *filename, size_t len) +{ + /* Loop and see if we need to quote + */ + for (size_t i = 0; i < len; i++) + { char c = filename[i]; + + if (isalnum((unsigned char)c) || c == '_') + continue; + + /* Need to quote + */ + buf->writeByte('"'); + buf->write(filename, len); + buf->writeByte('"'); + return; + } + + /* No quoting necessary + */ + buf->write(filename, len); +} + +void writeFilename(OutBuffer *buf, char *filename) +{ + writeFilename(buf, filename, strlen(filename)); +} + +/***************************** + * Run the linker. Return status of execution. + */ + +int runLINK() +{ +#if _WIN32 + char *p; + int status; + OutBuffer cmdbuf; + + global.params.libfiles->push("user32"); + global.params.libfiles->push("kernel32"); + + for (size_t i = 0; i < global.params.objfiles->dim; i++) + { + if (i) + cmdbuf.writeByte('+'); + p = global.params.objfiles->tdata()[i]; + char *basename = FileName::removeExt(FileName::name(p)); + char *ext = FileName::ext(p); + if (ext && !strchr(basename, '.')) + // Write name sans extension (but not if a double extension) + writeFilename(&cmdbuf, p, ext - p - 1); + else + writeFilename(&cmdbuf, p); + mem.free(basename); + } + cmdbuf.writeByte(','); + if (global.params.exefile) + writeFilename(&cmdbuf, global.params.exefile); + else + { /* Generate exe file name from first obj name. + * No need to add it to cmdbuf because the linker will default to it. + */ + char *n = global.params.objfiles->tdata()[0]; + n = FileName::name(n); + FileName *fn = FileName::forceExt(n, "exe"); + global.params.exefile = fn->toChars(); + } + + // Make sure path to exe file exists + { char *p = FileName::path(global.params.exefile); + FileName::ensurePathExists(p); + mem.free(p); + } + + cmdbuf.writeByte(','); + if (global.params.mapfile) + writeFilename(&cmdbuf, global.params.mapfile); + else if (global.params.map) + { + FileName *fn = FileName::forceExt(global.params.exefile, "map"); + + char *path = FileName::path(global.params.exefile); + char *p; + if (path[0] == '\0') + p = FileName::combine(global.params.objdir, fn->toChars()); + else + p = fn->toChars(); + + writeFilename(&cmdbuf, p); + } + else + cmdbuf.writestring("nul"); + cmdbuf.writeByte(','); + + for (size_t i = 0; i < global.params.libfiles->dim; i++) + { + if (i) + cmdbuf.writeByte('+'); + writeFilename(&cmdbuf, global.params.libfiles->tdata()[i]); + } + + if (global.params.deffile) + { + cmdbuf.writeByte(','); + writeFilename(&cmdbuf, global.params.deffile); + } + + /* Eliminate unnecessary trailing commas */ + while (1) + { size_t i = cmdbuf.offset; + if (!i || cmdbuf.data[i - 1] != ',') + break; + cmdbuf.offset--; + } + + if (global.params.resfile) + { + cmdbuf.writestring("/RC:"); + writeFilename(&cmdbuf, global.params.resfile); + } + + if (global.params.map || global.params.mapfile) + cmdbuf.writestring("/m"); + +#if 0 + if (debuginfo) + cmdbuf.writestring("/li"); + if (codeview) + { + cmdbuf.writestring("/co"); + if (codeview3) + cmdbuf.writestring(":3"); + } +#else + if (global.params.symdebug) + cmdbuf.writestring("/co"); +#endif + + cmdbuf.writestring("/noi"); + for (size_t i = 0; i < global.params.linkswitches->dim; i++) + { + cmdbuf.writestring(global.params.linkswitches->tdata()[i]); + } + cmdbuf.writeByte(';'); + + p = cmdbuf.toChars(); + + FileName *lnkfilename = NULL; + size_t plen = strlen(p); + if (plen > 7000) + { + lnkfilename = FileName::forceExt(global.params.exefile, "lnk"); + File flnk(lnkfilename); + flnk.setbuffer(p, plen); + flnk.ref = 1; + if (flnk.write()) + error("error writing file %s", lnkfilename); + if (lnkfilename->len() < plen) + sprintf(p, "@%s", lnkfilename->toChars()); + } + + char *linkcmd = getenv("LINKCMD"); + if (!linkcmd) + linkcmd = "link"; + status = executecmd(linkcmd, p, 1); + if (lnkfilename) + { + remove(lnkfilename->toChars()); + delete lnkfilename; + } + return status; +#elif linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + pid_t childpid; + int i; + int status; + + // Build argv[] + Strings argv; + + const char *cc = getenv("CC"); + if (!cc) + cc = "gcc"; + argv.push((char *)cc); + argv.insert(1, global.params.objfiles); + +#if __APPLE__ + // If we are on Mac OS X and linking a dynamic library, + // add the "-dynamiclib" flag + if (global.params.dll) + argv.push((char *) "-dynamiclib"); +#elif linux || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + if (global.params.dll) + argv.push((char *) "-shared"); +#endif + + // None of that a.out stuff. Use explicit exe file name, or + // generate one from name of first source file. + argv.push((char *)"-o"); + if (global.params.exefile) + { + if (global.params.dll) + global.params.exefile = FileName::forceExt(global.params.exefile, global.dll_ext)->toChars(); + argv.push(global.params.exefile); + } + else + { // Generate exe file name from first obj name + char *n = global.params.objfiles->tdata()[0]; + char *e; + char *ex; + + n = FileName::name(n); + e = FileName::ext(n); + if (e) + { + e--; // back up over '.' + ex = (char *)mem.malloc(e - n + 1); + memcpy(ex, n, e - n); + ex[e - n] = 0; + // If generating dll then force dll extension + if (global.params.dll) + ex = FileName::forceExt(ex, global.dll_ext)->toChars(); + } + else + ex = (char *)"a.out"; // no extension, so give up + argv.push(ex); + global.params.exefile = ex; + } + + // Make sure path to exe file exists + { char *p = FileName::path(global.params.exefile); + FileName::ensurePathExists(p); + mem.free(p); + } + + if (global.params.symdebug) + argv.push((char *)"-g"); + + if (global.params.is64bit) + argv.push((char *)"-m64"); + else + argv.push((char *)"-m32"); + + if (global.params.map || global.params.mapfile) + { + argv.push((char *)"-Xlinker"); +#if __APPLE__ + argv.push((char *)"-map"); +#else + argv.push((char *)"-Map"); +#endif + if (!global.params.mapfile) + { + FileName *fn = FileName::forceExt(global.params.exefile, "map"); + + char *path = FileName::path(global.params.exefile); + char *p; + if (path[0] == '\0') + p = FileName::combine(global.params.objdir, fn->toChars()); + else + p = fn->toChars(); + + global.params.mapfile = p; + } + argv.push((char *)"-Xlinker"); + argv.push(global.params.mapfile); + } + + if (0 && global.params.exefile) + { + /* This switch enables what is known as 'smart linking' + * in the Windows world, where unreferenced sections + * are removed from the executable. It eliminates unreferenced + * functions, essentially making a 'library' out of a module. + * Although it is documented to work with ld version 2.13, + * in practice it does not, but just seems to be ignored. + * Thomas Kuehne has verified that it works with ld 2.16.1. + * BUG: disabled because it causes exception handling to fail + * because EH sections are "unreferenced" and elided + */ + argv.push((char *)"-Xlinker"); + argv.push((char *)"--gc-sections"); + } + + for (size_t i = 0; i < global.params.linkswitches->dim; i++) + { char *p = global.params.linkswitches->tdata()[i]; + if (!p || !p[0] || !(p[0] == '-' && p[1] == 'l')) + // Don't need -Xlinker if switch starts with -l + argv.push((char *)"-Xlinker"); + argv.push(p); + } + + /* Add each library, prefixing it with "-l". + * The order of libraries passed is: + * 1. any libraries passed with -L command line switch + * 2. libraries specified on the command line + * 3. libraries specified by pragma(lib), which were appended + * to global.params.libfiles. + * 4. standard libraries. + */ + for (size_t i = 0; i < global.params.libfiles->dim; i++) + { char *p = global.params.libfiles->tdata()[i]; + size_t plen = strlen(p); + if (plen > 2 && p[plen - 2] == '.' && p[plen -1] == 'a') + argv.push(p); + else + { + char *s = (char *)mem.malloc(plen + 3); + s[0] = '-'; + s[1] = 'l'; + memcpy(s + 2, p, plen + 1); + argv.push(s); + } + } + + /* Standard libraries must go after user specified libraries + * passed with -l. + */ + const char *libname = (global.params.symdebug) + ? global.params.debuglibname + : global.params.defaultlibname; + size_t slen = strlen(libname); + if (slen) + { + char *buf = (char *)malloc(2 + slen + 1); + strcpy(buf, "-l"); + strcpy(buf + 2, libname); + argv.push(buf); // turns into /usr/lib/libphobos2.a + } + +// argv.push((void *)"-ldruntime"); + argv.push((char *)"-lpthread"); + argv.push((char *)"-lm"); +#if linux && DMDV2 + // Changes in ld for Ubuntu 11.10 require this to appear after phobos2 + argv.push((char *)"-lrt"); +#endif + + if (!global.params.quiet || global.params.verbose) + { + // Print it + for (size_t i = 0; i < argv.dim; i++) + printf("%s ", argv.tdata()[i]); + printf("\n"); + fflush(stdout); + } + + argv.push(NULL); +#if HAS_POSIX_SPAWN + int spawn_err = posix_spawnp(&childpid, argv.tdata()[0], NULL, NULL, argv.tdata(), environ); + if (spawn_err != 0) + { + perror(argv.tdata()[0]); + return -1; + } +#else + childpid = fork(); + if (childpid == 0) + { + execvp(argv.tdata()[0], argv.tdata()); + perror(argv.tdata()[0]); // failed to execute + return -1; + } + else if (childpid == -1) + { + perror("Unable to fork"); + return -1; + } +#endif + + waitpid(childpid, &status, 0); + + if (WIFEXITED(status)) + { + status = WEXITSTATUS(status); + if (status) + printf("--- errorlevel %d\n", status); + } + else if (WIFSIGNALED(status)) + { + printf("--- killed by signal %d\n", WTERMSIG(status)); + status = 1; + } + return status; +#else + printf ("Linking is not yet supported for this version of DMD.\n"); + return -1; +#endif +} + +/********************************** + * Delete generated EXE file. + */ + +void deleteExeFile() +{ + if (global.params.exefile) + { + //printf("deleteExeFile() %s\n", global.params.exefile); + remove(global.params.exefile); + } +} + +/****************************** + * Execute a rule. Return the status. + * cmd program to run + * args arguments to cmd, as a string + * useenv if cmd knows about _CMDLINE environment variable + */ + +#if _WIN32 +int executecmd(char *cmd, char *args, int useenv) +{ + int status; + size_t len; + + if (!global.params.quiet || global.params.verbose) + { + printf("%s %s\n", cmd, args); + fflush(stdout); + } + + if ((len = strlen(args)) > 255) + { char *q; + static char envname[] = "@_CMDLINE"; + + envname[0] = '@'; + switch (useenv) + { case 0: goto L1; + case 2: envname[0] = '%'; break; + } + q = (char *) alloca(sizeof(envname) + len + 1); + sprintf(q,"%s=%s", envname + 1, args); + status = putenv(q); + if (status == 0) + args = envname; + else + { + L1: + error("command line length of %d is too long",len); + } + } + + status = executearg0(cmd,args); +#if _WIN32 + if (status == -1) + status = spawnlp(0,cmd,cmd,args,NULL); +#endif +// if (global.params.verbose) +// printf("\n"); + if (status) + { + if (status == -1) + printf("Can't run '%s', check PATH\n", cmd); + else + printf("--- errorlevel %d\n", status); + } + return status; +} +#endif + +/************************************** + * Attempt to find command to execute by first looking in the directory + * where DMD was run from. + * Returns: + * -1 did not find command there + * !=-1 exit status from command + */ + +#if _WIN32 +int executearg0(char *cmd, char *args) +{ + const char *file; + char *argv0 = global.params.argv0; + + //printf("argv0='%s', cmd='%s', args='%s'\n",argv0,cmd,args); + + // If cmd is fully qualified, we don't do this + if (FileName::absolute(cmd)) + return -1; + + file = FileName::replaceName(argv0, cmd); + + //printf("spawning '%s'\n",file); +#if _WIN32 + return spawnl(0,file,file,args,NULL); +#elif linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + char *full; + int cmdl = strlen(cmd); + + full = (char*) mem.malloc(cmdl + strlen(args) + 2); + if (full == NULL) + return 1; + strcpy(full, cmd); + full [cmdl] = ' '; + strcpy(full + cmdl + 1, args); + + int result = system(full); + + mem.free(full); + return result; +#else + assert(0); +#endif +} +#endif + +/*************************************** + * Run the compiled program. + * Return exit status. + */ + +int runProgram() +{ + //printf("runProgram()\n"); + if (global.params.verbose) + { + printf("%s", global.params.exefile); + for (size_t i = 0; i < global.params.runargs_length; i++) + printf(" %s", (char *)global.params.runargs[i]); + printf("\n"); + } + + // Build argv[] + Strings argv; + + argv.push(global.params.exefile); + for (size_t i = 0; i < global.params.runargs_length; i++) + { char *a = global.params.runargs[i]; + +#if _WIN32 + // BUG: what about " appearing in the string? + if (strchr(a, ' ')) + { char *b = (char *)mem.malloc(3 + strlen(a)); + sprintf(b, "\"%s\"", a); + a = b; + } +#endif + argv.push(a); + } + argv.push(NULL); + +#if _WIN32 + char *ex = FileName::name(global.params.exefile); + if (ex == global.params.exefile) + ex = FileName::combine(".", ex); + else + ex = global.params.exefile; + return spawnv(0,ex,argv.tdata()); +#elif linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + pid_t childpid; + int status; + + childpid = fork(); + if (childpid == 0) + { + char *fn = argv.tdata()[0]; + if (!FileName::absolute(fn)) + { // Make it "./fn" + fn = FileName::combine(".", fn); + } + execv(fn, argv.tdata()); + perror(fn); // failed to execute + return -1; + } + + waitpid(childpid, &status, 0); + + if (WIFEXITED(status)) + { + status = WEXITSTATUS(status); + //printf("--- errorlevel %d\n", status); + } + else if (WIFSIGNALED(status)) + { + printf("--- killed by signal %d\n", WTERMSIG(status)); + status = 1; + } + return status; +#else + assert(0); +#endif +} diff --git a/macro.c b/macro.c new file mode 100644 index 00000000..398ba77f --- /dev/null +++ b/macro.c @@ -0,0 +1,449 @@ + +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* Simple macro text processor. + */ + +#include +#include +#include +#include +#include + +#include "rmem.h" +#include "root.h" + +#include "macro.h" + +#define isidstart(c) (isalpha(c) || (c) == '_') +#define isidchar(c) (isalnum(c) || (c) == '_') + +unsigned char *memdup(unsigned char *p, size_t len) +{ + return (unsigned char *)memcpy(mem.malloc(len), p, len); +} + +Macro::Macro(unsigned char *name, size_t namelen, unsigned char *text, size_t textlen) +{ + next = NULL; + +#if 1 + this->name = name; + this->namelen = namelen; + + this->text = text; + this->textlen = textlen; +#else + this->name = name; + this->namelen = namelen; + + this->text = text; + this->textlen = textlen; +#endif + inuse = 0; +} + + +Macro *Macro::search(unsigned char *name, size_t namelen) +{ Macro *table; + + //printf("Macro::search(%.*s)\n", namelen, name); + for (table = this; table; table = table->next) + { + if (table->namelen == namelen && + memcmp(table->name, name, namelen) == 0) + { + //printf("\tfound %d\n", table->textlen); + break; + } + } + return table; +} + +Macro *Macro::define(Macro **ptable, unsigned char *name, size_t namelen, unsigned char *text, size_t textlen) +{ + //printf("Macro::define('%.*s' = '%.*s')\n", namelen, name, textlen, text); + + Macro *table; + + //assert(ptable); + for (table = *ptable; table; table = table->next) + { + if (table->namelen == namelen && + memcmp(table->name, name, namelen) == 0) + { + table->text = text; + table->textlen = textlen; + return table; + } + } + table = new Macro(name, namelen, text, textlen); + table->next = *ptable; + *ptable = table; + return table; +} + +/********************************************************** + * Given buffer p[0..end], extract argument marg[0..marglen]. + * Params: + * n 0: get entire argument + * 1..9: get nth argument + * -1: get 2nd through end + */ + +unsigned extractArgN(unsigned char *p, unsigned end, unsigned char **pmarg, unsigned *pmarglen, int n) +{ + /* Scan forward for matching right parenthesis. + * Nest parentheses. + * Skip over $( and $) + * Skip over "..." and '...' strings inside HTML tags. + * Skip over comments. + * Skip over previous macro insertions + * Set marglen. + */ + unsigned parens = 1; + unsigned char instring = 0; + unsigned incomment = 0; + unsigned intag = 0; + unsigned inexp = 0; + unsigned argn = 0; + + unsigned v = 0; + + Largstart: +#if 1 + // Skip first space, if any, to find the start of the macro argument + if (v < end && isspace(p[v])) + v++; +#else + // Skip past spaces to find the start of the macro argument + for (; v < end && isspace(p[v]); v++) + ; +#endif + *pmarg = p + v; + + for (; v < end; v++) + { unsigned char c = p[v]; + + switch (c) + { + case ',': + if (!inexp && !instring && !incomment && parens == 1) + { + argn++; + if (argn == 1 && n == -1) + { v++; + goto Largstart; + } + if (argn == n) + break; + if (argn + 1 == n) + { v++; + goto Largstart; + } + } + continue; + + case '(': + if (!inexp && !instring && !incomment) + parens++; + continue; + + case ')': + if (!inexp && !instring && !incomment && --parens == 0) + { + break; + } + continue; + + case '"': + case '\'': + if (!inexp && !incomment && intag) + { + if (c == instring) + instring = 0; + else if (!instring) + instring = c; + } + continue; + + case '<': + if (!inexp && !instring && !incomment) + { + if (v + 6 < end && + p[v + 1] == '!' && + p[v + 2] == '-' && + p[v + 3] == '-') + { + incomment = 1; + v += 3; + } + else if (v + 2 < end && + isalpha(p[v + 1])) + intag = 1; + } + continue; + + case '>': + if (!inexp) + intag = 0; + continue; + + case '-': + if (!inexp && + !instring && + incomment && + v + 2 < end && + p[v + 1] == '-' && + p[v + 2] == '>') + { + incomment = 0; + v += 2; + } + continue; + + case 0xFF: + if (v + 1 < end) + { + if (p[v + 1] == '{') + inexp++; + else if (p[v + 1] == '}') + inexp--; + } + continue; + + default: + continue; + } + break; + } + if (argn == 0 && n == -1) + *pmarg = p + v; + *pmarglen = p + v - *pmarg; + //printf("extractArg%d('%.*s') = '%.*s'\n", n, end, p, *pmarglen, *pmarg); + return v; +} + + +/***************************************************** + * Expand macro in place in buf. + * Only look at the text in buf from start to end. + */ + +void Macro::expand(OutBuffer *buf, unsigned start, unsigned *pend, + unsigned char *arg, unsigned arglen) +{ +#if 0 + printf("Macro::expand(buf[%d..%d], arg = '%.*s')\n", start, *pend, arglen, arg); + printf("Buf is: '%.*s'\n", *pend - start, buf->data + start); +#endif + + static int nest; + if (nest > 100) // limit recursive expansion + return; + nest++; + + unsigned end = *pend; + assert(start <= end); + assert(end <= buf->offset); + + /* First pass - replace $0 + */ + arg = memdup(arg, arglen); + for (unsigned u = start; u + 1 < end; ) + { + unsigned char *p = buf->data; // buf->data is not loop invariant + + /* Look for $0, but not $$0, and replace it with arg. + */ + if (p[u] == '$' && (isdigit(p[u + 1]) || p[u + 1] == '+')) + { + if (u > start && p[u - 1] == '$') + { // Don't expand $$0, but replace it with $0 + buf->remove(u - 1, 1); + end--; + u += 1; // now u is one past the closing '1' + continue; + } + + unsigned char c = p[u + 1]; + int n = (c == '+') ? -1 : c - '0'; + + unsigned char *marg; + unsigned marglen; + extractArgN(arg, arglen, &marg, &marglen, n); + if (marglen == 0) + { // Just remove macro invocation + //printf("Replacing '$%c' with '%.*s'\n", p[u + 1], marglen, marg); + buf->remove(u, 2); + end -= 2; + } + else if (c == '+') + { + // Replace '$+' with 'arg' + //printf("Replacing '$%c' with '%.*s'\n", p[u + 1], marglen, marg); + buf->remove(u, 2); + buf->insert(u, marg, marglen); + end += marglen - 2; + + // Scan replaced text for further expansion + unsigned mend = u + marglen; + expand(buf, u, &mend, NULL, 0); + end += mend - (u + marglen); + u = mend; + } + else + { + // Replace '$1' with '\xFF{arg\xFF}' + //printf("Replacing '$%c' with '\xFF{%.*s\xFF}'\n", p[u + 1], marglen, marg); + buf->data[u] = 0xFF; + buf->data[u + 1] = '{'; + buf->insert(u + 2, marg, marglen); + buf->insert(u + 2 + marglen, "\xFF}", 2); + end += -2 + 2 + marglen + 2; + + // Scan replaced text for further expansion + unsigned mend = u + 2 + marglen; + expand(buf, u + 2, &mend, NULL, 0); + end += mend - (u + 2 + marglen); + u = mend; + } + //printf("u = %d, end = %d\n", u, end); + //printf("#%.*s#\n", end, &buf->data[0]); + continue; + } + + u++; + } + + /* Second pass - replace other macros + */ + for (unsigned u = start; u + 4 < end; ) + { + unsigned char *p = buf->data; // buf->data is not loop invariant + + /* A valid start of macro expansion is $(c, where c is + * an id start character, and not $$(c. + */ + if (p[u] == '$' && p[u + 1] == '(' && isidstart(p[u + 2])) + { + //printf("\tfound macro start '%c'\n", p[u + 2]); + unsigned char *name = p + u + 2; + unsigned namelen = 0; + + unsigned char *marg; + unsigned marglen; + + unsigned v; + /* Scan forward to find end of macro name and + * beginning of macro argument (marg). + */ + for (v = u + 2; v < end; v++) + { unsigned char c = p[v]; + + if (!isidchar(c)) + { // We've gone past the end of the macro name. + namelen = v - (u + 2); + break; + } + } + + v += extractArgN(p + v, end - v, &marg, &marglen, 0); + assert(v <= end); + + if (v < end) + { // v is on the closing ')' + if (u > start && p[u - 1] == '$') + { // Don't expand $$(NAME), but replace it with $(NAME) + buf->remove(u - 1, 1); + end--; + u = v; // now u is one past the closing ')' + continue; + } + + Macro *m = search(name, namelen); + if (m) + { +#if 0 + if (m->textlen && m->text[0] == ' ') + { m->text++; + m->textlen--; + } +#endif + if (m->inuse && marglen == 0) + { // Remove macro invocation + buf->remove(u, v + 1 - u); + end -= v + 1 - u; + } + else if (m->inuse && arglen == marglen && memcmp(arg, marg, arglen) == 0) + { // Recursive expansion; just leave in place + + } + else + { + //printf("\tmacro '%.*s'(%.*s) = '%.*s'\n", m->namelen, m->name, marglen, marg, m->textlen, m->text); +#if 1 + marg = memdup(marg, marglen); + // Insert replacement text + buf->spread(v + 1, 2 + m->textlen + 2); + buf->data[v + 1] = 0xFF; + buf->data[v + 2] = '{'; + memcpy(buf->data + v + 3, m->text, m->textlen); + buf->data[v + 3 + m->textlen] = 0xFF; + buf->data[v + 3 + m->textlen + 1] = '}'; + + end += 2 + m->textlen + 2; + + // Scan replaced text for further expansion + m->inuse++; + unsigned mend = v + 1 + 2+m->textlen+2; + expand(buf, v + 1, &mend, marg, marglen); + end += mend - (v + 1 + 2+m->textlen+2); + m->inuse--; + + buf->remove(u, v + 1 - u); + end -= v + 1 - u; + u += mend - (v + 1); +#else + // Insert replacement text + buf->insert(v + 1, m->text, m->textlen); + end += m->textlen; + + // Scan replaced text for further expansion + m->inuse++; + unsigned mend = v + 1 + m->textlen; + expand(buf, v + 1, &mend, marg, marglen); + end += mend - (v + 1 + m->textlen); + m->inuse--; + + buf->remove(u, v + 1 - u); + end -= v + 1 - u; + u += mend - (v + 1); +#endif + mem.free(marg); + //printf("u = %d, end = %d\n", u, end); + //printf("#%.*s#\n", end - u, &buf->data[u]); + continue; + } + } + else + { + // Replace $(NAME) with nothing + buf->remove(u, v + 1 - u); + end -= (v + 1 - u); + continue; + } + } + } + u++; + } + mem.free(arg); + *pend = end; + nest--; +} diff --git a/macro.h b/macro.h new file mode 100644 index 00000000..7c939621 --- /dev/null +++ b/macro.h @@ -0,0 +1,45 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_MACRO_H +#define DMD_MACRO_H 1 + +#include +#include +#include +#include + +#include "root.h" + + +struct Macro +{ + private: + Macro *next; // next in list + + unsigned char *name; // macro name + size_t namelen; // length of macro name + + unsigned char *text; // macro replacement text + size_t textlen; // length of replacement text + + int inuse; // macro is in use (don't expand) + + Macro(unsigned char *name, size_t namelen, unsigned char *text, size_t textlen); + Macro *search(unsigned char *name, size_t namelen); + + public: + static Macro *define(Macro **ptable, unsigned char *name, size_t namelen, unsigned char *text, size_t textlen); + + void expand(OutBuffer *buf, unsigned start, unsigned *pend, + unsigned char *arg, unsigned arglen); +}; + +#endif diff --git a/mangle.c b/mangle.c new file mode 100644 index 00000000..c4baa871 --- /dev/null +++ b/mangle.c @@ -0,0 +1,272 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#include "root.h" + +#include "init.h" +#include "declaration.h" +#include "aggregate.h" +#include "mtype.h" +#include "attrib.h" +#include "template.h" +#include "id.h" +#include "module.h" + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +char *cpp_mangle(Dsymbol *s); +#endif + +char *mangle(Declaration *sthis) +{ + OutBuffer buf; + char *id; + Dsymbol *s; + + //printf("::mangle(%s)\n", sthis->toChars()); + s = sthis; + do + { + //printf("mangle: s = %p, '%s', parent = %p\n", s, s->toChars(), s->parent); + if (s->ident) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (s != sthis && fd) + { + id = mangle(fd); + buf.prependstring(id); + goto L1; + } + else + { + id = s->ident->toChars(); + int len = strlen(id); + char tmp[sizeof(len) * 3 + 1]; + buf.prependstring(id); + sprintf(tmp, "%d", len); + buf.prependstring(tmp); + } + } + else + buf.prependstring("0"); + s = s->parent; + } while (s); + +// buf.prependstring("_D"); +L1: + //printf("deco = '%s'\n", sthis->type->deco ? sthis->type->deco : "null"); + //printf("sthis->type = %s\n", sthis->type->toChars()); + FuncDeclaration *fd = sthis->isFuncDeclaration(); + if (fd && (fd->needThis() || fd->isNested())) + buf.writeByte(Type::needThisPrefix()); + if (sthis->type->deco) + buf.writestring(sthis->type->deco); + else + { +#ifdef DEBUG + if (!fd->inferRetType) + printf("%s\n", fd->toChars()); +#endif + assert(fd && fd->inferRetType); + } + + id = buf.toChars(); + buf.data = NULL; + return id; +} + +char *Declaration::mangle() +#if __DMC__ + __out(result) + { + int len = strlen(result); + + assert(len > 0); + //printf("mangle: '%s' => '%s'\n", toChars(), result); + for (int i = 0; i < len; i++) + { + assert(result[i] == '_' || + result[i] == '@' || + isalnum(result[i]) || result[i] & 0x80); + } + } + __body +#endif + { + //printf("Declaration::mangle(this = %p, '%s', parent = '%s', linkage = %d)\n", this, toChars(), parent ? parent->toChars() : "null", linkage); + if (!parent || parent->isModule() || linkage == LINKcpp) // if at global scope + { + // If it's not a D declaration, no mangling + switch (linkage) + { + case LINKd: + break; + + case LINKc: + case LINKwindows: + case LINKpascal: + return ident->toChars(); + + case LINKcpp: +#if CPP_MANGLE + return cpp_mangle(this); +#else + // Windows C++ mangling is done by C++ back end + return ident->toChars(); +#endif + + case LINKdefault: + error("forward declaration"); + return ident->toChars(); + + default: + fprintf(stdmsg, "'%s', linkage = %d\n", toChars(), linkage); + assert(0); + } + } + char *p = ::mangle(this); + OutBuffer buf; + buf.writestring("_D"); + buf.writestring(p); + p = buf.toChars(); + buf.data = NULL; + //printf("Declaration::mangle(this = %p, '%s', parent = '%s', linkage = %d) = %s\n", this, toChars(), parent ? parent->toChars() : "null", linkage, p); + return p; + } + +char *FuncDeclaration::mangle() +#if __DMC__ + __out(result) + { + assert(strlen(result) > 0); + } + __body +#endif + { + if (isMain()) + return (char *)"_Dmain"; + + if (isWinMain() || isDllMain() || ident == Id::tls_get_addr) + return ident->toChars(); + + assert(this); + return Declaration::mangle(); + } + +char *StructDeclaration::mangle() +{ + //printf("StructDeclaration::mangle() '%s'\n", toChars()); + return Dsymbol::mangle(); +} + + +char *TypedefDeclaration::mangle() +{ + //printf("TypedefDeclaration::mangle() '%s'\n", toChars()); + return Dsymbol::mangle(); +} + + +char *ClassDeclaration::mangle() +{ + Dsymbol *parentsave = parent; + + //printf("ClassDeclaration::mangle() %s.%s\n", parent->toChars(), toChars()); + + /* These are reserved to the compiler, so keep simple + * names for them. + */ + if (ident == Id::Exception) + { if (parent->ident == Id::object) + parent = NULL; + } + else if (ident == Id::TypeInfo || +// ident == Id::Exception || + ident == Id::TypeInfo_Struct || + ident == Id::TypeInfo_Class || + ident == Id::TypeInfo_Typedef || + ident == Id::TypeInfo_Tuple || + this == object || + this == classinfo || + this == Module::moduleinfo || + memcmp(ident->toChars(), "TypeInfo_", 9) == 0 + ) + parent = NULL; + + char *id = Dsymbol::mangle(); + parent = parentsave; + return id; +} + + +char *TemplateInstance::mangle() +{ + OutBuffer buf; + +#if 0 + printf("TemplateInstance::mangle() %p %s", this, toChars()); + if (parent) + printf(" parent = %s %s", parent->kind(), parent->toChars()); + printf("\n"); +#endif + char *id = ident ? ident->toChars() : toChars(); + if (!tempdecl) + error("is not defined"); + else + { + Dsymbol *par = isnested || isTemplateMixin() ? parent : tempdecl->parent; + if (par) + { + char *p = par->mangle(); + if (p[0] == '_' && p[1] == 'D') + p += 2; + buf.writestring(p); + } + } + buf.printf("%zu%s", strlen(id), id); + id = buf.toChars(); + buf.data = NULL; + //printf("TemplateInstance::mangle() %s = %s\n", toChars(), id); + return id; +} + + + +char *Dsymbol::mangle() +{ + OutBuffer buf; + char *id; + +#if 0 + printf("Dsymbol::mangle() '%s'", toChars()); + if (parent) + printf(" parent = %s %s", parent->kind(), parent->toChars()); + printf("\n"); +#endif + id = ident ? ident->toChars() : toChars(); + if (parent) + { + char *p = parent->mangle(); + if (p[0] == '_' && p[1] == 'D') + p += 2; + buf.writestring(p); + } + buf.printf("%zu%s", strlen(id), id); + id = buf.toChars(); + buf.data = NULL; + //printf("Dsymbol::mangle() %s = %s\n", toChars(), id); + return id; +} + + diff --git a/mars.c b/mars.c new file mode 100644 index 00000000..5c7f38eb --- /dev/null +++ b/mars.c @@ -0,0 +1,1594 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// https://github.com/D-Programming-Language/dmd/blob/master/src/mars.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#endif + +#include "rmem.h" +#include "root.h" +#include "async.h" + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "id.h" +#include "cond.h" +#include "expression.h" +#include "lexer.h" +#include "lib.h" +#include "json.h" + +#if WINDOWS_SEH +#include +long __cdecl __ehfilter(LPEXCEPTION_POINTERS ep); +#endif + + +int response_expand(int *pargc, char ***pargv); +void browse(const char *url); +void getenv_setargv(const char *envvar, int *pargc, char** *pargv); + +void obj_start(char *srcfile); +void obj_end(Library *library, File *objfile); + +void printCtfePerformanceStats(); + +Global global; + +Global::Global() +{ + mars_ext = "d"; + sym_ext = "d"; + hdr_ext = "di"; + doc_ext = "html"; + ddoc_ext = "ddoc"; + json_ext = "json"; + map_ext = "map"; + +#if TARGET_WINDOS + obj_ext = "obj"; +#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + obj_ext = "o"; +#elif TARGET_NET +#else +#error "fix this" +#endif + +#if TARGET_WINDOS + lib_ext = "lib"; +#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + lib_ext = "a"; +#elif TARGET_NET +#else +#error "fix this" +#endif + +#if TARGET_WINDOS + dll_ext = "dll"; +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + dll_ext = "so"; +#elif TARGET_OSX + dll_ext = "dylib"; +#else +#error "fix this" +#endif + + copyright = "Copyright (c) 1999-2012 by Digital Mars"; + written = "written by Walter Bright" +#if TARGET_NET + "\nMSIL back-end (alpha release) by Cristian L. Vlasceanu and associates."; +#endif + ; + version = "v2.058"; + global.structalign = 8; + + memset(¶ms, 0, sizeof(Param)); +} + +unsigned Global::startGagging() +{ + ++gag; + return gaggedErrors; +} + +bool Global::endGagging(unsigned oldGagged) +{ + bool anyErrs = (gaggedErrors != oldGagged); + --gag; + // Restore the original state of gagged errors; set total errors + // to be original errors + new ungagged errors. + errors -= (gaggedErrors - oldGagged); + gaggedErrors = oldGagged; + return anyErrs; +} + + +char *Loc::toChars() +{ + OutBuffer buf; + + if (filename) + { + buf.printf("%s", filename); + } + + if (linnum) + buf.printf("(%d)", linnum); + buf.writeByte(0); + return (char *)buf.extractData(); +} + +Loc::Loc(Module *mod, unsigned linnum) +{ + this->linnum = linnum; + this->filename = mod ? mod->srcfile->toChars() : NULL; +} + +bool Loc::equals(const Loc& loc) +{ + return linnum == loc.linnum && FileName::equals(filename, loc.filename); +} + +/************************************** + * Print error message + */ + +void error(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end( ap ); +} + +void error(const char *filename, unsigned linnum, const char *format, ...) +{ Loc loc; + loc.filename = (char *)filename; + loc.linnum = linnum; + va_list ap; + va_start(ap, format); + verror(loc, format, ap); + va_end( ap ); +} + +void warning(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + vwarning(loc, format, ap); + va_end( ap ); +} + +/************************************** + * Print supplementary message about the last error + * Used for backtraces, etc + */ +void errorSupplemental(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + verrorSupplemental(loc, format, ap); + va_end( ap ); +} + +void verror(Loc loc, const char *format, va_list ap) +{ + if (!global.gag) + { + char *p = loc.toChars(); + + if (*p) + fprintf(stdmsg, "%s: ", p); + mem.free(p); + + fprintf(stdmsg, "Error: "); +#if _MSC_VER + // MS doesn't recognize %zu format + OutBuffer tmp; + tmp.vprintf(format, ap); + fprintf(stdmsg, "%s", tmp.toChars()); +#else + vfprintf(stdmsg, format, ap); +#endif + fprintf(stdmsg, "\n"); + fflush(stdmsg); +//halt(); + } + else + { + global.gaggedErrors++; + } + global.errors++; +} + +// Doesn't increase error count, doesn't print "Error:". +void verrorSupplemental(Loc loc, const char *format, va_list ap) +{ + if (!global.gag) + { + fprintf(stdmsg, "%s: ", loc.toChars()); +#if _MSC_VER + // MS doesn't recognize %zu format + OutBuffer tmp; + tmp.vprintf(format, ap); + fprintf(stdmsg, "%s", tmp.toChars()); +#else + vfprintf(stdmsg, format, ap); +#endif + fprintf(stdmsg, "\n"); + fflush(stdmsg); + } +} + +void vwarning(Loc loc, const char *format, va_list ap) +{ + if (global.params.warnings && !global.gag) + { + char *p = loc.toChars(); + + if (*p) + fprintf(stdmsg, "%s: ", p); + mem.free(p); + + fprintf(stdmsg, "Warning: "); +#if _MSC_VER + // MS doesn't recognize %zu format + OutBuffer tmp; + tmp.vprintf(format, ap); + fprintf(stdmsg, "%s", tmp.toChars()); +#else + vfprintf(stdmsg, format, ap); +#endif + fprintf(stdmsg, "\n"); + fflush(stdmsg); +//halt(); + if (global.params.warnings == 1) + global.warnings++; // warnings don't count if gagged + } +} + +/*************************************** + * Call this after printing out fatal error messages to clean up and exit + * the compiler. + */ + +void fatal() +{ +#if 0 + halt(); +#endif + exit(EXIT_FAILURE); +} + +/************************************** + * Try to stop forgetting to remove the breakpoints from + * release builds. + */ +void halt() +{ +#ifdef DEBUG + *(volatile char*)0=0; +#endif +} + +extern void backend_init(); +extern void backend_term(); + +void usage() +{ +#if TARGET_LINUX + const char fpic[] ="\ + -fPIC generate position independent code\n\ +"; +#else + const char fpic[] = ""; +#endif + printf("DMD%s D Compiler %s\n%s %s\n", + sizeof(size_t) == 4 ? "32" : "64", + global.version, global.copyright, global.written); + printf("\ +Documentation: http://www.dlang.org/index.html\n\ +Usage:\n\ + dmd files.d ... { -switch }\n\ +\n\ + files.d D source files\n\ + @cmdfile read arguments from cmdfile\n\ + -c do not link\n\ + -cov do code coverage analysis\n\ + -D generate documentation\n\ + -Dddocdir write documentation file to docdir directory\n\ + -Dffilename write documentation file to filename\n\ + -d allow deprecated features\n\ + -debug compile in debug code\n\ + -debug=level compile in debug code <= level\n\ + -debug=ident compile in debug code identified by ident\n\ + -debuglib=name set symbolic debug library to name\n\ + -defaultlib=name set default library to name\n\ + -deps=filename write module dependencies to filename\n%s" +" -g add symbolic debug info\n\ + -gc add symbolic debug info, pretend to be C\n\ + -gs always emit stack frame\n\ + -H generate 'header' file\n\ + -Hddirectory write 'header' file to directory\n\ + -Hffilename write 'header' file to filename\n\ + --help print help\n\ + -Ipath where to look for imports\n\ + -ignore ignore unsupported pragmas\n\ + -inline do function inlining\n\ + -Jpath where to look for string imports\n\ + -Llinkerflag pass linkerflag to link\n\ + -lib generate library rather than object files\n" +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +" -m32 generate 32 bit code\n\ + -m64 generate 64 bit code\n" +#endif +" -man open web browser on manual page\n\ + -map generate linker .map file\n\ + -noboundscheck turns off array bounds checking for all functions\n\ + -nofloat do not emit reference to floating point\n\ + -O optimize\n\ + -o- do not write object file\n\ + -odobjdir write object & library files to directory objdir\n\ + -offilename name output file to filename\n\ + -op do not strip paths from source file\n\ + -profile profile runtime performance of generated code\n\ + -property enforce property syntax\n\ + -quiet suppress unnecessary messages\n\ + -release compile release version\n\ + -run srcfile args... run resulting program, passing args\n" +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +" -shared generate shared library\n" +#endif +" -unittest compile in unit tests\n\ + -v verbose\n\ + -version=level compile in version code >= level\n\ + -version=ident compile in version code identified by ident\n\ + -vtls list all variables going into thread local storage\n\ + -w enable warnings\n\ + -wi enable informational warnings\n\ + -X generate JSON file\n\ + -Xffilename write JSON file to filename\n\ +", fpic); +} + +extern signed char tyalignsize[]; + +#if _WIN32 +extern "C" +{ + extern int _xi_a; + extern int _end; +} +#endif + +int main(int argc, char *argv[]) +{ + mem.init(); // initialize storage allocator + mem.setStackBottom(&argv); +#if _WIN32 + mem.addroots((char *)&_xi_a, (char *)&_end); +#endif + + Strings files; + Strings libmodules; + char *p; + Module *m; + int status = EXIT_SUCCESS; + int argcstart = argc; + int setdebuglib = 0; + char noboundscheck = 0; + const char *inifilename = NULL; + +#ifdef DEBUG + printf("DMD %s DEBUG\n", global.version); +#endif + + unittests(); + + // Check for malformed input + if (argc < 1 || !argv) + { + Largs: + error("missing or null command line arguments"); + fatal(); + } + for (size_t i = 0; i < argc; i++) + { + if (!argv[i]) + goto Largs; + } + + if (response_expand(&argc,&argv)) // expand response files + error("can't open response file"); + + files.reserve(argc - 1); + + // Set default values + global.params.argv0 = argv[0]; + global.params.link = 1; + global.params.useAssert = 1; + global.params.useInvariants = 1; + global.params.useIn = 1; + global.params.useOut = 1; + global.params.useArrayBounds = 2; // default to all functions + global.params.useSwitchError = 1; + global.params.useInline = 0; + global.params.obj = 1; + global.params.Dversion = 2; + global.params.quiet = 1; + + global.params.linkswitches = new Strings(); + global.params.libfiles = new Strings(); + global.params.objfiles = new Strings(); + global.params.ddocfiles = new Strings(); + + // Default to -m32 for 32 bit dmd, -m64 for 64 bit dmd + global.params.is64bit = (sizeof(size_t) == 8); + +#if TARGET_WINDOS + global.params.defaultlibname = "phobos"; +#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + global.params.defaultlibname = "phobos2"; +#elif TARGET_NET +#else +#error "fix this" +#endif + + // Predefine version identifiers + VersionCondition::addPredefinedGlobalIdent("DigitalMars"); + +#if TARGET_WINDOS + VersionCondition::addPredefinedGlobalIdent("Windows"); + global.params.isWindows = 1; +#if TARGET_NET + // TARGET_NET macro is NOT mutually-exclusive with TARGET_WINDOS + VersionCondition::addPredefinedGlobalIdent("D_NET"); +#endif +#elif TARGET_LINUX + VersionCondition::addPredefinedGlobalIdent("Posix"); + VersionCondition::addPredefinedGlobalIdent("linux"); + global.params.isLinux = 1; +#elif TARGET_OSX + VersionCondition::addPredefinedGlobalIdent("Posix"); + VersionCondition::addPredefinedGlobalIdent("OSX"); + global.params.isOSX = 1; + + // For legacy compatibility + VersionCondition::addPredefinedGlobalIdent("darwin"); +#elif TARGET_FREEBSD + VersionCondition::addPredefinedGlobalIdent("Posix"); + VersionCondition::addPredefinedGlobalIdent("FreeBSD"); + global.params.isFreeBSD = 1; +#elif TARGET_OPENBSD + VersionCondition::addPredefinedGlobalIdent("Posix"); + VersionCondition::addPredefinedGlobalIdent("OpenBSD"); + global.params.isFreeBSD = 1; +#elif TARGET_SOLARIS + VersionCondition::addPredefinedGlobalIdent("Posix"); + VersionCondition::addPredefinedGlobalIdent("Solaris"); + global.params.isSolaris = 1; +#else +#error "fix this" +#endif + + VersionCondition::addPredefinedGlobalIdent("LittleEndian"); + //VersionCondition::addPredefinedGlobalIdent("D_Bits"); +#if DMDV2 + VersionCondition::addPredefinedGlobalIdent("D_Version2"); +#endif + VersionCondition::addPredefinedGlobalIdent("all"); + +#if _WIN32 + inifilename = inifile(argv[0], "sc.ini"); +#elif linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + inifilename = inifile(argv[0], "dmd.conf"); +#else +#error "fix this" +#endif + getenv_setargv("DFLAGS", &argc, &argv); + +#if 0 + for (size_t i = 0; i < argc; i++) + { + printf("argv[%d] = '%s'\n", i, argv[i]); + } +#endif + + for (size_t i = 1; i < argc; i++) + { + p = argv[i]; + if (*p == '-') + { + if (strcmp(p + 1, "d") == 0) + global.params.useDeprecated = 1; + else if (strcmp(p + 1, "c") == 0) + global.params.link = 0; + else if (strcmp(p + 1, "cov") == 0) + global.params.cov = 1; +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + else if (strcmp(p + 1, "shared") == 0 +#if TARGET_OSX + // backwards compatibility with old switch + || strcmp(p + 1, "dylib") == 0 +#endif + ) + global.params.dll = 1; + else if (strcmp(p + 1, "fPIC") == 0) + global.params.pic = 1; +#endif + else if (strcmp(p + 1, "map") == 0) + global.params.map = 1; + else if (strcmp(p + 1, "multiobj") == 0) + global.params.multiobj = 1; + else if (strcmp(p + 1, "g") == 0) + global.params.symdebug = 1; + else if (strcmp(p + 1, "gc") == 0) + global.params.symdebug = 2; + else if (strcmp(p + 1, "gs") == 0) + global.params.alwaysframe = 1; + else if (strcmp(p + 1, "gt") == 0) + { error("use -profile instead of -gt\n"); + global.params.trace = 1; + } + else if (strcmp(p + 1, "m32") == 0) + global.params.is64bit = 0; + else if (strcmp(p + 1, "m64") == 0) + global.params.is64bit = 1; + else if (strcmp(p + 1, "profile") == 0) + global.params.trace = 1; + else if (strcmp(p + 1, "v") == 0) + global.params.verbose = 1; +#if DMDV2 + else if (strcmp(p + 1, "vtls") == 0) + global.params.vtls = 1; +#endif + else if (strcmp(p + 1, "v1") == 0) + { +#if DMDV1 + global.params.Dversion = 1; +#else + error("use DMD 1.0 series compilers for -v1 switch"); + break; +#endif + } + else if (strcmp(p + 1, "w") == 0) + global.params.warnings = 1; + else if (strcmp(p + 1, "wi") == 0) + global.params.warnings = 2; + else if (strcmp(p + 1, "O") == 0) + global.params.optimize = 1; + else if (p[1] == 'o') + { + switch (p[2]) + { + case '-': + global.params.obj = 0; + break; + + case 'd': + if (!p[3]) + goto Lnoarg; + global.params.objdir = p + 3; + break; + + case 'f': + if (!p[3]) + goto Lnoarg; + global.params.objname = p + 3; + break; + + case 'p': + if (p[3]) + goto Lerror; + global.params.preservePaths = 1; + break; + + case 0: + error("-o no longer supported, use -of or -od"); + break; + + default: + goto Lerror; + } + } + else if (p[1] == 'D') + { global.params.doDocComments = 1; + switch (p[2]) + { + case 'd': + if (!p[3]) + goto Lnoarg; + global.params.docdir = p + 3; + break; + case 'f': + if (!p[3]) + goto Lnoarg; + global.params.docname = p + 3; + break; + + case 0: + break; + + default: + goto Lerror; + } + } + else if (p[1] == 'H') + { global.params.doHdrGeneration = 1; + switch (p[2]) + { + case 'd': + if (!p[3]) + goto Lnoarg; + global.params.hdrdir = p + 3; + break; + + case 'f': + if (!p[3]) + goto Lnoarg; + global.params.hdrname = p + 3; + break; + + case 0: + break; + + default: + goto Lerror; + } + } + else if (p[1] == 'X') + { global.params.doXGeneration = 1; + switch (p[2]) + { + case 'f': + if (!p[3]) + goto Lnoarg; + global.params.xfilename = p + 3; + break; + + case 0: + break; + + default: + goto Lerror; + } + } + else if (strcmp(p + 1, "ignore") == 0) + global.params.ignoreUnsupportedPragmas = 1; + else if (strcmp(p + 1, "property") == 0) + global.params.enforcePropertySyntax = 1; + else if (strcmp(p + 1, "inline") == 0) + global.params.useInline = 1; + else if (strcmp(p + 1, "lib") == 0) + global.params.lib = 1; + else if (strcmp(p + 1, "nofloat") == 0) + global.params.nofloat = 1; + else if (strcmp(p + 1, "quiet") == 0) + global.params.quiet = 1; + else if (strcmp(p + 1, "release") == 0) + global.params.release = 1; +#if DMDV2 + else if (strcmp(p + 1, "noboundscheck") == 0) + noboundscheck = 1; +#endif + else if (strcmp(p + 1, "unittest") == 0) + global.params.useUnitTests = 1; + else if (p[1] == 'I') + { + if (!global.params.imppath) + global.params.imppath = new Strings(); + global.params.imppath->push(p + 2); + } + else if (p[1] == 'J') + { + if (!global.params.fileImppath) + global.params.fileImppath = new Strings(); + global.params.fileImppath->push(p + 2); + } + else if (memcmp(p + 1, "debug", 5) == 0 && p[6] != 'l') + { + // Parse: + // -debug + // -debug=number + // -debug=identifier + if (p[6] == '=') + { + if (isdigit((unsigned char)p[7])) + { long level; + + errno = 0; + level = strtol(p + 7, &p, 10); + if (*p || errno || level > INT_MAX) + goto Lerror; + DebugCondition::setGlobalLevel((int)level); + } + else if (Lexer::isValidIdentifier(p + 7)) + DebugCondition::addGlobalIdent(p + 7); + else + goto Lerror; + } + else if (p[6]) + goto Lerror; + else + global.params.debuglevel = 1; + } + else if (memcmp(p + 1, "version", 5) == 0) + { + // Parse: + // -version=number + // -version=identifier + if (p[8] == '=') + { + if (isdigit((unsigned char)p[9])) + { long level; + + errno = 0; + level = strtol(p + 9, &p, 10); + if (*p || errno || level > INT_MAX) + goto Lerror; + VersionCondition::setGlobalLevel((int)level); + } + else if (Lexer::isValidIdentifier(p + 9)) + VersionCondition::addGlobalIdent(p + 9); + else + goto Lerror; + } + else + goto Lerror; + } + else if (strcmp(p + 1, "-b") == 0) + global.params.debugb = 1; + else if (strcmp(p + 1, "-c") == 0) + global.params.debugc = 1; + else if (strcmp(p + 1, "-f") == 0) + global.params.debugf = 1; + else if (strcmp(p + 1, "-help") == 0) + { usage(); + exit(EXIT_SUCCESS); + } + else if (strcmp(p + 1, "-r") == 0) + global.params.debugr = 1; + else if (strcmp(p + 1, "-x") == 0) + global.params.debugx = 1; + else if (strcmp(p + 1, "-y") == 0) + global.params.debugy = 1; + else if (p[1] == 'L') + { + global.params.linkswitches->push(p + 2); + } + else if (memcmp(p + 1, "defaultlib=", 11) == 0) + { + global.params.defaultlibname = p + 1 + 11; + } + else if (memcmp(p + 1, "debuglib=", 9) == 0) + { + setdebuglib = 1; + global.params.debuglibname = p + 1 + 9; + } + else if (memcmp(p + 1, "deps=", 5) == 0) + { + global.params.moduleDepsFile = p + 1 + 5; + if (!global.params.moduleDepsFile[0]) + goto Lnoarg; + global.params.moduleDeps = new OutBuffer; + } + else if (memcmp(p + 1, "man", 3) == 0) + { +#if _WIN32 +#if DMDV1 + browse("http://www.digitalmars.com/d/1.0/dmd-windows.html"); +#else + browse("http://www.dlang.org/dmd-windows.html"); +#endif +#endif +#if linux +#if DMDV1 + browse("http://www.digitalmars.com/d/1.0/dmd-linux.html"); +#else + browse("http://www.dlang.org/dmd-linux.html"); +#endif +#endif +#if __APPLE__ +#if DMDV1 + browse("http://www.digitalmars.com/d/1.0/dmd-osx.html"); +#else + browse("http://www.dlang.org/dmd-osx.html"); +#endif +#endif +#if __FreeBSD__ +#if DMDV1 + browse("http://www.digitalmars.com/d/1.0/dmd-freebsd.html"); +#else + browse("http://www.dlang.org/dmd-freebsd.html"); +#endif +#endif +#if __OpenBSD__ +#if DMDV1 + browse("http://www.digitalmars.com/d/1.0/dmd-openbsd.html"); +#else + browse("http://www.dlang.org/dmd-openbsd.html"); +#endif +#endif + exit(EXIT_SUCCESS); + } + else if (strcmp(p + 1, "run") == 0) + { global.params.run = 1; + global.params.runargs_length = ((i >= argcstart) ? argc : argcstart) - i - 1; + if (global.params.runargs_length) + { + files.push(argv[i + 1]); + global.params.runargs = &argv[i + 2]; + i += global.params.runargs_length; + global.params.runargs_length--; + } + else + { global.params.run = 0; + goto Lnoarg; + } + } + else + { + Lerror: + error("unrecognized switch '%s'", argv[i]); + continue; + + Lnoarg: + error("argument expected for switch '%s'", argv[i]); + continue; + } + } + else + { +#if TARGET_WINDOS + char *ext = FileName::ext(p); + if (ext && FileName::compare(ext, "exe") == 0) + { + global.params.objname = p; + continue; + } +#endif + files.push(p); + } + } + if (global.errors) + { + fatal(); + } + if (files.dim == 0) + { usage(); + return EXIT_FAILURE; + } + + if (!setdebuglib) + global.params.debuglibname = global.params.defaultlibname; + +#if TARGET_OSX + global.params.pic = 1; +#endif + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + if (global.params.lib && global.params.dll) + error("cannot mix -lib and -shared\n"); +#endif + + if (global.params.release) + { global.params.useInvariants = 0; + global.params.useIn = 0; + global.params.useOut = 0; + global.params.useAssert = 0; + global.params.useArrayBounds = 1; + global.params.useSwitchError = 0; + } + if (noboundscheck) + global.params.useArrayBounds = 0; + + if (global.params.run) + global.params.quiet = 1; + + if (global.params.useUnitTests) + global.params.useAssert = 1; + + if (!global.params.obj || global.params.lib) + global.params.link = 0; + + if (global.params.link) + { + global.params.exefile = global.params.objname; + global.params.oneobj = 1; + if (global.params.objname) + { + /* Use this to name the one object file with the same + * name as the exe file. + */ + global.params.objname = FileName::forceExt(global.params.objname, global.obj_ext)->toChars(); + + /* If output directory is given, use that path rather than + * the exe file path. + */ + if (global.params.objdir) + { char *name = FileName::name(global.params.objname); + global.params.objname = FileName::combine(global.params.objdir, name); + } + } + } + else if (global.params.lib) + { + global.params.libname = global.params.objname; + global.params.objname = NULL; + + // Haven't investigated handling these options with multiobj + if (!global.params.cov && !global.params.trace +#if 0 && TARGET_WINDOS + /* multiobj causes class/struct debug info to be attached to init-data, + * but this will not be linked into the executable, so this info is lost. + * Bugzilla 4014 + */ + && !global.params.symdebug +#endif + ) + global.params.multiobj = 1; + } + else if (global.params.run) + { + error("flags conflict with -run"); + fatal(); + } + else + { + if (global.params.objname && files.dim > 1) + { + global.params.oneobj = 1; + //error("multiple source files, but only one .obj name"); + //fatal(); + } + } + if (global.params.is64bit) + { + VersionCondition::addPredefinedGlobalIdent("D_InlineAsm_X86_64"); + VersionCondition::addPredefinedGlobalIdent("X86_64"); + VersionCondition::addPredefinedGlobalIdent("D_LP64"); + VersionCondition::addPredefinedGlobalIdent("D_SIMD"); +#if TARGET_WINDOS + VersionCondition::addPredefinedGlobalIdent("Win64"); +#endif + } + else + { + VersionCondition::addPredefinedGlobalIdent("D_InlineAsm"); + VersionCondition::addPredefinedGlobalIdent("D_InlineAsm_X86"); + VersionCondition::addPredefinedGlobalIdent("X86"); +#if TARGET_OSX + VersionCondition::addPredefinedGlobalIdent("D_SIMD"); +#endif +#if TARGET_WINDOS + VersionCondition::addPredefinedGlobalIdent("Win32"); +#endif + } + if (global.params.doDocComments) + VersionCondition::addPredefinedGlobalIdent("D_Ddoc"); + if (global.params.cov) + VersionCondition::addPredefinedGlobalIdent("D_Coverage"); + if (global.params.pic) + VersionCondition::addPredefinedGlobalIdent("D_PIC"); +#if DMDV2 + if (global.params.useUnitTests) + VersionCondition::addPredefinedGlobalIdent("unittest"); +#endif + + // Initialization + Type::init(); + Id::initialize(); + Module::init(); + initPrecedence(); + + if (global.params.verbose) + { printf("binary %s\n", argv[0]); + printf("version %s\n", global.version); + printf("config %s\n", inifilename ? inifilename : "(none)"); + } + + //printf("%d source files\n",files.dim); + + // Build import search path + if (global.params.imppath) + { + for (size_t i = 0; i < global.params.imppath->dim; i++) + { + char *path = (*global.params.imppath)[i]; + Strings *a = FileName::splitPath(path); + + if (a) + { + if (!global.path) + global.path = new Strings(); + global.path->append(a); + } + } + } + + // Build string import search path + if (global.params.fileImppath) + { + for (size_t i = 0; i < global.params.fileImppath->dim; i++) + { + char *path = global.params.fileImppath->tdata()[i]; + Strings *a = FileName::splitPath(path); + + if (a) + { + if (!global.filePath) + global.filePath = new Strings(); + global.filePath->append(a); + } + } + } + + // Create Modules + Modules modules; + modules.reserve(files.dim); + int firstmodule = 1; + for (size_t i = 0; i < files.dim; i++) + { + char *ext; + char *name; + + p = files.tdata()[i]; + +#if _WIN32 + // Convert / to \ so linker will work + for (size_t i = 0; p[i]; i++) + { + if (p[i] == '/') + p[i] = '\\'; + } +#endif + + p = FileName::name(p); // strip path + ext = FileName::ext(p); + if (ext) + { /* Deduce what to do with a file based on its extension + */ + if (FileName::equals(ext, global.obj_ext)) + { + global.params.objfiles->push(files.tdata()[i]); + libmodules.push(files.tdata()[i]); + continue; + } + + if (FileName::equals(ext, global.lib_ext)) + { + global.params.libfiles->push(files.tdata()[i]); + libmodules.push(files.tdata()[i]); + continue; + } + + if (strcmp(ext, global.ddoc_ext) == 0) + { + global.params.ddocfiles->push(files.tdata()[i]); + continue; + } + + if (FileName::equals(ext, global.json_ext)) + { + global.params.doXGeneration = 1; + global.params.xfilename = files.tdata()[i]; + continue; + } + + if (FileName::equals(ext, global.map_ext)) + { + global.params.mapfile = files.tdata()[i]; + continue; + } + +#if TARGET_WINDOS + if (FileName::equals(ext, "res")) + { + global.params.resfile = files.tdata()[i]; + continue; + } + + if (FileName::equals(ext, "def")) + { + global.params.deffile = files.tdata()[i]; + continue; + } + + if (FileName::equals(ext, "exe")) + { + assert(0); // should have already been handled + } +#endif + + /* Examine extension to see if it is a valid + * D source file extension + */ + if (FileName::equals(ext, global.mars_ext) || + FileName::equals(ext, global.hdr_ext) || + FileName::equals(ext, "dd") || + FileName::equals(ext, "htm") || + FileName::equals(ext, "html") || + FileName::equals(ext, "xhtml")) + { + ext--; // skip onto '.' + assert(*ext == '.'); + name = (char *)mem.malloc((ext - p) + 1); + memcpy(name, p, ext - p); + name[ext - p] = 0; // strip extension + + if (name[0] == 0 || + strcmp(name, "..") == 0 || + strcmp(name, ".") == 0) + { + Linvalid: + error("invalid file name '%s'", files.tdata()[i]); + fatal(); + } + } + else + { error("unrecognized file extension %s\n", ext); + fatal(); + } + } + else + { name = p; + if (!*name) + goto Linvalid; + } + + /* At this point, name is the D source file name stripped of + * its path and extension. + */ + + Identifier *id = Lexer::idPool(name); + m = new Module(files[i], id, global.params.doDocComments, global.params.doHdrGeneration); + modules.push(m); + + if (firstmodule) + { global.params.objfiles->push(m->objfile->name->str); + firstmodule = 0; + } + } + +#if WINDOWS_SEH + __try + { +#endif + // Read files +#define ASYNCREAD 1 +#if ASYNCREAD + // Multi threaded + AsyncRead *aw = AsyncRead::create(modules.dim); + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + aw->addFile(m->srcfile); + } + aw->start(); +#else + // Single threaded + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + m->read(0); + } +#endif + + // Parse files + bool anydocfiles = false; + size_t filecount = modules.dim; + for (size_t filei = 0, modi = 0; filei < filecount; filei++, modi++) + { + m = modules[modi]; + if (global.params.verbose) + printf("parse %s\n", m->toChars()); + if (!Module::rootModule) + Module::rootModule = m; + m->importedFrom = m; + if (!global.params.oneobj || modi == 0 || m->isDocFile) + m->deleteObjFile(); +#if ASYNCREAD + if (aw->read(filei)) + { + error("cannot read file %s", m->srcfile->name->toChars()); + } +#endif + m->parse(); + if (m->isDocFile) + { + anydocfiles = true; + m->gendocfile(); + + // Remove m from list of modules + modules.remove(modi); + modi--; + + // Remove m's object file from list of object files + for (size_t j = 0; j < global.params.objfiles->dim; j++) + { + if (m->objfile->name->str == global.params.objfiles->tdata()[j]) + { + global.params.objfiles->remove(j); + break; + } + } + + if (global.params.objfiles->dim == 0) + global.params.link = 0; + } + } +#if ASYNCREAD + AsyncRead::dispose(aw); +#endif + + if (anydocfiles && modules.dim && + (global.params.oneobj || global.params.objname)) + { + error("conflicting Ddoc and obj generation options"); + fatal(); + } + if (global.errors) + fatal(); + if (global.params.doHdrGeneration) + { + /* Generate 'header' import files. + * Since 'header' import files must be independent of command + * line switches and what else is imported, they are generated + * before any semantic analysis. + */ + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("import %s\n", m->toChars()); + m->genhdrfile(); + } + } + if (global.errors) + fatal(); + + // load all unconditional imports for better symbol resolving + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("importall %s\n", m->toChars()); + m->importAll(0); + } + if (global.errors) + fatal(); + + backend_init(); + + // Do semantic analysis + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("semantic %s\n", m->toChars()); + m->semantic(); + } + if (global.errors) + fatal(); + + Module::dprogress = 1; + Module::runDeferredSemantic(); + + // Do pass 2 semantic analysis + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("semantic2 %s\n", m->toChars()); + m->semantic2(); + } + if (global.errors) + fatal(); + + // Do pass 3 semantic analysis + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("semantic3 %s\n", m->toChars()); + m->semantic3(); + } + if (global.errors) + fatal(); + + if (global.params.moduleDeps != NULL) + { + assert(global.params.moduleDepsFile != NULL); + + File deps(global.params.moduleDepsFile); + OutBuffer* ob = global.params.moduleDeps; + deps.setbuffer((void*)ob->data, ob->offset); + deps.writev(); + } + + + // Scan for functions to inline + if (global.params.useInline) + { + /* The problem with useArrayBounds and useAssert is that the + * module being linked to may not have generated them, so if + * we inline functions from those modules, the symbols for them will + * not be found at link time. + */ + if (!global.params.useArrayBounds && !global.params.useAssert) + { + // Do pass 3 semantic analysis on all imported modules, + // since otherwise functions in them cannot be inlined + for (size_t i = 0; i < Module::amodules.dim; i++) + { + m = Module::amodules[i]; + if (global.params.verbose) + printf("semantic3 %s\n", m->toChars()); + m->semantic3(); + } + if (global.errors) + fatal(); + } + + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("inline scan %s\n", m->toChars()); + m->inlineScan(); + } + } + + // Do not attempt to generate output files if errors or warnings occurred + if (global.errors || global.warnings) + fatal(); + + printCtfePerformanceStats(); + + Library *library = NULL; + if (global.params.lib) + { + library = new Library(); + library->setFilename(global.params.objdir, global.params.libname); + + // Add input object and input library files to output library + for (size_t i = 0; i < libmodules.dim; i++) + { + char *p = libmodules[i]; + library->addObject(p, NULL, 0); + } + } + + // Generate output files + + if (global.params.doXGeneration) + json_generate(&modules); + + if (global.params.oneobj) + { + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("code %s\n", m->toChars()); + if (i == 0) + obj_start(m->srcfile->toChars()); + m->genobjfile(0); + if (!global.errors && global.params.doDocComments) + m->gendocfile(); + } + if (!global.errors && modules.dim) + { + obj_end(library, modules.tdata()[0]->objfile); + } + } + else + { + for (size_t i = 0; i < modules.dim; i++) + { + m = modules[i]; + if (global.params.verbose) + printf("code %s\n", m->toChars()); + if (global.params.obj) + { obj_start(m->srcfile->toChars()); + m->genobjfile(global.params.multiobj); + obj_end(library, m->objfile); + obj_write_deferred(library); + } + if (global.errors) + { + if (!global.params.lib) + m->deleteObjFile(); + } + else + { + if (global.params.doDocComments) + m->gendocfile(); + } + } + } + + if (global.params.lib && !global.errors) + library->write(); + +#if WINDOWS_SEH + } + __except (__ehfilter(GetExceptionInformation())) + { + printf("Stack overflow\n"); + fatal(); + } +#endif + backend_term(); + if (global.errors) + fatal(); + + if (!global.params.objfiles->dim) + { + if (global.params.link) + error("no object files to link"); + } + else + { + if (global.params.link) + status = runLINK(); + + if (global.params.run) + { + if (!status) + { + status = runProgram(); + + /* Delete .obj files and .exe file + */ + for (size_t i = 0; i < modules.dim; i++) + { + Module *m = modules[i]; + m->deleteObjFile(); + if (global.params.oneobj) + break; + } + deleteExeFile(); + } + } + } + + return status; +} + + + +/*********************************** + * Parse and append contents of environment variable envvar + * to argc and argv[]. + * The string is separated into arguments, processing \ and ". + */ + +void getenv_setargv(const char *envvar, int *pargc, char** *pargv) +{ + char *p; + + int instring; + int slash; + char c; + + char *env = getenv(envvar); + if (!env) + return; + + env = mem.strdup(env); // create our own writable copy + + int argc = *pargc; + Strings *argv = new Strings(); + argv->setDim(argc); + + for (size_t i = 0; i < argc; i++) + argv->tdata()[i] = (*pargv)[i]; + + size_t j = 1; // leave argv[0] alone + while (1) + { + int wildcard = 1; // do wildcard expansion + switch (*env) + { + case ' ': + case '\t': + env++; + break; + + case 0: + goto Ldone; + + case '"': + wildcard = 0; + default: + argv->push(env); // append + //argv->insert(j, env); // insert at position j + j++; + argc++; + p = env; + slash = 0; + instring = 0; + c = 0; + + while (1) + { + c = *env++; + switch (c) + { + case '"': + p -= (slash >> 1); + if (slash & 1) + { p--; + goto Laddc; + } + instring ^= 1; + slash = 0; + continue; + + case ' ': + case '\t': + if (instring) + goto Laddc; + *p = 0; + //if (wildcard) + //wildcardexpand(); // not implemented + break; + + case '\\': + slash++; + *p++ = c; + continue; + + case 0: + *p = 0; + //if (wildcard) + //wildcardexpand(); // not implemented + goto Ldone; + + default: + Laddc: + slash = 0; + *p++ = c; + continue; + } + break; + } + } + } + +Ldone: + *pargc = argc; + *pargv = argv->tdata(); +} + +#if WINDOWS_SEH + +long __cdecl __ehfilter(LPEXCEPTION_POINTERS ep) +{ + //printf("%x\n", ep->ExceptionRecord->ExceptionCode); + if (ep->ExceptionRecord->ExceptionCode == STATUS_STACK_OVERFLOW) + { +#ifndef DEBUG + return EXCEPTION_EXECUTE_HANDLER; +#endif + } + return EXCEPTION_CONTINUE_SEARCH; +} + +#endif diff --git a/mars.h b/mars.h new file mode 100644 index 00000000..24cd00b2 --- /dev/null +++ b/mars.h @@ -0,0 +1,441 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_MARS_H +#define DMD_MARS_H + +#ifdef __DMC__ +#pragma once +#endif + +/* +It is very important to use version control macros correctly - the +idea is that host and target are independent. If these are done +correctly, cross compilers can be built. +The host compiler and host operating system are also different, +and are predefined by the host compiler. The ones used in +dmd are: + +Macros defined by the compiler, not the code: + + Compiler: + __DMC__ Digital Mars compiler + _MSC_VER Microsoft compiler + __GNUC__ Gnu compiler + __clang__ Clang compiler + + Host operating system: + _WIN32 Microsoft NT, Windows 95, Windows 98, Win32s, + Windows 2000, Win XP, Vista + _WIN64 Windows for AMD64 + linux Linux + __APPLE__ Mac OSX + __FreeBSD__ FreeBSD + __OpenBSD__ OpenBSD + __sun&&__SVR4 Solaris, OpenSolaris (yes, both macros are necessary) + +For the target systems, there are the target operating system and +the target object file format: + + Target operating system: + TARGET_WINDOS Covers 32 bit windows and 64 bit windows + TARGET_LINUX Covers 32 and 64 bit linux + TARGET_OSX Covers 32 and 64 bit Mac OSX + TARGET_FREEBSD Covers 32 and 64 bit FreeBSD + TARGET_OPENBSD Covers 32 and 64 bit OpenBSD + TARGET_SOLARIS Covers 32 and 64 bit Solaris + TARGET_NET Covers .Net + + It is expected that the compiler for each platform will be able + to generate 32 and 64 bit code from the same compiler binary. + + Target object module format: + OMFOBJ Intel Object Module Format, used on Windows + ELFOBJ Elf Object Module Format, used on linux, FreeBSD, OpenBSD and Solaris + MACHOBJ Mach-O Object Module Format, used on Mac OSX + + There are currently no macros for byte endianness order. + */ + + +#include +#include +#include + +#ifdef __DMC__ +#ifdef DEBUG +#undef assert +#define assert(e) (static_cast((e) || (printf("assert %s(%d) %s\n", __FILE__, __LINE__, #e), halt()))) +#endif +#endif + +#ifdef DEBUG +#define UNITTEST 1 +#endif +void unittests(); + +#ifdef IN_GCC +/* Changes for the GDC compiler by David Friedman */ +#endif + +#define DMDV1 0 +#define DMDV2 1 // Version 2.0 features +#define BREAKABI 1 // 0 if not ready to break the ABI just yet +#define STRUCTTHISREF DMDV2 // if 'this' for struct is a reference, not a pointer +#define SNAN_DEFAULT_INIT DMDV2 // if floats are default initialized to signalling NaN +#define SARRAYVALUE DMDV2 // static arrays are value types +#define MODULEINFO_IS_STRUCT DMDV2 // if ModuleInfo is a struct rather than a class + +// Set if C++ mangling is done by the front end +#define CPP_MANGLE (DMDV2 && (TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS)) + +/* Other targets are TARGET_LINUX, TARGET_OSX, TARGET_FREEBSD, TARGET_OPENBSD and + * TARGET_SOLARIS, which are + * set on the command line via the compiler makefile. + */ + +#if _WIN32 +#ifndef TARGET_WINDOS +#define TARGET_WINDOS 1 // Windows dmd generates Windows targets +#endif +#ifndef OMFOBJ +#define OMFOBJ TARGET_WINDOS +#endif +#endif + +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +#ifndef ELFOBJ +#define ELFOBJ 1 +#endif +#endif + +#if TARGET_OSX +#ifndef MACHOBJ +#define MACHOBJ 1 +#endif +#endif + + +struct OutBuffer; + +// Can't include arraytypes.h here, need to declare these directly. +template struct ArrayBase; +typedef ArrayBase Identifiers; +typedef ArrayBase Strings; + +// Put command line switches in here +struct Param +{ + char obj; // write object file + char link; // perform link + char dll; // generate shared dynamic library + char lib; // write library file instead of object file(s) + char multiobj; // break one object file into multiple ones + char oneobj; // write one object file instead of multiple ones + char trace; // insert profiling hooks + char quiet; // suppress non-error messages + char verbose; // verbose compile + char vtls; // identify thread local variables + char symdebug; // insert debug symbolic information + char alwaysframe; // always emit standard stack frame + char optimize; // run optimizer + char map; // generate linker .map file + char cpu; // target CPU + char is64bit; // generate 64 bit code + char isLinux; // generate code for linux + char isOSX; // generate code for Mac OSX + char isWindows; // generate code for Windows + char isFreeBSD; // generate code for FreeBSD + char isOPenBSD; // generate code for OpenBSD + char isSolaris; // generate code for Solaris + char scheduler; // which scheduler to use + char useDeprecated; // allow use of deprecated features + char useAssert; // generate runtime code for assert()'s + char useInvariants; // generate class invariant checks + char useIn; // generate precondition checks + char useOut; // generate postcondition checks + char useArrayBounds; // 0: no array bounds checks + // 1: array bounds checks for safe functions only + // 2: array bounds checks for all functions + char noboundscheck; // no array bounds checking at all + char useSwitchError; // check for switches without a default + char useUnitTests; // generate unittest code + char useInline; // inline expand functions + char release; // build release version + char preservePaths; // !=0 means don't strip path from source file + char warnings; // 0: enable warnings + // 1: warnings as errors + // 2: informational warnings (no errors) + char pic; // generate position-independent-code for shared libs + char cov; // generate code coverage data + char nofloat; // code should not pull in floating point support + char Dversion; // D version number + char ignoreUnsupportedPragmas; // rather than error on them + char enforcePropertySyntax; + + char *argv0; // program name + Strings *imppath; // array of char*'s of where to look for import modules + Strings *fileImppath; // array of char*'s of where to look for file import modules + char *objdir; // .obj/.lib file output directory + char *objname; // .obj file output name + char *libname; // .lib file output name + + char doDocComments; // process embedded documentation comments + char *docdir; // write documentation file to docdir directory + char *docname; // write documentation file to docname + Strings *ddocfiles; // macro include files for Ddoc + + char doHdrGeneration; // process embedded documentation comments + char *hdrdir; // write 'header' file to docdir directory + char *hdrname; // write 'header' file to docname + + char doXGeneration; // write JSON file + char *xfilename; // write JSON file to xfilename + + unsigned debuglevel; // debug level + Strings *debugids; // debug identifiers + + unsigned versionlevel; // version level + Strings *versionids; // version identifiers + + bool dump_source; + + const char *defaultlibname; // default library for non-debug builds + const char *debuglibname; // default library for debug builds + + char *moduleDepsFile; // filename for deps output + OutBuffer *moduleDeps; // contents to be written to deps file + + // Hidden debug switches + char debuga; + char debugb; + char debugc; + char debugf; + char debugr; + char debugw; + char debugx; + char debugy; + + char run; // run resulting executable + size_t runargs_length; + char** runargs; // arguments for executable + + // Linker stuff + Strings *objfiles; + Strings *linkswitches; + Strings *libfiles; + char *deffile; + char *resfile; + char *exefile; + char *mapfile; +}; + +struct Global +{ + const char *mars_ext; + const char *sym_ext; + const char *obj_ext; + const char *lib_ext; + const char *dll_ext; + const char *doc_ext; // for Ddoc generated files + const char *ddoc_ext; // for Ddoc macro include files + const char *hdr_ext; // for D 'header' import files + const char *json_ext; // for JSON files + const char *map_ext; // for .map files + const char *copyright; + const char *written; + Strings *path; // Array of char*'s which form the import lookup path + Strings *filePath; // Array of char*'s which form the file import lookup path + int structalign; + const char *version; + + Param params; + unsigned errors; // number of errors reported so far + unsigned warnings; // number of warnings reported so far + unsigned gag; // !=0 means gag reporting of errors & warnings + unsigned gaggedErrors; // number of errors reported while gagged + + // Start gagging. Return the current number of gagged errors + unsigned startGagging(); + + /* End gagging, restoring the old gagged state. + * Return true if errors occured while gagged. + */ + bool endGagging(unsigned oldGagged); + + Global(); +}; + +extern Global global; + +/* Set if Windows Structured Exception Handling C extensions are supported. + * Apparently, VC has dropped support for these? + */ +#define WINDOWS_SEH (_WIN32 && __DMC__) + + +#ifdef __DMC__ + typedef _Complex long double complex_t; +#else + #ifndef IN_GCC + #include "complex_t.h" + #endif + #ifdef __APPLE__ + //#include "complex.h"//This causes problems with include the c++ and not the C "complex.h" + #endif +#endif + +// Be careful not to care about sign when using dinteger_t +//typedef uint64_t integer_t; +typedef uint64_t dinteger_t; // use this instead of integer_t to + // avoid conflicts with system #include's + +// Signed and unsigned variants +typedef int64_t sinteger_t; +typedef uint64_t uinteger_t; + +typedef int8_t d_int8; +typedef uint8_t d_uns8; +typedef int16_t d_int16; +typedef uint16_t d_uns16; +typedef int32_t d_int32; +typedef uint32_t d_uns32; +typedef int64_t d_int64; +typedef uint64_t d_uns64; + +typedef float d_float32; +typedef double d_float64; +typedef long double d_float80; + +typedef d_uns8 d_char; +typedef d_uns16 d_wchar; +typedef d_uns32 d_dchar; + +#ifdef IN_GCC +#include "d-gcc-real.h" +#else +typedef long double real_t; +#endif + +// Modify OutBuffer::writewchar to write the correct size of wchar +#if _WIN32 +#define writewchar writeword +#else +// This needs a configuration test... +#define writewchar write4 +#endif + +#ifdef IN_GCC +#include "d-gcc-complex_t.h" +#endif + +struct Module; + +//typedef unsigned Loc; // file location +struct Loc +{ + const char *filename; + unsigned linnum; + + Loc() + { + linnum = 0; + filename = NULL; + } + + Loc(int x) + { + linnum = x; + filename = NULL; + } + + Loc(Module *mod, unsigned linnum); + + char *toChars(); + bool equals(const Loc& loc); +}; + +#ifndef GCC_SAFE_DMD +#define TRUE 1 +#define FALSE 0 +#endif + +#define INTERFACE_OFFSET 0 // if 1, put classinfo as first entry + // in interface vtbl[]'s +#define INTERFACE_VIRTUAL 0 // 1 means if an interface appears + // in the inheritance graph multiple + // times, only one is used + +enum LINK +{ + LINKdefault, + LINKd, + LINKc, + LINKcpp, + LINKwindows, + LINKpascal, +}; + +enum DYNCAST +{ + DYNCAST_OBJECT, + DYNCAST_EXPRESSION, + DYNCAST_DSYMBOL, + DYNCAST_TYPE, + DYNCAST_IDENTIFIER, + DYNCAST_TUPLE, +}; + +enum MATCH +{ + MATCHnomatch, // no match + MATCHconvert, // match with conversions +#if DMDV2 + MATCHconst, // match with conversion to const +#endif + MATCHexact // exact match +}; + +typedef uint64_t StorageClass; + + +void warning(Loc loc, const char *format, ...); +void error(Loc loc, const char *format, ...); +void errorSupplemental(Loc loc, const char *format, ...); +void verror(Loc loc, const char *format, va_list); +void vwarning(Loc loc, const char *format, va_list); +void verrorSupplemental(Loc loc, const char *format, va_list); +void fatal(); +void err_nomem(); +int runLINK(); +void deleteExeFile(); +int runProgram(); +const char *inifile(const char *argv0, const char *inifile); +void halt(); +void util_progress(); + +/*** Where to send error messages ***/ +#if IN_GCC +#define stdmsg stderr +#else +#define stdmsg stderr +#endif + +struct Dsymbol; +struct Library; +struct File; +void obj_start(char *srcfile); +void obj_end(Library *library, File *objfile); +void obj_append(Dsymbol *s); +void obj_write_deferred(Library *library); + +const char *importHint(const char *s); + +#endif /* DMD_MARS_H */ diff --git a/module.c b/module.c new file mode 100644 index 00000000..716f36d8 --- /dev/null +++ b/module.c @@ -0,0 +1,1190 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#if (defined (__SVR4) && defined (__sun)) +#include +#endif + +#if defined(_MSC_VER) || defined(__MINGW32__) +#include +#endif + +#if IN_GCC +#include "gdc_alloca.h" +#endif + +#include "rmem.h" + +#include "mars.h" +#include "module.h" +#include "parse.h" +#include "scope.h" +#include "identifier.h" +#include "id.h" +#include "import.h" +#include "dsymbol.h" +#include "hdrgen.h" +#include "lexer.h" + +#define MARS 1 +#include "html.h" + +#ifdef IN_GCC +#include "d-dmd-gcc.h" +#endif + +ClassDeclaration *Module::moduleinfo; + +Module *Module::rootModule; +DsymbolTable *Module::modules; +Modules Module::amodules; + +Dsymbols Module::deferred; // deferred Dsymbol's needing semantic() run on them +unsigned Module::dprogress; + +void Module::init() +{ + modules = new DsymbolTable(); +} + +Module::Module(char *filename, Identifier *ident, int doDocComment, int doHdrGen) + : Package(ident) +{ + FileName *srcfilename; + FileName *objfilename; + FileName *symfilename; + +// printf("Module::Module(filename = '%s', ident = '%s')\n", filename, ident->toChars()); + this->arg = filename; + md = NULL; + errors = 0; + numlines = 0; + members = NULL; + isHtml = 0; + isDocFile = 0; + needmoduleinfo = 0; +#ifdef IN_GCC + strictlyneedmoduleinfo = 0; +#endif + selfimports = 0; + insearch = 0; + searchCacheIdent = NULL; + searchCacheSymbol = NULL; + searchCacheFlags = 0; + semanticstarted = 0; + semanticRun = 0; + decldefs = NULL; + vmoduleinfo = NULL; + massert = NULL; + munittest = NULL; + marray = NULL; + sictor = NULL; + sctor = NULL; + sdtor = NULL; + ssharedctor = NULL; + sshareddtor = NULL; + stest = NULL; + sfilename = NULL; + root = 0; + importedFrom = NULL; + srcfile = NULL; + docfile = NULL; + + debuglevel = 0; + debugids = NULL; + debugidsNot = NULL; + versionlevel = 0; + versionids = NULL; + versionidsNot = NULL; + + macrotable = NULL; + escapetable = NULL; + safe = FALSE; + doppelganger = 0; + cov = NULL; + covb = NULL; + + nameoffset = 0; + namelen = 0; + + srcfilename = FileName::defaultExt(filename, global.mars_ext); + if (!srcfilename->equalsExt(global.mars_ext) && + !srcfilename->equalsExt(global.hdr_ext) && + !srcfilename->equalsExt("dd")) + { + if (srcfilename->equalsExt("html") || + srcfilename->equalsExt("htm") || + srcfilename->equalsExt("xhtml")) + { if (!global.params.useDeprecated) + error("html source files is deprecated %s", srcfilename->toChars()); + isHtml = 1; + } + else + { error("source file name '%s' must have .%s extension", srcfilename->toChars(), global.mars_ext); + fatal(); + } + } + + char *argobj; + if (global.params.objname) + argobj = global.params.objname; +#if 0 + else if (global.params.preservePaths) + argobj = filename; + else + argobj = FileName::name(filename); + if (!FileName::absolute(argobj)) + { + argobj = FileName::combine(global.params.objdir, argobj); + } +#else // Bugzilla 3547 + else + { + if (global.params.preservePaths) + argobj = filename; + else + argobj = FileName::name(filename); + if (!FileName::absolute(argobj)) + { + argobj = FileName::combine(global.params.objdir, argobj); + } + } +#endif + + if (global.params.objname) + objfilename = new FileName(argobj, 0); + else + objfilename = FileName::forceExt(argobj, global.obj_ext); + + symfilename = FileName::forceExt(filename, global.sym_ext); + + srcfile = new File(srcfilename); + + if (doDocComment) + { + setDocfile(); + } + + if (doHdrGen) + { + setHdrfile(); + } + + objfile = new File(objfilename); + symfile = new File(symfilename); +} + +void Module::setDocfile() +{ + FileName *docfilename; + char *argdoc; + + if (global.params.docname) + argdoc = global.params.docname; + else if (global.params.preservePaths) + argdoc = (char *)arg; + else + argdoc = FileName::name((char *)arg); + if (!FileName::absolute(argdoc)) + { //FileName::ensurePathExists(global.params.docdir); + argdoc = FileName::combine(global.params.docdir, argdoc); + } + if (global.params.docname) + docfilename = new FileName(argdoc, 0); + else + docfilename = FileName::forceExt(argdoc, global.doc_ext); + + if (docfilename->equals(srcfile->name)) + { error("Source file and documentation file have same name '%s'", srcfile->name->str); + fatal(); + } + + docfile = new File(docfilename); +} + +void Module::setHdrfile() +{ + FileName *hdrfilename; + char *arghdr; + + if (global.params.hdrname) + arghdr = global.params.hdrname; + else if (global.params.preservePaths) + arghdr = (char *)arg; + else + arghdr = FileName::name((char *)arg); + if (!FileName::absolute(arghdr)) + { //FileName::ensurePathExists(global.params.hdrdir); + arghdr = FileName::combine(global.params.hdrdir, arghdr); + } + if (global.params.hdrname) + hdrfilename = new FileName(arghdr, 0); + else + hdrfilename = FileName::forceExt(arghdr, global.hdr_ext); + + if (hdrfilename->equals(srcfile->name)) + { error("Source file and 'header' file have same name '%s'", srcfile->name->str); + fatal(); + } + + hdrfile = new File(hdrfilename); +} + +void Module::deleteObjFile() +{ + if (global.params.obj) + objfile->remove(); + if (docfile) + docfile->remove(); +} + +Module::~Module() +{ +} + +const char *Module::kind() +{ + return "module"; +} + +Module *Module::load(Loc loc, Identifiers *packages, Identifier *ident) +{ Module *m; + char *filename; + + //printf("Module::load(ident = '%s')\n", ident->toChars()); + + // Build module filename by turning: + // foo.bar.baz + // into: + // foo\bar\baz + filename = ident->toChars(); + if (packages && packages->dim) + { + OutBuffer buf; + + for (size_t i = 0; i < packages->dim; i++) + { Identifier *pid = packages->tdata()[i]; + + buf.writestring(pid->toChars()); +#if _WIN32 + buf.writeByte('\\'); +#else + buf.writeByte('/'); +#endif + } + buf.writestring(filename); + buf.writeByte(0); + filename = (char *)buf.extractData(); + } + + m = new Module(filename, ident, 0, 0); + m->loc = loc; + + /* Search along global.path for .di file, then .d file. + */ + char *result = NULL; + FileName *fdi = FileName::forceExt(filename, global.hdr_ext); + FileName *fd = FileName::forceExt(filename, global.mars_ext); + char *sdi = fdi->toChars(); + char *sd = fd->toChars(); + + if (FileName::exists(sdi)) + result = sdi; + else if (FileName::exists(sd)) + result = sd; + else if (FileName::absolute(filename)) + ; + else if (!global.path) + ; + else + { + for (size_t i = 0; i < global.path->dim; i++) + { + char *p = (*global.path)[i]; + char *n = FileName::combine(p, sdi); + if (FileName::exists(n)) + { result = n; + break; + } + mem.free(n); + n = FileName::combine(p, sd); + if (FileName::exists(n)) + { result = n; + break; + } + mem.free(n); + } + } + if (result) + m->srcfile = new File(result); + + if (global.params.verbose) + { + printf("import "); + if (packages) + { + for (size_t i = 0; i < packages->dim; i++) + { Identifier *pid = packages->tdata()[i]; + printf("%s.", pid->toChars()); + } + } + printf("%s\t(%s)\n", ident->toChars(), m->srcfile->toChars()); + } + + m->read(loc); + m->parse(); + +#ifdef IN_GCC + d_gcc_magic_module(m); +#endif + + return m; +} + +void Module::read(Loc loc) +{ + //printf("Module::read('%s') file '%s'\n", toChars(), srcfile->toChars()); + if (srcfile->read()) + { error(loc, "is in file '%s' which cannot be read", srcfile->toChars()); + if (!global.gag) + { /* Print path + */ + if (global.path) + { + for (size_t i = 0; i < global.path->dim; i++) + { + char *p = global.path->tdata()[i]; + fprintf(stdmsg, "import path[%zd] = %s\n", i, p); + } + } + else + fprintf(stdmsg, "Specify path to file '%s' with -I switch\n", srcfile->toChars()); + } + fatal(); + } +} + +inline unsigned readwordLE(unsigned short *p) +{ +#if LITTLE_ENDIAN + return *p; +#else + return (((unsigned char *)p)[1] << 8) | ((unsigned char *)p)[0]; +#endif +} + +inline unsigned readwordBE(unsigned short *p) +{ + return (((unsigned char *)p)[0] << 8) | ((unsigned char *)p)[1]; +} + +inline unsigned readlongLE(unsigned *p) +{ +#if LITTLE_ENDIAN + return *p; +#else + return ((unsigned char *)p)[0] | + (((unsigned char *)p)[1] << 8) | + (((unsigned char *)p)[2] << 16) | + (((unsigned char *)p)[3] << 24); +#endif +} + +inline unsigned readlongBE(unsigned *p) +{ + return ((unsigned char *)p)[3] | + (((unsigned char *)p)[2] << 8) | + (((unsigned char *)p)[1] << 16) | + (((unsigned char *)p)[0] << 24); +} + +#if IN_GCC +void Module::parse(bool dump_source) +#else +void Module::parse() +#endif +{ char *srcname; + unsigned char *buf; + unsigned buflen; + unsigned le; + unsigned bom; + + //printf("Module::parse()\n"); + + srcname = srcfile->name->toChars(); + //printf("Module::parse(srcname = '%s')\n", srcname); + + buf = srcfile->buffer; + buflen = srcfile->len; + + if (buflen >= 2) + { + /* Convert all non-UTF-8 formats to UTF-8. + * BOM : http://www.unicode.org/faq/utf_bom.html + * 00 00 FE FF UTF-32BE, big-endian + * FF FE 00 00 UTF-32LE, little-endian + * FE FF UTF-16BE, big-endian + * FF FE UTF-16LE, little-endian + * EF BB BF UTF-8 + */ + + bom = 1; // assume there's a BOM + if (buf[0] == 0xFF && buf[1] == 0xFE) + { + if (buflen >= 4 && buf[2] == 0 && buf[3] == 0) + { // UTF-32LE + le = 1; + + Lutf32: + OutBuffer dbuf; + unsigned *pu = (unsigned *)(buf); + unsigned *pumax = &pu[buflen / 4]; + + if (buflen & 3) + { error("odd length of UTF-32 char source %u", buflen); + fatal(); + } + + dbuf.reserve(buflen / 4); + for (pu += bom; pu < pumax; pu++) + { unsigned u; + + u = le ? readlongLE(pu) : readlongBE(pu); + if (u & ~0x7F) + { + if (u > 0x10FFFF) + { error("UTF-32 value %08x greater than 0x10FFFF", u); + fatal(); + } + dbuf.writeUTF8(u); + } + else + dbuf.writeByte(u); + } + dbuf.writeByte(0); // add 0 as sentinel for scanner + buflen = dbuf.offset - 1; // don't include sentinel in count + buf = (unsigned char *) dbuf.extractData(); + } + else + { // UTF-16LE (X86) + // Convert it to UTF-8 + le = 1; + + Lutf16: + OutBuffer dbuf; + unsigned short *pu = (unsigned short *)(buf); + unsigned short *pumax = &pu[buflen / 2]; + + if (buflen & 1) + { error("odd length of UTF-16 char source %u", buflen); + fatal(); + } + + dbuf.reserve(buflen / 2); + for (pu += bom; pu < pumax; pu++) + { unsigned u; + + u = le ? readwordLE(pu) : readwordBE(pu); + if (u & ~0x7F) + { if (u >= 0xD800 && u <= 0xDBFF) + { unsigned u2; + + if (++pu > pumax) + { error("surrogate UTF-16 high value %04x at EOF", u); + fatal(); + } + u2 = le ? readwordLE(pu) : readwordBE(pu); + if (u2 < 0xDC00 || u2 > 0xDFFF) + { error("surrogate UTF-16 low value %04x out of range", u2); + fatal(); + } + u = (u - 0xD7C0) << 10; + u |= (u2 - 0xDC00); + } + else if (u >= 0xDC00 && u <= 0xDFFF) + { error("unpaired surrogate UTF-16 value %04x", u); + fatal(); + } + else if (u == 0xFFFE || u == 0xFFFF) + { error("illegal UTF-16 value %04x", u); + fatal(); + } + dbuf.writeUTF8(u); + } + else + dbuf.writeByte(u); + } + dbuf.writeByte(0); // add 0 as sentinel for scanner + buflen = dbuf.offset - 1; // don't include sentinel in count + buf = (unsigned char *) dbuf.extractData(); + } + } + else if (buf[0] == 0xFE && buf[1] == 0xFF) + { // UTF-16BE + le = 0; + goto Lutf16; + } + else if (buflen >= 4 && buf[0] == 0 && buf[1] == 0 && buf[2] == 0xFE && buf[3] == 0xFF) + { // UTF-32BE + le = 0; + goto Lutf32; + } + else if (buflen >= 3 && buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF) + { // UTF-8 + + buf += 3; + buflen -= 3; + } + else + { + /* There is no BOM. Make use of Arcane Jill's insight that + * the first char of D source must be ASCII to + * figure out the encoding. + */ + + bom = 0; + if (buflen >= 4) + { if (buf[1] == 0 && buf[2] == 0 && buf[3] == 0) + { // UTF-32LE + le = 1; + goto Lutf32; + } + else if (buf[0] == 0 && buf[1] == 0 && buf[2] == 0) + { // UTF-32BE + le = 0; + goto Lutf32; + } + } + if (buflen >= 2) + { + if (buf[1] == 0) + { // UTF-16LE + le = 1; + goto Lutf16; + } + else if (buf[0] == 0) + { // UTF-16BE + le = 0; + goto Lutf16; + } + } + + // It's UTF-8 + if (buf[0] >= 0x80) + { error("source file must start with BOM or ASCII character, not \\x%02X", buf[0]); + fatal(); + } + } + } + +#ifdef IN_GCC + // dump utf-8 encoded source + if (dump_source) + { // %% srcname could contain a path ... + d_gcc_dump_source(srcname, "utf-8", buf, buflen); + } +#endif + + /* If it starts with the string "Ddoc", then it's a documentation + * source file. + */ + if (buflen >= 4 && memcmp(buf, "Ddoc", 4) == 0) + { + comment = buf + 4; + isDocFile = 1; + if (!docfile) + setDocfile(); + return; + } + if (isHtml) + { + OutBuffer *dbuf = new OutBuffer(); + Html h(srcname, buf, buflen); + h.extractCode(dbuf); + buf = dbuf->data; + buflen = dbuf->offset; +#ifdef IN_GCC + // dump extracted source + if (dump_source) + d_gcc_dump_source(srcname, "d.utf-8", buf, buflen); +#endif + } + Parser p(this, buf, buflen, docfile != NULL); + p.nextToken(); + members = p.parseModule(); + + ::free(srcfile->buffer); + srcfile->buffer = NULL; + srcfile->len = 0; + + md = p.md; + numlines = p.loc.linnum; + + DsymbolTable *dst; + + if (md) + { this->ident = md->id; + this->safe = md->safe; + dst = Package::resolve(md->packages, &this->parent, NULL); + } + else + { + dst = modules; + + /* Check to see if module name is a valid identifier + */ + if (!Lexer::isValidIdentifier(this->ident->toChars())) + error("has non-identifier characters in filename, use module declaration instead"); + } + + // Update global list of modules + if (!dst->insert(this)) + { + Dsymbol *prev = dst->lookup(ident); + assert(prev); + Module *mprev = prev->isModule(); + if (mprev) + error(loc, "from file %s conflicts with another module %s from file %s", + srcname, mprev->toChars(), mprev->srcfile->toChars()); + else + { + Package *pkg = prev->isPackage(); + assert(pkg); + error(loc, "from file %s conflicts with package name %s", + srcname, pkg->toChars()); + } + } + else + { + amodules.push(this); + } +} + +void Module::importAll(Scope *prevsc) +{ + //printf("+Module::importAll(this = %p, '%s'): parent = %p\n", this, toChars(), parent); + + if (scope) + return; // already done + + if (isDocFile) + { + error("is a Ddoc file, cannot import it"); + return; + } + + /* Note that modules get their own scope, from scratch. + * This is so regardless of where in the syntax a module + * gets imported, it is unaffected by context. + * Ignore prevsc. + */ + Scope *sc = Scope::createGlobal(this); // create root scope + + // Add import of "object", even for the "object" module. + // If it isn't there, some compiler rewrites, like + // classinst == classinst -> .object.opEquals(classinst, classinst) + // would fail inside object.d. + if (members->dim == 0 || ((*members)[0])->ident != Id::object) + { + Import *im = new Import(0, NULL, Id::object, NULL, 0); + members->shift(im); + } + + if (!symtab) + { + // Add all symbols into module's symbol table + symtab = new DsymbolTable(); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->addMember(NULL, sc->scopesym, 1); + } + } + // anything else should be run after addMember, so version/debug symbols are defined + + /* Set scope for the symbols so that if we forward reference + * a symbol, it can possibly be resolved on the spot. + * If this works out well, it can be extended to all modules + * before any semantic() on any of them. + */ + setScope(sc); // remember module scope for semantic + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + s->setScope(sc); + } + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->importAll(sc); + } + + sc = sc->pop(); + sc->pop(); // 2 pops because Scope::createGlobal() created 2 +} + +void Module::semantic() +{ + if (semanticstarted) + return; + + //printf("+Module::semantic(this = %p, '%s'): parent = %p\n", this, toChars(), parent); + semanticstarted = 1; + + // Note that modules get their own scope, from scratch. + // This is so regardless of where in the syntax a module + // gets imported, it is unaffected by context. + Scope *sc = scope; // see if already got one from importAll() + if (!sc) + { printf("test2\n"); + Scope::createGlobal(this); // create root scope + } + + //printf("Module = %p, linkage = %d\n", sc->scopesym, sc->linkage); + +#if 0 + // Add import of "object" if this module isn't "object" + if (ident != Id::object) + { + Import *im = new Import(0, NULL, Id::object, NULL, 0); + members->shift(im); + } + + // Add all symbols into module's symbol table + symtab = new DsymbolTable(); + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = (Dsymbol *)members->data[i]; + s->addMember(NULL, sc->scopesym, 1); + } + + /* Set scope for the symbols so that if we forward reference + * a symbol, it can possibly be resolved on the spot. + * If this works out well, it can be extended to all modules + * before any semantic() on any of them. + */ + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = (Dsymbol *)members->data[i]; + s->setScope(sc); + } +#endif + + // Do semantic() on members that don't depend on others + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + //printf("\tModule('%s'): '%s'.semantic0()\n", toChars(), s->toChars()); + s->semantic0(sc); + } + + // Pass 1 semantic routines: do public side of the definition + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + //printf("\tModule('%s'): '%s'.semantic()\n", toChars(), s->toChars()); + s->semantic(sc); + runDeferredSemantic(); + } + + if (!scope) + { sc = sc->pop(); + sc->pop(); // 2 pops because Scope::createGlobal() created 2 + } + semanticRun = semanticstarted; + //printf("-Module::semantic(this = %p, '%s'): parent = %p\n", this, toChars(), parent); +} + +void Module::semantic2() +{ + if (deferred.dim) + { + for (size_t i = 0; i < deferred.dim; i++) + { + Dsymbol *sd = deferred.tdata()[i]; + + sd->error("unable to resolve forward reference in definition"); + } + return; + } + //printf("Module::semantic2('%s'): parent = %p\n", toChars(), parent); + if (semanticstarted >= 2) + return; + assert(semanticstarted == 1); + semanticstarted = 2; + + // Note that modules get their own scope, from scratch. + // This is so regardless of where in the syntax a module + // gets imported, it is unaffected by context. + Scope *sc = Scope::createGlobal(this); // create root scope + //printf("Module = %p\n", sc.scopesym); + + // Pass 2 semantic routines: do initializers and function bodies + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s; + + s = members->tdata()[i]; + s->semantic2(sc); + } + + sc = sc->pop(); + sc->pop(); + semanticRun = semanticstarted; + //printf("-Module::semantic2('%s'): parent = %p\n", toChars(), parent); +} + +void Module::semantic3() +{ + //printf("Module::semantic3('%s'): parent = %p\n", toChars(), parent); + if (semanticstarted >= 3) + return; + assert(semanticstarted == 2); + semanticstarted = 3; + + // Note that modules get their own scope, from scratch. + // This is so regardless of where in the syntax a module + // gets imported, it is unaffected by context. + Scope *sc = Scope::createGlobal(this); // create root scope + //printf("Module = %p\n", sc.scopesym); + + // Pass 3 semantic routines: do initializers and function bodies + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s; + + s = members->tdata()[i]; + //printf("Module %s: %s.semantic3()\n", toChars(), s->toChars()); + s->semantic3(sc); + } + + sc = sc->pop(); + sc->pop(); + semanticRun = semanticstarted; +} + +void Module::inlineScan() +{ + if (semanticstarted >= 4) + return; + assert(semanticstarted == 3); + semanticstarted = 4; + + // Note that modules get their own scope, from scratch. + // This is so regardless of where in the syntax a module + // gets imported, it is unaffected by context. + //printf("Module = %p\n", sc.scopesym); + + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + //if (global.params.verbose) + //printf("inline scan symbol %s\n", s->toChars()); + + s->inlineScan(); + } + semanticRun = semanticstarted; +} + +/**************************************************** + */ + +void Module::gensymfile() +{ + OutBuffer buf; + HdrGenState hgs; + + //printf("Module::gensymfile()\n"); + + buf.printf("// Sym file generated from '%s'", srcfile->toChars()); + buf.writenl(); + + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + s->toCBuffer(&buf, &hgs); + } + + // Transfer image to file + symfile->setbuffer(buf.data, buf.offset); + buf.data = NULL; + + symfile->writev(); +} + +/********************************** + * Determine if we need to generate an instance of ModuleInfo + * for this Module. + */ + +int Module::needModuleInfo() +{ + //printf("needModuleInfo() %s, %d, %d\n", toChars(), needmoduleinfo, global.params.cov); + return needmoduleinfo || global.params.cov; +} + +Dsymbol *Module::search(Loc loc, Identifier *ident, int flags) +{ + /* Since modules can be circularly referenced, + * need to stop infinite recursive searches. + * This is done with the cache. + */ + + //printf("%s Module::search('%s', flags = %d) insearch = %d\n", toChars(), ident->toChars(), flags, insearch); + Dsymbol *s; + if (insearch) + s = NULL; + else if (searchCacheIdent == ident && searchCacheFlags == flags) + { + s = searchCacheSymbol; + //printf("%s Module::search('%s', flags = %d) insearch = %d searchCacheSymbol = %s\n", toChars(), ident->toChars(), flags, insearch, searchCacheSymbol ? searchCacheSymbol->toChars() : "null"); + } + else + { + insearch = 1; + s = ScopeDsymbol::search(loc, ident, flags); + insearch = 0; + + searchCacheIdent = ident; + searchCacheSymbol = s; + searchCacheFlags = flags; + } + return s; +} + +Dsymbol *Module::symtabInsert(Dsymbol *s) +{ + searchCacheIdent = 0; // symbol is inserted, so invalidate cache + return Package::symtabInsert(s); +} + +void Module::clearCache() +{ + for (size_t i = 0; i < amodules.dim; i++) + { Module *m = amodules.tdata()[i]; + m->searchCacheIdent = NULL; + } +} + +/******************************************* + * Can't run semantic on s now, try again later. + */ + +void Module::addDeferredSemantic(Dsymbol *s) +{ + // Don't add it if it is already there + for (size_t i = 0; i < deferred.dim; i++) + { + Dsymbol *sd = deferred.tdata()[i]; + + if (sd == s) + return; + } + + //printf("Module::addDeferredSemantic('%s')\n", s->toChars()); + deferred.push(s); +} + + +/****************************************** + * Run semantic() on deferred symbols. + */ + +void Module::runDeferredSemantic() +{ + if (dprogress == 0) + return; + + static int nested; + if (nested) + return; + //if (deferred.dim) printf("+Module::runDeferredSemantic('%s'), len = %d\n", toChars(), deferred.dim); + nested++; + + size_t len; + do + { + dprogress = 0; + len = deferred.dim; + if (!len) + break; + + Dsymbol **todo; + Dsymbol *tmp; + if (len == 1) + { + todo = &tmp; + } + else + { + todo = (Dsymbol **)alloca(len * sizeof(Dsymbol *)); + assert(todo); + } + memcpy(todo, deferred.tdata(), len * sizeof(Dsymbol *)); + deferred.setDim(0); + + for (size_t i = 0; i < len; i++) + { + Dsymbol *s = todo[i]; + + s->semantic(NULL); + //printf("deferred: %s, parent = %s\n", s->toChars(), s->parent->toChars()); + } + //printf("\tdeferred.dim = %d, len = %d, dprogress = %d\n", deferred.dim, len, dprogress); + } while (deferred.dim < len || dprogress); // while making progress + nested--; + //printf("-Module::runDeferredSemantic('%s'), len = %d\n", toChars(), deferred.dim); +} + +/************************************ + * Recursively look at every module this module imports, + * return TRUE if it imports m. + * Can be used to detect circular imports. + */ + +int Module::imports(Module *m) +{ + //printf("%s Module::imports(%s)\n", toChars(), m->toChars()); + int aimports_dim = aimports.dim; +#if 0 + for (size_t i = 0; i < aimports.dim; i++) + { Module *mi = (Module *)aimports.data[i]; + printf("\t[%d] %s\n", i, mi->toChars()); + } +#endif + for (size_t i = 0; i < aimports.dim; i++) + { Module *mi = aimports.tdata()[i]; + if (mi == m) + return TRUE; + if (!mi->insearch) + { + mi->insearch = 1; + int r = mi->imports(m); + if (r) + return r; + } + } + return FALSE; +} + +/************************************* + * Return !=0 if module imports itself. + */ + +int Module::selfImports() +{ + //printf("Module::selfImports() %s\n", toChars()); + if (!selfimports) + { + for (size_t i = 0; i < amodules.dim; i++) + { Module *mi = amodules.tdata()[i]; + //printf("\t[%d] %s\n", i, mi->toChars()); + mi->insearch = 0; + } + + selfimports = imports(this) + 1; + + for (size_t i = 0; i < amodules.dim; i++) + { Module *mi = amodules.tdata()[i]; + //printf("\t[%d] %s\n", i, mi->toChars()); + mi->insearch = 0; + } + } + return selfimports - 1; +} + + +/* =========================== ModuleDeclaration ===================== */ + +ModuleDeclaration::ModuleDeclaration(Identifiers *packages, Identifier *id, bool safe) +{ + this->packages = packages; + this->id = id; + this->safe = safe; +} + +char *ModuleDeclaration::toChars() +{ + OutBuffer buf; + + if (packages && packages->dim) + { + for (size_t i = 0; i < packages->dim; i++) + { Identifier *pid = packages->tdata()[i]; + + buf.writestring(pid->toChars()); + buf.writeByte('.'); + } + } + buf.writestring(id->toChars()); + buf.writeByte(0); + return (char *)buf.extractData(); +} + +/* =========================== Package ===================== */ + +Package::Package(Identifier *ident) + : ScopeDsymbol(ident) +{ +} + + +const char *Package::kind() +{ + return "package"; +} + + +DsymbolTable *Package::resolve(Identifiers *packages, Dsymbol **pparent, Package **ppkg) +{ + DsymbolTable *dst = Module::modules; + Dsymbol *parent = NULL; + + //printf("Package::resolve()\n"); + if (ppkg) + *ppkg = NULL; + + if (packages) + { + for (size_t i = 0; i < packages->dim; i++) + { Identifier *pid = packages->tdata()[i]; + Dsymbol *p; + + p = dst->lookup(pid); + if (!p) + { + p = new Package(pid); + dst->insert(p); + p->parent = parent; + ((ScopeDsymbol *)p)->symtab = new DsymbolTable(); + } + else + { + assert(p->isPackage()); +#if TARGET_NET //dot net needs modules and packages with same name +#else + if (p->isModule()) + { p->error("module and package have the same name"); + fatal(); + break; + } +#endif + } + parent = p; + dst = ((Package *)p)->symtab; + if (ppkg && !*ppkg) + *ppkg = (Package *)p; + } + if (pparent) + { + *pparent = parent; + } + } + return dst; +} diff --git a/module.h b/module.h new file mode 100644 index 00000000..6b045985 --- /dev/null +++ b/module.h @@ -0,0 +1,194 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2008 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_MODULE_H +#define DMD_MODULE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "dsymbol.h" + +struct ModuleInfoDeclaration; +struct ClassDeclaration; +struct ModuleDeclaration; +struct Macro; +struct Escape; +struct VarDeclaration; +struct Library; + +// Back end +#if IN_GCC +union tree_node; typedef union tree_node elem; +#else +struct elem; +#endif + +struct Package : ScopeDsymbol +{ + Package(Identifier *ident); + const char *kind(); + + static DsymbolTable *resolve(Identifiers *packages, Dsymbol **pparent, Package **ppkg); + + Package *isPackage() { return this; } + + virtual void semantic(Scope *sc) { } +}; + +struct Module : Package +{ + static Module *rootModule; + static DsymbolTable *modules; // symbol table of all modules + static Modules amodules; // array of all modules + static Dsymbols deferred; // deferred Dsymbol's needing semantic() run on them + static unsigned dprogress; // progress resolving the deferred list + static void init(); + + static ClassDeclaration *moduleinfo; + + + const char *arg; // original argument name + ModuleDeclaration *md; // if !NULL, the contents of the ModuleDeclaration declaration + File *srcfile; // input source file + File *objfile; // output .obj file + File *hdrfile; // 'header' file + File *symfile; // output symbol file + File *docfile; // output documentation file + unsigned errors; // if any errors in file + unsigned numlines; // number of lines in source file + int isHtml; // if it is an HTML file + int isDocFile; // if it is a documentation input file, not D source + int needmoduleinfo; +#ifdef IN_GCC + int strictlyneedmoduleinfo; +#endif + + int selfimports; // 0: don't know, 1: does not, 2: does + int selfImports(); // returns !=0 if module imports itself + + int insearch; + Identifier *searchCacheIdent; + Dsymbol *searchCacheSymbol; // cached value of search + int searchCacheFlags; // cached flags + + int semanticstarted; // has semantic() been started? + int semanticRun; // has semantic() been done? + int root; // != 0 if this is a 'root' module, + // i.e. a module that will be taken all the + // way to an object file + Module *importedFrom; // module from command line we're imported from, + // i.e. a module that will be taken all the + // way to an object file + + Dsymbols *decldefs; // top level declarations for this Module + + Modules aimports; // all imported modules + + ModuleInfoDeclaration *vmoduleinfo; + + unsigned debuglevel; // debug level + Strings *debugids; // debug identifiers + Strings *debugidsNot; // forward referenced debug identifiers + + unsigned versionlevel; // version level + Strings *versionids; // version identifiers + Strings *versionidsNot; // forward referenced version identifiers + + Macro *macrotable; // document comment macros + Escape *escapetable; // document comment escapes + bool safe; // TRUE if module is marked as 'safe' + + size_t nameoffset; // offset of module name from start of ModuleInfo + size_t namelen; // length of module name in characters + + Module(char *arg, Identifier *ident, int doDocComment, int doHdrGen); + ~Module(); + + static Module *load(Loc loc, Identifiers *packages, Identifier *ident); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + void toJsonBuffer(OutBuffer *buf); + const char *kind(); + void setDocfile(); // set docfile member + void read(Loc loc); // read file +#if IN_GCC + void parse(bool dump_source = false); // syntactic parse +#else + void parse(); // syntactic parse +#endif + void importAll(Scope *sc); + void semantic(); // semantic analysis + void semantic2(); // pass 2 semantic analysis + void semantic3(); // pass 3 semantic analysis + void inlineScan(); // scan for functions to inline + void setHdrfile(); // set hdrfile member + void genhdrfile(); // generate D import file + void genobjfile(int multiobj); + void gensymfile(); + void gendocfile(); + int needModuleInfo(); + Dsymbol *search(Loc loc, Identifier *ident, int flags); + Dsymbol *symtabInsert(Dsymbol *s); + void deleteObjFile(); + void addDeferredSemantic(Dsymbol *s); + static void runDeferredSemantic(); + static void clearCache(); + int imports(Module *m); + + // Back end + + int doppelganger; // sub-module + Symbol *cov; // private uint[] __coverage; + unsigned *covb; // bit array of valid code line numbers + + Symbol *sictor; // module order independent constructor + Symbol *sctor; // module constructor + Symbol *sdtor; // module destructor + Symbol *ssharedctor; // module shared constructor + Symbol *sshareddtor; // module shared destructor + Symbol *stest; // module unit test + + Symbol *sfilename; // symbol for filename + + Symbol *massert; // module assert function + Symbol *toModuleAssert(); // get module assert function + + Symbol *munittest; // module unittest failure function + Symbol *toModuleUnittest(); // get module unittest failure function + + Symbol *marray; // module array bounds function + Symbol *toModuleArray(); // get module array bounds function + + + static Symbol *gencritsec(); + elem *toEfilename(); + + Symbol *toSymbol(); + void genmoduleinfo(); + + Module *isModule() { return this; } +}; + + +struct ModuleDeclaration +{ + Identifier *id; + Identifiers *packages; // array of Identifier's representing packages + bool safe; + + ModuleDeclaration(Identifiers *packages, Identifier *id, bool safe); + + char *toChars(); +}; + +#endif /* DMD_MODULE_H */ diff --git a/msc.c b/msc.c new file mode 100644 index 00000000..c154cbd2 --- /dev/null +++ b/msc.c @@ -0,0 +1,408 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "mars.h" + +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +extern void ph_init(); + +extern Global global; +extern int REALSIZE; + +Config config; +Configv configv; + +struct Environment; + +/************************************** + * Initialize config variables. + */ + +void out_config_init() +{ + //printf("out_config_init()\n"); + Param *params = &global.params; + + if (!config.target_cpu) + { config.target_cpu = TARGET_PentiumPro; + config.target_scheduler = config.target_cpu; + } + config.fulltypes = CVNONE; + config.fpxmmregs = FALSE; + config.inline8087 = 1; + config.memmodel = 0; + config.flags |= CFGuchar; // make sure TYchar is unsigned + tytab[TYchar] |= TYFLuns; +#if TARGET_WINDOS + if (params->is64bit) + config.exe = EX_WIN64; + else + config.exe = EX_NT; + + // Win32 eh + config.flags2 |= CFG2seh; + + if (params->run) + config.wflags |= WFexe; // EXE file only optimizations + else if (params->link && !global.params.deffile) + config.wflags |= WFexe; // EXE file only optimizations + else if (params->exefile) // if writing out EXE file + { size_t len = strlen(params->exefile); + if (len >= 4 && stricmp(params->exefile + len - 3, "exe") == 0) + config.wflags |= WFexe; + } + config.flags4 |= CFG4underscore; +#endif +#if TARGET_LINUX + if (params->is64bit) + { config.exe = EX_LINUX64; + config.fpxmmregs = TRUE; + } + else + config.exe = EX_LINUX; + config.flags |= CFGnoebp; + config.flags |= CFGalwaysframe; + if (params->pic) + config.flags3 |= CFG3pic; +#endif +#if TARGET_OSX + config.fpxmmregs = TRUE; + if (params->is64bit) + { config.exe = EX_OSX64; + config.fpxmmregs = TRUE; + } + else + config.exe = EX_OSX; + config.flags |= CFGnoebp; + config.flags |= CFGalwaysframe; + if (params->pic) + config.flags3 |= CFG3pic; +#endif +#if TARGET_FREEBSD + if (params->is64bit) + { config.exe = EX_FREEBSD64; + config.fpxmmregs = TRUE; + } + else + config.exe = EX_FREEBSD; + config.flags |= CFGnoebp; + config.flags |= CFGalwaysframe; + if (params->pic) + config.flags3 |= CFG3pic; +#endif +#if TARGET_OPENBSD + if (params->is64bit) + { config.exe = EX_OPENBSD64; + config.fpxmmregs = TRUE; + } + else + config.exe = EX_OPENBSD; + config.flags |= CFGnoebp; + config.flags |= CFGalwaysframe; + if (params->pic) + config.flags3 |= CFG3pic; +#endif +#if TARGET_SOLARIS + if (params->is64bit) + { config.exe = EX_SOLARIS64; + config.fpxmmregs = TRUE; + } + else + config.exe = EX_SOLARIS; + config.flags |= CFGnoebp; + config.flags |= CFGalwaysframe; + if (params->pic) + config.flags3 |= CFG3pic; +#endif + config.flags2 |= CFG2nodeflib; // no default library + config.flags3 |= CFG3eseqds; +#if 0 + if (env->getEEcontext()->EEcompile != 2) + config.flags4 |= CFG4allcomdat; + if (env->nochecks()) + config.flags4 |= CFG4nochecks; // no runtime checking +#elif TARGET_OSX +#else + config.flags4 |= CFG4allcomdat; +#endif + if (params->trace) + config.flags |= CFGtrace; // turn on profiler + if (params->nofloat) + config.flags3 |= CFG3wkfloat; + + configv.verbose = params->verbose; + + if (params->optimize) + go_flag((char *)"-o"); + + if (params->symdebug) + { +#if ELFOBJ || MACHOBJ + configv.addlinenumbers = 1; + config.fulltypes = (params->symdebug == 1) ? CVDWARF_D : CVDWARF_C; +#endif +#if OMFOBJ + configv.addlinenumbers = 1; + config.fulltypes = CV4; +#endif + if (!params->optimize) + config.flags |= CFGalwaysframe; + } + else + { + configv.addlinenumbers = 0; + config.fulltypes = CVNONE; + //config.flags &= ~CFGalwaysframe; + } + + if (params->alwaysframe) + config.flags &= ~CFGalwaysframe; + +#ifdef DEBUG + debugb = params->debugb; + debugc = params->debugc; + debugf = params->debugf; + debugr = params->debugr; + debugw = params->debugw; + debugx = params->debugx; + debugy = params->debugy; +#endif +} + +/******************************* + * Redo tables from 8086/286 to ILP32 + */ + +void util_set32() +{ + _tyrelax[TYenum] = TYlong; + _tyrelax[TYint] = TYlong; + _tyrelax[TYuint] = TYlong; + + tyequiv[TYint] = TYlong; + tyequiv[TYuint] = TYulong; + + for (int i = 0; i < 1; ++i) + { tysize[TYenum + i] = LONGSIZE; + tysize[TYint + i] = LONGSIZE; + tysize[TYuint + i] = LONGSIZE; + tysize[TYjhandle + i] = LONGSIZE; + tysize[TYnptr + i] = LONGSIZE; + tysize[TYnref + i] = LONGSIZE; + } + + for (int i = 0; i < 1; ++i) + { tyalignsize[TYenum + i] = LONGSIZE; + tyalignsize[TYint + i] = LONGSIZE; + tyalignsize[TYuint + i] = LONGSIZE; + tyalignsize[TYnullptr + i] = LONGSIZE; + tyalignsize[TYnptr + i] = LONGSIZE; + tyalignsize[TYnref + i] = LONGSIZE; + } +} + +/******************************* + * Redo tables from 8086/286 to LP64. + */ + +void util_set64() +{ + _tyrelax[TYenum] = TYlong; + _tyrelax[TYint] = TYlong; + _tyrelax[TYuint] = TYlong; + + tyequiv[TYint] = TYlong; + tyequiv[TYuint] = TYulong; + + for (int i = 0; i < 1; ++i) + { tysize[TYenum + i] = LONGSIZE; + tysize[TYint + i] = LONGSIZE; + tysize[TYuint + i] = LONGSIZE; + tysize[TYnptr + i] = 8; + tysize[TYnref + i] = 8; + tysize[TYldouble + i] = REALSIZE; + tysize[TYildouble + i] = REALSIZE; + tysize[TYcldouble + i] = 2 * REALSIZE; + + tyalignsize[TYenum + i] = LONGSIZE; + tyalignsize[TYint + i] = LONGSIZE; + tyalignsize[TYuint + i] = LONGSIZE; + tyalignsize[TYnullptr + i] = 8; + tyalignsize[TYnptr + i] = 8; + tyalignsize[TYnref + i] = 8; +#if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS || TARGET_OSX + tyalignsize[TYldouble + i] = 16; + tyalignsize[TYildouble + i] = 16; + tyalignsize[TYcldouble + i] = 16; +#else + assert(0); +#endif + tytab[TYjfunc + i] &= ~TYFLpascal; // set so caller cleans the stack (as in C) + } + + TYptrdiff = TYllong; + TYsize = TYullong; + TYsize_t = TYullong; +} + +/*********************************** + * Return aligned 'offset' if it is of size 'size'. + */ + +targ_size_t align(targ_size_t size, targ_size_t offset) +{ + switch (size) + { + case 1: + break; + case 2: + case 4: + case 8: + offset = (offset + size - 1) & ~(size - 1); + break; + default: + if (size >= 16) + offset = (offset + 15) & ~15; + else + offset = (offset + REGSIZE - 1) & ~(REGSIZE - 1); + break; + } + return offset; +} + +/******************************* + * Get size of ty + */ + +targ_size_t size(tym_t ty) +{ + int sz = (tybasic(ty) == TYvoid) ? 1 : tysize(ty); +#ifdef DEBUG + if (sz == -1) + WRTYxx(ty); +#endif + assert(sz!= -1); + return sz; +} + +/******************************* + * Replace (e) with ((stmp = e),stmp) + */ + +elem *exp2_copytotemp(elem *e) +{ + //printf("exp2_copytotemp()\n"); + elem_debug(e); + Symbol *stmp = symbol_genauto(e); + elem *eeq = el_bin(OPeq,e->Ety,el_var(stmp),e); + elem *er = el_bin(OPcomma,e->Ety,eeq,el_var(stmp)); + if (tybasic(e->Ety) == TYstruct || tybasic(e->Ety) == TYarray) + { + eeq->Eoper = OPstreq; + eeq->ET = e->ET; + eeq->E1->ET = e->ET; + er->ET = e->ET; + er->E2->ET = e->ET; + } + return er; +} + +/**************************** + * Generate symbol of type ty at DATA:offset + */ + +symbol *symboldata(targ_size_t offset,tym_t ty) +{ + symbol *s = symbol_generate(SClocstat, type_fake(ty)); + s->Sfl = FLdata; + s->Soffset = offset; + s->Sseg = DATA; + symbol_keep(s); // keep around + return s; +} + +/************************************ + * Add symbol to slist. + */ + +static list_t slist; + +void slist_add(Symbol *s) +{ + list_prepend(&slist,s); +} + +/************************************* + */ + +void slist_reset() +{ + //printf("slist_reset()\n"); + for (list_t sl = slist; sl; sl = list_next(sl)) + { Symbol *s = list_symbol(sl); + +#if MACHOBJ + s->Soffset = 0; +#endif + s->Sxtrnnum = 0; + s->Stypidx = 0; + s->Sflags &= ~(STRoutdef | SFLweak); + if (s->Sclass == SCglobal || s->Sclass == SCcomdat || + s->Sfl == FLudata || s->Sclass == SCstatic) + { s->Sclass = SCextern; + s->Sfl = FLextern; + } + } +} + + +/************************************** + */ + +void backend_init() +{ + ph_init(); + block_init(); + + if (global.params.is64bit) + { + util_set64(); + type_init(); + cod3_set64(); + } + else + { + util_set32(); + type_init(); + cod3_set32(); + } + + rtlsym_init(); // uses fregsaved, so must be after it's set inside cod3_set* + + out_config_init(); +} + +void backend_term() +{ +} diff --git a/mtype.c b/mtype.c new file mode 100644 index 00000000..c7f22412 --- /dev/null +++ b/mtype.c @@ -0,0 +1,9040 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// http://www.dsource.org/projects/dmd/browser/trunk/src/mtype.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#define __C99FEATURES__ 1 // Needed on Solaris for NaN and more +#define __USE_ISOC99 1 // so signbit() gets defined + +#if (defined (__SVR4) && defined (__sun)) +#include +#endif + +#include + +#include +#include +#include + +#if _MSC_VER +#include +#include +#include +#elif __DMC__ +#include +#elif __MINGW32__ +#include +#endif + +#include "rmem.h" +#include "port.h" + +#include "dsymbol.h" +#include "mtype.h" +#include "scope.h" +#include "init.h" +#include "expression.h" +#include "attrib.h" +#include "declaration.h" +#include "template.h" +#include "id.h" +#include "enum.h" +#include "import.h" +#include "aggregate.h" +#include "hdrgen.h" + +FuncDeclaration *hasThis(Scope *sc); +void ObjectNotFound(Identifier *id); + + +#define LOGDOTEXP 0 // log ::dotExp() +#define LOGDEFAULTINIT 0 // log ::defaultInit() + +// Allow implicit conversion of T[] to T* +#define IMPLICIT_ARRAY_TO_PTR global.params.useDeprecated + +/* These have default values for 32 bit code, they get + * adjusted for 64 bit code. + */ + +int PTRSIZE = 4; + +/* REALSIZE = size a real consumes in memory + * REALPAD = 'padding' added to the CPU real size to bring it up to REALSIZE + * REALALIGNSIZE = alignment for reals + */ +#if TARGET_OSX +int REALSIZE = 16; +int REALPAD = 6; +int REALALIGNSIZE = 16; +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS +int REALSIZE = 12; +int REALPAD = 2; +int REALALIGNSIZE = 4; +#elif TARGET_WINDOS +int REALSIZE = 10; +int REALPAD = 0; +int REALALIGNSIZE = 2; +#else +#error "fix this" +#endif + +int Tsize_t = Tuns32; +int Tptrdiff_t = Tint32; + +/***************************** Type *****************************/ + +ClassDeclaration *Type::typeinfo; +ClassDeclaration *Type::typeinfoclass; +ClassDeclaration *Type::typeinfointerface; +ClassDeclaration *Type::typeinfostruct; +ClassDeclaration *Type::typeinfotypedef; +ClassDeclaration *Type::typeinfopointer; +ClassDeclaration *Type::typeinfoarray; +ClassDeclaration *Type::typeinfostaticarray; +ClassDeclaration *Type::typeinfoassociativearray; +ClassDeclaration *Type::typeinfovector; +ClassDeclaration *Type::typeinfoenum; +ClassDeclaration *Type::typeinfofunction; +ClassDeclaration *Type::typeinfodelegate; +ClassDeclaration *Type::typeinfotypelist; +ClassDeclaration *Type::typeinfoconst; +ClassDeclaration *Type::typeinfoinvariant; +ClassDeclaration *Type::typeinfoshared; +ClassDeclaration *Type::typeinfowild; + +TemplateDeclaration *Type::associativearray; + +Type *Type::tvoidptr; +Type *Type::tstring; +Type *Type::basic[TMAX]; +unsigned char Type::mangleChar[TMAX]; +unsigned char Type::sizeTy[TMAX]; +StringTable Type::stringtable; + + +Type::Type(TY ty) +{ + this->ty = ty; + this->mod = 0; + this->deco = NULL; +#if DMDV2 + this->cto = NULL; + this->ito = NULL; + this->sto = NULL; + this->scto = NULL; + this->wto = NULL; + this->swto = NULL; +#endif + this->pto = NULL; + this->rto = NULL; + this->arrayof = NULL; + this->vtinfo = NULL; + this->ctype = NULL; +} + +Type *Type::syntaxCopy() +{ + print(); + fprintf(stdmsg, "ty = %d\n", ty); + assert(0); + return this; +} + +int Type::equals(Object *o) +{ Type *t; + + t = (Type *)o; + //printf("Type::equals(%s, %s)\n", toChars(), t->toChars()); + if (this == o || + (t && deco == t->deco) && // deco strings are unique + deco != NULL) // and semantic() has been run + { + //printf("deco = '%s', t->deco = '%s'\n", deco, t->deco); + return 1; + } + //if (deco && t && t->deco) printf("deco = '%s', t->deco = '%s'\n", deco, t->deco); + return 0; +} + +char Type::needThisPrefix() +{ + return 'M'; // name mangling prefix for functions needing 'this' +} + +void Type::init() +{ + stringtable.init(1543); + Lexer::initKeywords(); + + for (size_t i = 0; i < TMAX; i++) + sizeTy[i] = sizeof(TypeBasic); + sizeTy[Tsarray] = sizeof(TypeSArray); + sizeTy[Tarray] = sizeof(TypeDArray); + sizeTy[Taarray] = sizeof(TypeAArray); + sizeTy[Tpointer] = sizeof(TypePointer); + sizeTy[Treference] = sizeof(TypeReference); + sizeTy[Tfunction] = sizeof(TypeFunction); + sizeTy[Tdelegate] = sizeof(TypeDelegate); + sizeTy[Tident] = sizeof(TypeIdentifier); + sizeTy[Tinstance] = sizeof(TypeInstance); + sizeTy[Ttypeof] = sizeof(TypeTypeof); + sizeTy[Tenum] = sizeof(TypeEnum); + sizeTy[Ttypedef] = sizeof(TypeTypedef); + sizeTy[Tstruct] = sizeof(TypeStruct); + sizeTy[Tclass] = sizeof(TypeClass); + sizeTy[Ttuple] = sizeof(TypeTuple); + sizeTy[Tslice] = sizeof(TypeSlice); + sizeTy[Treturn] = sizeof(TypeReturn); + sizeTy[Terror] = sizeof(TypeError); + sizeTy[Tnull] = sizeof(TypeNull); + + mangleChar[Tarray] = 'A'; + mangleChar[Tsarray] = 'G'; + mangleChar[Taarray] = 'H'; + mangleChar[Tpointer] = 'P'; + mangleChar[Treference] = 'R'; + mangleChar[Tfunction] = 'F'; + mangleChar[Tident] = 'I'; + mangleChar[Tclass] = 'C'; + mangleChar[Tstruct] = 'S'; + mangleChar[Tenum] = 'E'; + mangleChar[Ttypedef] = 'T'; + mangleChar[Tdelegate] = 'D'; + + mangleChar[Tnone] = 'n'; + mangleChar[Tvoid] = 'v'; + mangleChar[Tint8] = 'g'; + mangleChar[Tuns8] = 'h'; + mangleChar[Tint16] = 's'; + mangleChar[Tuns16] = 't'; + mangleChar[Tint32] = 'i'; + mangleChar[Tuns32] = 'k'; + mangleChar[Tint64] = 'l'; + mangleChar[Tuns64] = 'm'; + mangleChar[Tfloat32] = 'f'; + mangleChar[Tfloat64] = 'd'; + mangleChar[Tfloat80] = 'e'; + + mangleChar[Timaginary32] = 'o'; + mangleChar[Timaginary64] = 'p'; + mangleChar[Timaginary80] = 'j'; + mangleChar[Tcomplex32] = 'q'; + mangleChar[Tcomplex64] = 'r'; + mangleChar[Tcomplex80] = 'c'; + + mangleChar[Tbool] = 'b'; + mangleChar[Tascii] = 'a'; + mangleChar[Twchar] = 'u'; + mangleChar[Tdchar] = 'w'; + + // '@' shouldn't appear anywhere in the deco'd names + mangleChar[Tinstance] = '@'; + mangleChar[Terror] = '@'; + mangleChar[Ttypeof] = '@'; + mangleChar[Ttuple] = 'B'; + mangleChar[Tslice] = '@'; + mangleChar[Treturn] = '@'; + mangleChar[Tvector] = '@'; + + mangleChar[Tnull] = 'n'; // same as TypeNone + + for (size_t i = 0; i < TMAX; i++) + { if (!mangleChar[i]) + fprintf(stdmsg, "ty = %zd\n", i); + assert(mangleChar[i]); + } + + // Set basic types + static TY basetab[] = + { Tvoid, Tint8, Tuns8, Tint16, Tuns16, Tint32, Tuns32, Tint64, Tuns64, + Tfloat32, Tfloat64, Tfloat80, + Timaginary32, Timaginary64, Timaginary80, + Tcomplex32, Tcomplex64, Tcomplex80, + Tbool, + Tascii, Twchar, Tdchar }; + + for (size_t i = 0; i < sizeof(basetab) / sizeof(basetab[0]); i++) + { Type *t = new TypeBasic(basetab[i]); + t = t->merge(); + basic[basetab[i]] = t; + } + basic[Terror] = new TypeError(); + + tnull = new TypeNull(); + tnull->deco = tnull->merge()->deco; + + tvoidptr = tvoid->pointerTo(); + tstring = tchar->invariantOf()->arrayOf(); + + if (global.params.is64bit) + { + PTRSIZE = 8; + if (global.params.isLinux || global.params.isFreeBSD || global.params.isSolaris) + { + REALSIZE = 16; + REALPAD = 6; + REALALIGNSIZE = 16; + } + Tsize_t = Tuns64; + Tptrdiff_t = Tint64; + } + else + { + PTRSIZE = 4; +#if TARGET_OSX + REALSIZE = 16; + REALPAD = 6; +#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + REALSIZE = 12; + REALPAD = 2; +#else + REALSIZE = 10; + REALPAD = 0; +#endif + Tsize_t = Tuns32; + Tptrdiff_t = Tint32; + } +} + +d_uns64 Type::size() +{ + return size(0); +} + +d_uns64 Type::size(Loc loc) +{ + error(loc, "no size for type %s", toChars()); + return 1; +} + +unsigned Type::alignsize() +{ + return size(0); +} + +Type *Type::semantic(Loc loc, Scope *sc) +{ + return merge(); +} + +Type *Type::trySemantic(Loc loc, Scope *sc) +{ + //printf("+trySemantic(%s) %d\n", toChars(), global.errors); + unsigned errors = global.startGagging(); + Type *t = semantic(loc, sc); + if (global.endGagging(errors)) // if any errors happened + { + t = NULL; + } + //printf("-trySemantic(%s) %d\n", toChars(), global.errors); + return t; +} + +/******************************** + * Convert to 'const'. + */ + +Type *Type::constOf() +{ + //printf("Type::constOf() %p %s\n", this, toChars()); + if (mod == MODconst) + return this; + if (cto) + { assert(cto->mod == MODconst); + return cto; + } + Type *t = makeConst(); + t = t->merge(); + t->fixTo(this); + //printf("-Type::constOf() %p %s\n", t, t->toChars()); + return t; +} + +/******************************** + * Convert to 'immutable'. + */ + +Type *Type::invariantOf() +{ + //printf("Type::invariantOf() %p %s\n", this, toChars()); + if (isImmutable()) + { + return this; + } + if (ito) + { + assert(ito->isImmutable()); + return ito; + } + Type *t = makeInvariant(); + t = t->merge(); + t->fixTo(this); + //printf("\t%p\n", t); + return t; +} + +/******************************** + * Make type mutable. + */ + +Type *Type::mutableOf() +{ + //printf("Type::mutableOf() %p, %s\n", this, toChars()); + Type *t = this; + if (isConst()) + { if (isShared()) + t = sto; // shared const => shared + else + t = cto; // const => naked + assert(!t || t->isMutable()); + } + else if (isImmutable()) + { t = ito; // immutable => naked + assert(!t || (t->isMutable() && !t->isShared())); + } + else if (isWild()) + { + if (isShared()) + t = sto; // shared wild => shared + else + t = wto; // wild => naked + assert(!t || t->isMutable()); + } + if (!t) + { + t = makeMutable(); + t = t->merge(); + t->fixTo(this); + } + assert(t->isMutable()); + return t; +} + +Type *Type::sharedOf() +{ + //printf("Type::sharedOf() %p, %s\n", this, toChars()); + if (mod == MODshared) + { + return this; + } + if (sto) + { + assert(sto->isShared()); + return sto; + } + Type *t = makeShared(); + t = t->merge(); + t->fixTo(this); + //printf("\t%p\n", t); + return t; +} + +Type *Type::sharedConstOf() +{ + //printf("Type::sharedConstOf() %p, %s\n", this, toChars()); + if (mod == (MODshared | MODconst)) + { + return this; + } + if (scto) + { + assert(scto->mod == (MODshared | MODconst)); + return scto; + } + Type *t = makeSharedConst(); + t = t->merge(); + t->fixTo(this); + //printf("\t%p\n", t); + return t; +} + + +/******************************** + * Make type unshared. + * 0 => 0 + * const => const + * immutable => immutable + * shared => 0 + * shared const => const + * wild => wild + * shared wild => wild + */ + +Type *Type::unSharedOf() +{ + //printf("Type::unSharedOf() %p, %s\n", this, toChars()); + Type *t = this; + + if (isShared()) + { + if (isConst()) + t = cto; // shared const => const + else if (isWild()) + t = wto; // shared wild => wild + else + t = sto; + assert(!t || !t->isShared()); + } + + if (!t) + { + unsigned sz = sizeTy[ty]; + t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = mod & ~MODshared; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t = t->merge(); + + t->fixTo(this); + } + assert(!t->isShared()); + return t; +} + +/******************************** + * Convert to 'wild'. + */ + +Type *Type::wildOf() +{ + //printf("Type::wildOf() %p %s\n", this, toChars()); + if (mod == MODwild) + { + return this; + } + if (wto) + { + assert(wto->isWild()); + return wto; + } + Type *t = makeWild(); + t = t->merge(); + t->fixTo(this); + //printf("\t%p %s\n", t, t->toChars()); + return t; +} + +Type *Type::sharedWildOf() +{ + //printf("Type::sharedWildOf() %p, %s\n", this, toChars()); + if (mod == (MODshared | MODwild)) + { + return this; + } + if (swto) + { + assert(swto->mod == (MODshared | MODwild)); + return swto; + } + Type *t = makeSharedWild(); + t = t->merge(); + t->fixTo(this); + //printf("\t%p\n", t); + return t; +} + +/********************************** + * For our new type 'this', which is type-constructed from t, + * fill in the cto, ito, sto, scto, wto shortcuts. + */ + +void Type::fixTo(Type *t) +{ + ito = t->ito; +#if 0 + /* Cannot do these because these are not fully transitive: + * there can be a shared ptr to immutable, for example. + * Immutable subtypes are always immutable, though. + */ + cto = t->cto; + sto = t->sto; + scto = t->scto; +#endif + + assert(mod != t->mod); +#define X(m, n) (((m) << 4) | (n)) + switch (X(mod, t->mod)) + { + case X(0, MODconst): + cto = t; + break; + + case X(0, MODimmutable): + ito = t; + break; + + case X(0, MODshared): + sto = t; + break; + + case X(0, MODshared | MODconst): + scto = t; + break; + + case X(0, MODwild): + wto = t; + break; + + case X(0, MODshared | MODwild): + swto = t; + break; + + + case X(MODconst, 0): + cto = NULL; + goto L2; + + case X(MODconst, MODimmutable): + ito = t; + goto L2; + + case X(MODconst, MODshared): + sto = t; + goto L2; + + case X(MODconst, MODshared | MODconst): + scto = t; + goto L2; + + case X(MODconst, MODwild): + wto = t; + goto L2; + + case X(MODconst, MODshared | MODwild): + swto = t; + L2: + t->cto = this; + break; + + + case X(MODimmutable, 0): + ito = NULL; + goto L3; + + case X(MODimmutable, MODconst): + cto = t; + goto L3; + + case X(MODimmutable, MODshared): + sto = t; + goto L3; + + case X(MODimmutable, MODshared | MODconst): + scto = t; + goto L3; + + case X(MODimmutable, MODwild): + wto = t; + goto L3; + + case X(MODimmutable, MODshared | MODwild): + swto = t; + L3: + t->ito = this; + if (t->cto) t->cto->ito = this; + if (t->sto) t->sto->ito = this; + if (t->scto) t->scto->ito = this; + if (t->wto) t->wto->ito = this; + if (t->swto) t->swto->ito = this; + break; + + + case X(MODshared, 0): + sto = NULL; + goto L4; + + case X(MODshared, MODconst): + cto = t; + goto L4; + + case X(MODshared, MODimmutable): + ito = t; + goto L4; + + case X(MODshared, MODshared | MODconst): + scto = t; + goto L4; + + case X(MODshared, MODwild): + wto = t; + goto L4; + + case X(MODshared, MODshared | MODwild): + swto = t; + L4: + t->sto = this; + break; + + + case X(MODshared | MODconst, 0): + scto = NULL; + goto L5; + + case X(MODshared | MODconst, MODconst): + cto = t; + goto L5; + + case X(MODshared | MODconst, MODimmutable): + ito = t; + goto L5; + + case X(MODshared | MODconst, MODwild): + wto = t; + goto L5; + + case X(MODshared | MODconst, MODshared): + sto = t; + goto L5; + + case X(MODshared | MODconst, MODshared | MODwild): + swto = t; + L5: + t->scto = this; + break; + + + case X(MODwild, 0): + wto = NULL; + goto L6; + + case X(MODwild, MODconst): + cto = t; + goto L6; + + case X(MODwild, MODimmutable): + ito = t; + goto L6; + + case X(MODwild, MODshared): + sto = t; + goto L6; + + case X(MODwild, MODshared | MODconst): + scto = t; + goto L6; + + case X(MODwild, MODshared | MODwild): + swto = t; + L6: + t->wto = this; + break; + + + case X(MODshared | MODwild, 0): + swto = NULL; + goto L7; + + case X(MODshared | MODwild, MODconst): + cto = t; + goto L7; + + case X(MODshared | MODwild, MODimmutable): + ito = t; + goto L7; + + case X(MODshared | MODwild, MODshared): + sto = t; + goto L7; + + case X(MODshared | MODwild, MODshared | MODconst): + scto = t; + goto L7; + + case X(MODshared | MODwild, MODwild): + wto = t; + L7: + t->swto = this; + break; + + + default: + assert(0); + } +#undef X + + check(); + t->check(); + //printf("fixTo: %s, %s\n", toChars(), t->toChars()); +} + +/*************************** + * Look for bugs in constructing types. + */ + +void Type::check() +{ + switch (mod) + { + case 0: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODconst: + if (cto) assert(cto->mod == 0); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODimmutable: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == 0); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODshared: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == 0); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODshared | MODconst: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == 0); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODwild: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == 0); + if (swto) assert(swto->mod == (MODshared | MODwild)); + break; + + case MODshared | MODwild: + if (cto) assert(cto->mod == MODconst); + if (ito) assert(ito->mod == MODimmutable); + if (sto) assert(sto->mod == MODshared); + if (scto) assert(scto->mod == (MODshared | MODconst)); + if (wto) assert(wto->mod == MODwild); + if (swto) assert(swto->mod == 0); + break; + + default: + assert(0); + } + + Type *tn = nextOf(); + if (tn && ty != Tfunction && tn->ty != Tfunction) + { // Verify transitivity + switch (mod) + { + case 0: + break; + + case MODconst: + assert(tn->mod & MODimmutable || tn->mod & MODconst); + break; + + case MODimmutable: + assert(tn->mod == MODimmutable); + break; + + case MODshared: + assert(tn->mod & MODimmutable || tn->mod & MODshared); + break; + + case MODshared | MODconst: + assert(tn->mod & MODimmutable || tn->mod & (MODshared | MODconst)); + break; + + case MODwild: + assert(tn->mod); + break; + + case MODshared | MODwild: + assert(tn->mod == MODimmutable || tn->mod == (MODshared | MODconst) || tn->mod == (MODshared | MODwild)); + break; + + default: + assert(0); + } + tn->check(); + } +} + +Type *Type::makeConst() +{ + //printf("Type::makeConst() %p, %s\n", this, toChars()); + if (cto) + return cto; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODconst; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + //printf("-Type::makeConst() %p, %s\n", t, toChars()); + return t; +} + +Type *Type::makeInvariant() +{ + if (ito) + return ito; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODimmutable; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +Type *Type::makeShared() +{ + if (sto) + return sto; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODshared; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +Type *Type::makeSharedConst() +{ + if (scto) + return scto; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODshared | MODconst; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +Type *Type::makeWild() +{ + if (wto) + return wto; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODwild; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +Type *Type::makeSharedWild() +{ + if (swto) + return swto; + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = MODshared | MODwild; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +Type *Type::makeMutable() +{ + unsigned sz = sizeTy[ty]; + Type *t = (Type *)mem.malloc(sz); + memcpy(t, this, sz); + t->mod = mod & MODshared; + t->deco = NULL; + t->arrayof = NULL; + t->pto = NULL; + t->rto = NULL; + t->cto = NULL; + t->ito = NULL; + t->sto = NULL; + t->scto = NULL; + t->wto = NULL; + t->swto = NULL; + t->vtinfo = NULL; + t->ctype = NULL; + return t; +} + +/************************************* + * Apply STCxxxx bits to existing type. + * Use *before* semantic analysis is run. + */ + +Type *Type::addSTC(StorageClass stc) +{ Type *t = this; + + if (stc & STCconst) + { if (t->isShared()) + t = t->makeSharedConst(); + else + t = t->makeConst(); + } + if (stc & STCimmutable) + t = t->makeInvariant(); + if (stc & STCshared) + { if (t->isConst()) + t = t->makeSharedConst(); + else + t = t->makeShared(); + } + if (stc & STCwild) + { if (t->isShared()) + t = t->makeSharedWild(); + else + t = t->makeWild(); + } + return t; +} + +/************************************ + * Apply MODxxxx bits to existing type. + */ + +Type *Type::castMod(unsigned mod) +{ Type *t; + + switch (mod) + { + case 0: + t = unSharedOf()->mutableOf(); + break; + + case MODconst: + t = unSharedOf()->constOf(); + break; + + case MODimmutable: + t = invariantOf(); + break; + + case MODshared: + t = mutableOf()->sharedOf(); + break; + + case MODshared | MODconst: + t = sharedConstOf(); + break; + + case MODwild: + t = unSharedOf()->wildOf(); + break; + + case MODshared | MODwild: + t = sharedWildOf(); + break; + + default: + assert(0); + } + return t; +} + +/************************************ + * Add MODxxxx bits to existing type. + * We're adding, not replacing, so adding const to + * a shared type => "shared const" + */ + +Type *Type::addMod(unsigned mod) +{ Type *t = this; + + /* Add anything to immutable, and it remains immutable + */ + if (!t->isImmutable()) + { + //printf("addMod(%x) %s\n", mod, toChars()); + switch (mod) + { + case 0: + break; + + case MODconst: + if (isShared()) + t = sharedConstOf(); + else + t = constOf(); + break; + + case MODimmutable: + t = invariantOf(); + break; + + case MODshared: + if (isConst()) + t = sharedConstOf(); + else if (isWild()) + t = sharedWildOf(); + else + t = sharedOf(); + break; + + case MODshared | MODconst: + t = sharedConstOf(); + break; + + case MODwild: + if (isConst()) + ; + else if (isShared()) + t = sharedWildOf(); + else + t = wildOf(); + break; + + case MODshared | MODwild: + if (isConst()) + t = sharedConstOf(); + else + t = sharedWildOf(); + break; + + default: + assert(0); + } + } + return t; +} + +/************************************ + * Add storage class modifiers to type. + */ + +Type *Type::addStorageClass(StorageClass stc) +{ + /* Just translate to MOD bits and let addMod() do the work + */ + unsigned mod = 0; + + if (stc & STCimmutable) + mod = MODimmutable; + else + { if (stc & (STCconst | STCin)) + mod = MODconst; + else if (stc & STCwild) // const takes precedence over wild + mod |= MODwild; + if (stc & STCshared) + mod |= MODshared; + } + return addMod(mod); +} + +Type *Type::pointerTo() +{ + if (ty == Terror) + return this; + if (!pto) + { Type *t; + + t = new TypePointer(this); + pto = t->merge(); + } + return pto; +} + +Type *Type::referenceTo() +{ + if (ty == Terror) + return this; + if (!rto) + { Type *t; + + t = new TypeReference(this); + rto = t->merge(); + } + return rto; +} + +Type *Type::arrayOf() +{ + if (ty == Terror) + return this; + if (!arrayof) + { Type *t; + + t = new TypeDArray(this); + arrayof = t->merge(); + } + return arrayof; +} + +Type *Type::aliasthisOf() +{ + AggregateDeclaration *ad = NULL; + if (ty == Tclass) + { + ad = ((TypeClass *)this)->sym; + goto L1; + } + else if (ty == Tstruct) + { + ad = ((TypeStruct *)this)->sym; + L1: + if (!ad->aliasthis) + return NULL; + + Declaration *d = ad->aliasthis->isDeclaration(); + if (d) + { assert(d->type); + Type *t = d->type; + if (d->isVarDeclaration() && d->needThis()) + { + t = t->addMod(this->mod); + } + else if (d->isFuncDeclaration()) + { + FuncDeclaration *fd = (FuncDeclaration *)d; + Expression *ethis = this->defaultInit(0); + fd = fd->overloadResolve(0, ethis, NULL); + if (fd) + t = ((TypeFunction *)fd->type)->next; + } + return t; + } + EnumDeclaration *ed = ad->aliasthis->isEnumDeclaration(); + if (ed) + { + Type *t = ed->type; + return t; + } + //printf("%s\n", ad->aliasthis->kind()); + } + return NULL; +} + +Dsymbol *Type::toDsymbol(Scope *sc) +{ + return NULL; +} + +/******************************* + * If this is a shell around another type, + * get that other type. + */ + +Type *Type::toBasetype() +{ + return this; +} + +/*************************** + * Return !=0 if modfrom can be implicitly converted to modto + */ +int MODimplicitConv(unsigned char modfrom, unsigned char modto) +{ + if (modfrom == modto) + return 1; + + //printf("MODimplicitConv(from = %x, to = %x)\n", modfrom, modto); + #define X(m, n) (((m) << 4) | (n)) + switch (X(modfrom, modto)) + { + case X(0, MODconst): + case X(MODimmutable, MODconst): + case X(MODwild, MODconst): + case X(MODimmutable, MODconst | MODshared): + case X(MODshared, MODconst | MODshared): + case X(MODwild | MODshared, MODconst | MODshared): + return 1; + + default: + return 0; + } + #undef X +} + +/*************************** + * Return !=0 if a method of type '() modfrom' can call a method of type '() modto'. + */ +int MODmethodConv(unsigned char modfrom, unsigned char modto) +{ + if (MODimplicitConv(modfrom, modto)) + return 1; + + #define X(m, n) (((m) << 4) | (n)) + switch (X(modfrom, modto)) + { + case X(0, MODwild): + case X(MODimmutable, MODwild): + case X(MODconst, MODwild): + case X(MODshared, MODshared|MODwild): + case X(MODshared|MODimmutable, MODshared|MODwild): + case X(MODshared|MODconst, MODshared|MODwild): + return 1; + + default: + return 0; + } + #undef X +} + +/*************************** + * Merge mod bits to form common mod. + */ +int MODmerge(unsigned char mod1, unsigned char mod2) +{ + if (mod1 == mod2) + return mod1; + + //printf("MODmerge(1 = %x, 2 = %x)\n", modfrom, modto); + #define X(m, n) (((m) << 4) | (n)) + // cases are commutative + #define Y(m, n) X(m, n): case X(n, m) + switch (X(mod1, mod2)) + { +#if 0 + case X(0, 0): + case X(MODconst, MODconst): + case X(MODimmutable, MODimmutable): + case X(MODshared, MODshared): + case X(MODshared | MODconst, MODshared | MODconst): + case X(MODwild, MODwild): + case X(MODshared | MODwild, MODshared | MODwild): +#endif + + case Y(0, MODconst): + case Y(0, MODimmutable): + case Y(MODconst, MODimmutable): + case Y(MODconst, MODwild): + case Y(0, MODwild): + case Y(MODimmutable, MODwild): + return MODconst; + + case Y(0, MODshared): + return MODshared; + + case Y(0, MODshared | MODconst): + case Y(MODconst, MODshared): + case Y(MODconst, MODshared | MODconst): + case Y(MODimmutable, MODshared): + case Y(MODimmutable, MODshared | MODconst): + case Y(MODshared, MODshared | MODconst): + case Y(0, MODshared | MODwild): + case Y(MODconst, MODshared | MODwild): + case Y(MODimmutable, MODshared | MODwild): + case Y(MODshared, MODwild): + case Y(MODshared, MODshared | MODwild): + case Y(MODshared | MODconst, MODwild): + case Y(MODshared | MODconst, MODshared | MODwild): + return MODshared | MODconst; + + case Y(MODwild, MODshared | MODwild): + return MODshared | MODwild; + + default: + assert(0); + } + #undef Y + #undef X + assert(0); + return 0; +} + +/********************************* + * Mangling for mod. + */ +void MODtoDecoBuffer(OutBuffer *buf, unsigned char mod) +{ + switch (mod) + { case 0: + break; + case MODconst: + buf->writeByte('x'); + break; + case MODimmutable: + buf->writeByte('y'); + break; + case MODshared: + buf->writeByte('O'); + break; + case MODshared | MODconst: + buf->writestring("Ox"); + break; + case MODwild: + buf->writestring("Ng"); + break; + case MODshared | MODwild: + buf->writestring("ONg"); + break; + default: + assert(0); + } +} + +/********************************* + * Name for mod. + */ +void MODtoBuffer(OutBuffer *buf, unsigned char mod) +{ + switch (mod) + { case 0: + break; + + case MODimmutable: + buf->writestring(Token::tochars[TOKimmutable]); + break; + + case MODshared: + buf->writestring(Token::tochars[TOKshared]); + break; + + case MODshared | MODconst: + buf->writestring(Token::tochars[TOKshared]); + buf->writeByte(' '); + case MODconst: + buf->writestring(Token::tochars[TOKconst]); + break; + + case MODshared | MODwild: + buf->writestring(Token::tochars[TOKshared]); + buf->writeByte(' '); + case MODwild: + buf->writestring(Token::tochars[TOKwild]); + break; + default: + assert(0); + } +} + +/******************************** + * Name mangling. + * Input: + * flag 0x100 do not do const/invariant + */ + +void Type::toDecoBuffer(OutBuffer *buf, int flag) +{ + if (flag != mod && flag != 0x100) + { + MODtoDecoBuffer(buf, mod); + } + buf->writeByte(mangleChar[ty]); +} + +/******************************** + * For pretty-printing a type. + */ + +char *Type::toChars() +{ OutBuffer *buf; + HdrGenState hgs; + + buf = new OutBuffer(); + toCBuffer(buf, NULL, &hgs); + return buf->toChars(); +} + +void Type::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs) +{ + toCBuffer2(buf, hgs, 0); + if (ident) + { buf->writeByte(' '); + buf->writestring(ident->toChars()); + } +} + +void Type::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(toChars()); +} + +void Type::toCBuffer3(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { + if (!(mod & MODshared) && (this->mod & MODshared)) + { + MODtoBuffer(buf, this->mod & MODshared); + buf->writeByte('('); + } + int m1 = this->mod & ~MODshared; + int m2 = (mod ^ m1) & m1; + if (m2) + { + MODtoBuffer(buf, m2); + buf->writeByte('('); + toCBuffer2(buf, hgs, this->mod); + buf->writeByte(')'); + } + else + toCBuffer2(buf, hgs, this->mod); + if (!(mod & MODshared) && (this->mod & MODshared)) + { + buf->writeByte(')'); + } + } +} + +void Type::modToBuffer(OutBuffer *buf) +{ + if (mod) + { + buf->writeByte(' '); + MODtoBuffer(buf, mod); + } +} + +/************************************ + */ + +Type *Type::merge() +{ + if (ty == Terror) return this; + if (ty == Ttypeof) return this; + if (ty == Tident) return this; + if (ty == Tinstance) return this; + if (nextOf() && !nextOf()->merge()->deco) + return this; + + //printf("merge(%s)\n", toChars()); + Type *t = this; + assert(t); + if (!deco) + { + OutBuffer buf; + StringValue *sv; + + //if (next) + //next = next->merge(); + toDecoBuffer(&buf); + sv = stringtable.update((char *)buf.data, buf.offset); + if (sv->ptrvalue) + { t = (Type *) sv->ptrvalue; +#ifdef DEBUG + if (!t->deco) + printf("t = %s\n", t->toChars()); +#endif + assert(t->deco); + //printf("old value, deco = '%s' %p\n", t->deco, t->deco); + } + else + { + sv->ptrvalue = this; + deco = sv->lstring.string; + //printf("new value, deco = '%s' %p\n", t->deco, t->deco); + } + } + return t; +} + +/************************************* + * This version does a merge even if the deco is already computed. + * Necessary for types that have a deco, but are not merged. + */ +Type *Type::merge2() +{ + //printf("merge2(%s)\n", toChars()); + Type *t = this; + assert(t); + if (!t->deco) + return t->merge(); + + StringValue *sv = stringtable.lookup((char *)t->deco, strlen(t->deco)); + if (sv && sv->ptrvalue) + { t = (Type *) sv->ptrvalue; + assert(t->deco); + } + else + assert(0); + return t; +} + +int Type::isintegral() +{ + return FALSE; +} + +int Type::isfloating() +{ + return FALSE; +} + +int Type::isreal() +{ + return FALSE; +} + +int Type::isimaginary() +{ + return FALSE; +} + +int Type::iscomplex() +{ + return FALSE; +} + +int Type::isscalar() +{ + return FALSE; +} + +int Type::isunsigned() +{ + return FALSE; +} + +ClassDeclaration *Type::isClassHandle() +{ + return NULL; +} + +int Type::isscope() +{ + return FALSE; +} + +int Type::isString() +{ + return FALSE; +} + +/************************** + * Given: + * T a, b; + * Can we assign: + * a = b; + * ? + */ +int Type::isAssignable() +{ + return TRUE; +} + +int Type::checkBoolean() +{ + return isscalar(); +} + +/******************************** + * TRUE if when type goes out of scope, it needs a destructor applied. + * Only applies to value types, not ref types. + */ +int Type::needsDestruction() +{ + return FALSE; +} + +/********************************* + * Check type to see if it is based on a deprecated symbol. + */ + +void Type::checkDeprecated(Loc loc, Scope *sc) +{ + Dsymbol *s = toDsymbol(sc); + + if (s) + s->checkDeprecated(loc, sc); +} + + +Expression *Type::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("Type::defaultInit() '%s'\n", toChars()); +#endif + return NULL; +} + +/*************************************** + * Use when we prefer the default initializer to be a literal, + * rather than a global immutable variable. + */ +Expression *Type::defaultInitLiteral(Loc loc) +{ +#if LOGDEFAULTINIT + printf("Type::defaultInitLiteral() '%s'\n", toChars()); +#endif + return defaultInit(loc); +} + +int Type::isZeroInit(Loc loc) +{ + return 0; // assume not +} + +int Type::isBaseOf(Type *t, int *poffset) +{ + return 0; // assume not +} + +/******************************** + * Determine if 'this' can be implicitly converted + * to type 'to'. + * Returns: + * MATCHnomatch, MATCHconvert, MATCHconst, MATCHexact + */ + +MATCH Type::implicitConvTo(Type *to) +{ + //printf("Type::implicitConvTo(this=%p, to=%p)\n", this, to); + //printf("from: %s\n", toChars()); + //printf("to : %s\n", to->toChars()); + if (this == to) + return MATCHexact; + return MATCHnomatch; +} + +/******************************* + * Determine if converting 'this' to 'to' is an identity operation, + * a conversion to const operation, or the types aren't the same. + * Returns: + * MATCHexact 'this' == 'to' + * MATCHconst 'to' is const + * MATCHnomatch conversion to mutable or invariant + */ + +MATCH Type::constConv(Type *to) +{ + //printf("Type::constConv(this = %s, to = %s)\n", toChars(), to->toChars()); + if (equals(to)) + return MATCHexact; + if (ty == to->ty && MODimplicitConv(mod, to->mod)) + return MATCHconst; + return MATCHnomatch; +} + +/*************************************** + * Return MOD bits matching this type to wild parameter type (tprm). + */ + +unsigned Type::wildConvTo(Type *tprm) +{ + //printf("Type::wildConvTo this = '%s', tprm = '%s'\n", toChars(), tprm->toChars()); + + if (tprm->isWild() && implicitConvTo(tprm->substWildTo(MODconst))) + { + if (isWild()) + return MODwild; + else if (isConst()) + return MODconst; + else if (isImmutable()) + return MODimmutable; + else if (isMutable()) + return MODmutable; + else + assert(0); + } + return 0; +} + +Type *Type::substWildTo(unsigned mod) +{ + //printf("+Type::substWildTo this = %s, mod = x%x\n", toChars(), mod); + Type *t; + + if (nextOf()) + { + t = nextOf()->substWildTo(mod); + if (t == nextOf()) + t = this; + else + { + if (ty == Tpointer) + t = t->pointerTo(); + else if (ty == Tarray) + t = t->arrayOf(); + else if (ty == Tsarray) + t = new TypeSArray(t, ((TypeSArray *)this)->dim->syntaxCopy()); + else if (ty == Taarray) + { + t = new TypeAArray(t, ((TypeAArray *)this)->index->syntaxCopy()); + t = t->merge(); + } + else + assert(0); + + t = t->addMod(this->mod); + } + } + else + t = this; + + if (isWild()) + { + if (mod & MODconst) + t = isShared() ? t->sharedConstOf() : t->constOf(); + else if (mod & MODimmutable) + t = t->invariantOf(); + else if (mod & MODwild) + t = isShared() ? t->sharedWildOf() : t->wildOf(); + else + t = isShared() ? t->sharedOf() : t->mutableOf(); + } + + //printf("-Type::substWildTo t = %s\n", t->toChars()); + return t; +} + +/************************** + * Return type with the top level of it being mutable. + */ +Type *Type::toHeadMutable() +{ + if (!mod) + return this; + return mutableOf(); +} + +Expression *Type::getProperty(Loc loc, Identifier *ident) +{ Expression *e; + +#if LOGDOTEXP + printf("Type::getProperty(type = '%s', ident = '%s')\n", toChars(), ident->toChars()); +#endif + if (ident == Id::__sizeof) + { + e = new IntegerExp(loc, size(loc), Type::tsize_t); + } + else if (ident == Id::size) + { + error(loc, ".size property should be replaced with .sizeof"); + e = new ErrorExp(); + } + else if (ident == Id::__xalignof) + { + e = new IntegerExp(loc, alignsize(), Type::tsize_t); + } + else if (ident == Id::typeinfo) + { + if (!global.params.useDeprecated) + error(loc, ".typeinfo deprecated, use typeid(type)"); + e = getTypeInfo(NULL); + } + else if (ident == Id::init) + { + if (ty == Tvoid) + error(loc, "void does not have an initializer"); + if (ty == Tfunction) + error(loc, "function does not have an initializer"); + e = defaultInitLiteral(loc); + } + else if (ident == Id::mangleof) + { const char *s; + if (!deco) + { s = toChars(); + error(loc, "forward reference of type %s.mangleof", s); + } + else + s = deco; + e = new StringExp(loc, (char *)s, strlen(s), 'c'); + Scope sc; + e = e->semantic(&sc); + } + else if (ident == Id::stringof) + { char *s = toChars(); + e = new StringExp(loc, s, strlen(s), 'c'); + Scope sc; + e = e->semantic(&sc); + } + else + { + Dsymbol *s = NULL; + if (ty == Tstruct || ty == Tclass || ty == Tenum || ty == Ttypedef) + s = toDsymbol(NULL); + if (s) + s = s->search_correct(ident); + if (this != Type::terror) + { + if (s) + error(loc, "no property '%s' for type '%s', did you mean '%s'?", ident->toChars(), toChars(), s->toChars()); + else + error(loc, "no property '%s' for type '%s'", ident->toChars(), toChars()); + } + e = new ErrorExp(); + } + return e; +} + +Expression *Type::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ VarDeclaration *v = NULL; + +#if LOGDOTEXP + printf("Type::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (e->op == TOKdotvar) + { + DotVarExp *dv = (DotVarExp *)e; + v = dv->var->isVarDeclaration(); + } + else if (e->op == TOKvar) + { + VarExp *ve = (VarExp *)e; + v = ve->var->isVarDeclaration(); + } + if (v) + { + if (ident == Id::offset) + { + if (!global.params.useDeprecated) + error(e->loc, ".offset deprecated, use .offsetof"); + goto Loffset; + } + else if (ident == Id::offsetof) + { + Loffset: + if (v->storage_class & STCfield) + { + e = new IntegerExp(e->loc, v->offset, Type::tsize_t); + return e; + } + } + else if (ident == Id::init) + { +#if 0 + if (v->init) + { + if (v->init->isVoidInitializer()) + error(e->loc, "%s.init is void", v->toChars()); + else + { Loc loc = e->loc; + e = v->init->toExpression(); + if (e->op == TOKassign || e->op == TOKconstruct || e->op == TOKblit) + { + e = ((AssignExp *)e)->e2; + + /* Take care of case where we used a 0 + * to initialize the struct. + */ + if (e->type == Type::tint32 && + e->isBool(0) && + v->type->toBasetype()->ty == Tstruct) + { + e = v->type->defaultInit(e->loc); + } + } + e = e->optimize(WANTvalue | WANTinterpret); +// if (!e->isConst()) +// error(loc, ".init cannot be evaluated at compile time"); + } + goto Lreturn; + } +#endif + e = defaultInitLiteral(e->loc); + goto Lreturn; + } + } + if (ident == Id::typeinfo) + { + if (!global.params.useDeprecated) + error(e->loc, ".typeinfo deprecated, use typeid(type)"); + e = getTypeInfo(sc); + } + else if (ident == Id::stringof) + { /* Bugzilla 3796: this should demangle e->type->deco rather than + * pretty-printing the type. + */ + char *s = e->toChars(); + e = new StringExp(e->loc, s, strlen(s), 'c'); + } + else + e = getProperty(e->loc, ident); + +Lreturn: + e = e->semantic(sc); + return e; +} + +/*************************************** + * Figures out what to do with an undefined member reference + * for classes and structs. + */ +Expression *Type::noMember(Scope *sc, Expression *e, Identifier *ident) +{ + assert(ty == Tstruct || ty == Tclass); + AggregateDeclaration *sym = toDsymbol(sc)->isAggregateDeclaration(); + assert(sym); + + if (ident != Id::__sizeof && + ident != Id::__xalignof && + ident != Id::init && + ident != Id::mangleof && + ident != Id::stringof && + ident != Id::offsetof) + { + /* Look for overloaded opDot() to see if we should forward request + * to it. + */ + Dsymbol *fd = search_function(sym, Id::opDot); + if (fd) + { /* Rewrite e.ident as: + * e.opDot().ident + */ + e = build_overload(e->loc, sc, e, NULL, fd); + e = new DotIdExp(e->loc, e, ident); + return e->semantic(sc); + } + + /* Look for overloaded opDispatch to see if we should forward request + * to it. + */ + fd = search_function(sym, Id::opDispatch); + if (fd) + { + /* Rewrite e.ident as: + * e.opDispatch!("ident") + */ + TemplateDeclaration *td = fd->isTemplateDeclaration(); + if (!td) + { + fd->error("must be a template opDispatch(string s), not a %s", fd->kind()); + return new ErrorExp(); + } + StringExp *se = new StringExp(e->loc, ident->toChars()); + Objects *tiargs = new Objects(); + tiargs->push(se); + e = new DotTemplateInstanceExp(e->loc, e, Id::opDispatch, tiargs); + ((DotTemplateInstanceExp *)e)->ti->tempdecl = td; + //return e; + e = e->semantic(sc); + return e; + } + + /* See if we should forward to the alias this. + */ + if (sym->aliasthis) + { /* Rewrite e.ident as: + * e.aliasthis.ident + */ + e = new DotIdExp(e->loc, e, sym->aliasthis->ident); + e = new DotIdExp(e->loc, e, ident); + return e->semantic(sc); + } + } + + return Type::dotExp(sc, e, ident); +} + +unsigned Type::memalign(unsigned salign) +{ + return salign; +} + +void Type::error(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + ::verror(loc, format, ap); + va_end( ap ); +} + +void Type::warning(Loc loc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + ::vwarning(loc, format, ap); + va_end( ap ); +} + +Identifier *Type::getTypeInfoIdent(int internal) +{ + // _init_10TypeInfo_%s + OutBuffer buf; + Identifier *id; + char *name; + int len; + + if (internal) + { buf.writeByte(mangleChar[ty]); + if (ty == Tarray) + buf.writeByte(mangleChar[((TypeArray *)this)->next->ty]); + } + else + toDecoBuffer(&buf); + len = buf.offset; + name = (char *)alloca(19 + sizeof(len) * 3 + len + 1); + buf.writeByte(0); +#if TARGET_OSX + // The LINKc will prepend the _ + sprintf(name, "D%dTypeInfo_%s6__initZ", 9 + len, buf.data); +#else + sprintf(name, "_D%dTypeInfo_%s6__initZ", 9 + len, buf.data); +#endif + if (global.params.isWindows) + name++; // C mangling will add it back in + //printf("name = %s\n", name); + id = Lexer::idPool(name); + return id; +} + +TypeBasic *Type::isTypeBasic() +{ + return NULL; +} + + +void Type::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + //printf("Type::resolve() %s, %d\n", toChars(), ty); + Type *t = semantic(loc, sc); + *pt = t; + *pe = NULL; + *ps = NULL; +} + +/******************************* + * If one of the subtypes of this type is a TypeIdentifier, + * i.e. it's an unresolved type, return that type. + */ + +Type *Type::reliesOnTident() +{ + return NULL; +} + +/*************************************** + * Return !=0 if the type or any of its subtypes is wild. + */ + +int Type::hasWild() +{ + return mod & MODwild; +} + +/******************************** + * We've mistakenly parsed this as a type. + * Redo it as an Expression. + * NULL if cannot. + */ + +Expression *Type::toExpression() +{ + return NULL; +} + +/*************************************** + * Return !=0 if type has pointers that need to + * be scanned by the GC during a collection cycle. + */ + +int Type::hasPointers() +{ + //printf("Type::hasPointers() %s, %d\n", toChars(), ty); + return FALSE; +} + +/************************************* + * If this is a type of something, return that something. + */ + +Type *Type::nextOf() +{ + return NULL; +} + +/**************************************** + * Return the mask that an integral type will + * fit into. + */ +uinteger_t Type::sizemask() +{ uinteger_t m; + + switch (toBasetype()->ty) + { + case Tbool: m = 1; break; + case Tchar: + case Tint8: + case Tuns8: m = 0xFF; break; + case Twchar: + case Tint16: + case Tuns16: m = 0xFFFFUL; break; + case Tdchar: + case Tint32: + case Tuns32: m = 0xFFFFFFFFUL; break; + case Tint64: + case Tuns64: m = 0xFFFFFFFFFFFFFFFFULL; break; + default: + assert(0); + } + return m; +} + +/* ============================= TypeError =========================== */ + +TypeError::TypeError() + : Type(Terror) +{ +} + +Type *TypeError::syntaxCopy() +{ + // No semantic analysis done, no need to copy + return this; +} + +void TypeError::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs) +{ + buf->writestring("_error_"); +} + +d_uns64 TypeError::size(Loc loc) { return 1; } +Expression *TypeError::getProperty(Loc loc, Identifier *ident) { return new ErrorExp(); } +Expression *TypeError::dotExp(Scope *sc, Expression *e, Identifier *ident) { return new ErrorExp(); } +Expression *TypeError::defaultInit(Loc loc) { return new ErrorExp(); } +Expression *TypeError::defaultInitLiteral(Loc loc) { return new ErrorExp(); } + +/* ============================= TypeNext =========================== */ + +TypeNext::TypeNext(TY ty, Type *next) + : Type(ty) +{ + this->next = next; +} + +void TypeNext::toDecoBuffer(OutBuffer *buf, int flag) +{ + Type::toDecoBuffer(buf, flag); + assert(next != this); + //printf("this = %p, ty = %d, next = %p, ty = %d\n", this, this->ty, next, next->ty); + next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod); +} + +void TypeNext::checkDeprecated(Loc loc, Scope *sc) +{ + Type::checkDeprecated(loc, sc); + if (next) // next can be NULL if TypeFunction and auto return type + next->checkDeprecated(loc, sc); +} + + +Type *TypeNext::reliesOnTident() +{ + return next->reliesOnTident(); +} + +int TypeNext::hasWild() +{ + return mod & MODwild || (next && next->hasWild()); +} + + +/******************************* + * For TypeFunction, nextOf() can return NULL if the function return + * type is meant to be inferred, and semantic() hasn't yet ben run + * on the function. After semantic(), it must no longer be NULL. + */ + +Type *TypeNext::nextOf() +{ + return next; +} + +Type *TypeNext::makeConst() +{ + //printf("TypeNext::makeConst() %p, %s\n", this, toChars()); + if (cto) + { assert(cto->mod == MODconst); + return cto; + } + TypeNext *t = (TypeNext *)Type::makeConst(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable() && !next->isConst()) + { if (next->isShared()) + t->next = next->sharedConstOf(); + else + t->next = next->constOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeConst() returns %p, %s\n", t, t->toChars()); + return t; +} + +Type *TypeNext::makeInvariant() +{ + //printf("TypeNext::makeInvariant() %s\n", toChars()); + if (ito) + { assert(ito->isImmutable()); + return ito; + } + TypeNext *t = (TypeNext *)Type::makeInvariant(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable()) + { t->next = next->invariantOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + return t; +} + +Type *TypeNext::makeShared() +{ + //printf("TypeNext::makeShared() %s\n", toChars()); + if (sto) + { assert(sto->mod == MODshared); + return sto; + } + TypeNext *t = (TypeNext *)Type::makeShared(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable() && !next->isShared()) + { + if (next->isConst()) + t->next = next->sharedConstOf(); + else if (next->isWild()) + t->next = next->sharedWildOf(); + else + t->next = next->sharedOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeShared() returns %p, %s\n", t, t->toChars()); + return t; +} + +Type *TypeNext::makeSharedConst() +{ + //printf("TypeNext::makeSharedConst() %s\n", toChars()); + if (scto) + { assert(scto->mod == (MODshared | MODconst)); + return scto; + } + TypeNext *t = (TypeNext *)Type::makeSharedConst(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable() && !next->isSharedConst()) + { + t->next = next->sharedConstOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeSharedConst() returns %p, %s\n", t, t->toChars()); + return t; +} + +Type *TypeNext::makeWild() +{ + //printf("TypeNext::makeWild() %s\n", toChars()); + if (wto) + { assert(wto->mod == MODwild); + return wto; + } + TypeNext *t = (TypeNext *)Type::makeWild(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable() && !next->isConst() && !next->isWild()) + { + if (next->isShared()) + t->next = next->sharedWildOf(); + else + t->next = next->wildOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeWild() returns %p, %s\n", t, t->toChars()); + return t; +} + +Type *TypeNext::makeSharedWild() +{ + //printf("TypeNext::makeSharedWild() %s\n", toChars()); + if (swto) + { assert(swto->isSharedWild()); + return swto; + } + TypeNext *t = (TypeNext *)Type::makeSharedWild(); + if (ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + !next->isImmutable() && !next->isSharedConst()) + { + if (next->isConst()) + t->next = next->sharedConstOf(); + else + t->next = next->sharedWildOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeSharedWild() returns %p, %s\n", t, t->toChars()); + return t; +} + +Type *TypeNext::makeMutable() +{ + //printf("TypeNext::makeMutable() %p, %s\n", this, toChars()); + TypeNext *t = (TypeNext *)Type::makeMutable(); + if ((ty != Tfunction && next->ty != Tfunction && + //(next->deco || next->ty == Tfunction) && + next->isWild()) || ty == Tsarray) + { + t->next = next->mutableOf(); + } + if (ty == Taarray) + { + ((TypeAArray *)t)->impl = NULL; // lazily recompute it + } + //printf("TypeNext::makeMutable() returns %p, %s\n", t, t->toChars()); + return t; +} + +MATCH TypeNext::constConv(Type *to) +{ + //printf("TypeNext::constConv from = %s, to = %s\n", toChars(), to->toChars()); + if (equals(to)) + return MATCHexact; + + if (!(ty == to->ty && MODimplicitConv(mod, to->mod))) + return MATCHnomatch; + + Type *tn = to->nextOf(); + if (!(tn && next->ty == tn->ty)) + return MATCHnomatch; + + MATCH m; + if (to->isConst()) // whole tail const conversion + { // Recursive shared level check + m = next->constConv(tn); + if (m == MATCHexact) + m = MATCHconst; + } + else + { //printf("\tnext => %s, to->next => %s\n", next->toChars(), tn->toChars()); + m = next->equals(tn) ? MATCHconst : MATCHnomatch; + } + return m; +} + +unsigned TypeNext::wildConvTo(Type *tprm) +{ + if (ty == Tfunction) + return 0; + + unsigned mod = 0; + Type *tn = tprm->nextOf(); + if (!tn) + return 0; + mod = next->wildConvTo(tn); + if (!mod) + mod = Type::wildConvTo(tprm); + + return mod; +} + + +void TypeNext::transitive() +{ + /* Invoke transitivity of type attributes + */ + next = next->addMod(mod); +} + +/* ============================= TypeBasic =========================== */ + +TypeBasic::TypeBasic(TY ty) + : Type(ty) +{ const char *d; + unsigned flags; + +#define TFLAGSintegral 1 +#define TFLAGSfloating 2 +#define TFLAGSunsigned 4 +#define TFLAGSreal 8 +#define TFLAGSimaginary 0x10 +#define TFLAGScomplex 0x20 +#define TFLAGSvector 0x40 // valid for a SIMD vector type + + flags = 0; + switch (ty) + { + case Tvoid: d = Token::toChars(TOKvoid); + flags |= TFLAGSvector; + break; + + case Tint8: d = Token::toChars(TOKint8); + flags |= TFLAGSintegral | TFLAGSvector; + break; + + case Tuns8: d = Token::toChars(TOKuns8); + flags |= TFLAGSintegral | TFLAGSunsigned | TFLAGSvector; + break; + + case Tint16: d = Token::toChars(TOKint16); + flags |= TFLAGSintegral | TFLAGSvector; + break; + + case Tuns16: d = Token::toChars(TOKuns16); + flags |= TFLAGSintegral | TFLAGSunsigned | TFLAGSvector; + break; + + case Tint32: d = Token::toChars(TOKint32); + flags |= TFLAGSintegral | TFLAGSvector; + break; + + case Tuns32: d = Token::toChars(TOKuns32); + flags |= TFLAGSintegral | TFLAGSunsigned | TFLAGSvector; + break; + + case Tfloat32: d = Token::toChars(TOKfloat32); + flags |= TFLAGSfloating | TFLAGSreal | TFLAGSvector; + break; + + case Tint64: d = Token::toChars(TOKint64); + flags |= TFLAGSintegral | TFLAGSvector; + break; + + case Tuns64: d = Token::toChars(TOKuns64); + flags |= TFLAGSintegral | TFLAGSunsigned | TFLAGSvector; + break; + + case Tfloat64: d = Token::toChars(TOKfloat64); + flags |= TFLAGSfloating | TFLAGSreal | TFLAGSvector; + break; + + case Tfloat80: d = Token::toChars(TOKfloat80); + flags |= TFLAGSfloating | TFLAGSreal; + break; + + case Timaginary32: d = Token::toChars(TOKimaginary32); + flags |= TFLAGSfloating | TFLAGSimaginary; + break; + + case Timaginary64: d = Token::toChars(TOKimaginary64); + flags |= TFLAGSfloating | TFLAGSimaginary; + break; + + case Timaginary80: d = Token::toChars(TOKimaginary80); + flags |= TFLAGSfloating | TFLAGSimaginary; + break; + + case Tcomplex32: d = Token::toChars(TOKcomplex32); + flags |= TFLAGSfloating | TFLAGScomplex; + break; + + case Tcomplex64: d = Token::toChars(TOKcomplex64); + flags |= TFLAGSfloating | TFLAGScomplex; + break; + + case Tcomplex80: d = Token::toChars(TOKcomplex80); + flags |= TFLAGSfloating | TFLAGScomplex; + break; + + case Tbool: d = "bool"; + flags |= TFLAGSintegral | TFLAGSunsigned; + break; + + case Tascii: d = Token::toChars(TOKchar); + flags |= TFLAGSintegral | TFLAGSunsigned; + break; + + case Twchar: d = Token::toChars(TOKwchar); + flags |= TFLAGSintegral | TFLAGSunsigned; + break; + + case Tdchar: d = Token::toChars(TOKdchar); + flags |= TFLAGSintegral | TFLAGSunsigned; + break; + + default: assert(0); + } + this->dstring = d; + this->flags = flags; + merge(); +} + +Type *TypeBasic::syntaxCopy() +{ + // No semantic analysis done on basic types, no need to copy + return this; +} + + +char *TypeBasic::toChars() +{ + return Type::toChars(); +} + +void TypeBasic::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + //printf("TypeBasic::toCBuffer2(mod = %d, this->mod = %d)\n", mod, this->mod); + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(dstring); +} + +d_uns64 TypeBasic::size(Loc loc) +{ unsigned size; + + //printf("TypeBasic::size()\n"); + switch (ty) + { + case Tint8: + case Tuns8: size = 1; break; + case Tint16: + case Tuns16: size = 2; break; + case Tint32: + case Tuns32: + case Tfloat32: + case Timaginary32: + size = 4; break; + case Tint64: + case Tuns64: + case Tfloat64: + case Timaginary64: + size = 8; break; + case Tfloat80: + case Timaginary80: + size = REALSIZE; break; + case Tcomplex32: + size = 8; break; + case Tcomplex64: + size = 16; break; + case Tcomplex80: + size = REALSIZE * 2; break; + + case Tvoid: + //size = Type::size(); // error message + size = 1; + break; + + case Tbool: size = 1; break; + case Tascii: size = 1; break; + case Twchar: size = 2; break; + case Tdchar: size = 4; break; + + default: + assert(0); + break; + } + //printf("TypeBasic::size() = %d\n", size); + return size; +} + +unsigned TypeBasic::alignsize() +{ unsigned sz; + + switch (ty) + { + case Tfloat80: + case Timaginary80: + case Tcomplex80: + sz = REALALIGNSIZE; + break; + +#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS + case Tint64: + case Tuns64: + sz = global.params.is64bit ? 8 : 4; + break; + + case Tfloat64: + case Timaginary64: + sz = global.params.is64bit ? 8 : 4; + break; + + case Tcomplex32: + sz = 4; + break; + + case Tcomplex64: + sz = global.params.is64bit ? 8 : 4; + break; +#endif + + default: + sz = size(0); + break; + } + return sz; +} + + +Expression *TypeBasic::getProperty(Loc loc, Identifier *ident) +{ + Expression *e; + d_int64 ivalue; +#ifdef IN_GCC + real_t fvalue; +#else + d_float80 fvalue; +#endif + + //printf("TypeBasic::getProperty('%s')\n", ident->toChars()); + if (ident == Id::max) + { + switch (ty) + { + case Tint8: ivalue = 0x7F; goto Livalue; + case Tuns8: ivalue = 0xFF; goto Livalue; + case Tint16: ivalue = 0x7FFFUL; goto Livalue; + case Tuns16: ivalue = 0xFFFFUL; goto Livalue; + case Tint32: ivalue = 0x7FFFFFFFUL; goto Livalue; + case Tuns32: ivalue = 0xFFFFFFFFUL; goto Livalue; + case Tint64: ivalue = 0x7FFFFFFFFFFFFFFFLL; goto Livalue; + case Tuns64: ivalue = 0xFFFFFFFFFFFFFFFFULL; goto Livalue; + case Tbool: ivalue = 1; goto Livalue; + case Tchar: ivalue = 0xFF; goto Livalue; + case Twchar: ivalue = 0xFFFFUL; goto Livalue; + case Tdchar: ivalue = 0x10FFFFUL; goto Livalue; + + case Tcomplex32: + case Timaginary32: + case Tfloat32: fvalue = FLT_MAX; goto Lfvalue; + case Tcomplex64: + case Timaginary64: + case Tfloat64: fvalue = DBL_MAX; goto Lfvalue; + case Tcomplex80: + case Timaginary80: + case Tfloat80: fvalue = Port::ldbl_max; goto Lfvalue; + } + } + else if (ident == Id::min) + { + switch (ty) + { + case Tint8: ivalue = -128; goto Livalue; + case Tuns8: ivalue = 0; goto Livalue; + case Tint16: ivalue = -32768; goto Livalue; + case Tuns16: ivalue = 0; goto Livalue; + case Tint32: ivalue = -2147483647L - 1; goto Livalue; + case Tuns32: ivalue = 0; goto Livalue; + case Tint64: ivalue = (-9223372036854775807LL-1LL); goto Livalue; + case Tuns64: ivalue = 0; goto Livalue; + case Tbool: ivalue = 0; goto Livalue; + case Tchar: ivalue = 0; goto Livalue; + case Twchar: ivalue = 0; goto Livalue; + case Tdchar: ivalue = 0; goto Livalue; + + case Tcomplex32: + case Timaginary32: + case Tfloat32: + case Tcomplex64: + case Timaginary64: + case Tfloat64: + case Tcomplex80: + case Timaginary80: + case Tfloat80: + // For backwards compatibility - eventually, deprecate + goto Lmin_normal; + } + } + else if (ident == Id::min_normal) + { + Lmin_normal: + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: fvalue = FLT_MIN; goto Lfvalue; + case Tcomplex64: + case Timaginary64: + case Tfloat64: fvalue = DBL_MIN; goto Lfvalue; + case Tcomplex80: + case Timaginary80: + case Tfloat80: fvalue = LDBL_MIN; goto Lfvalue; + } + } + else if (ident == Id::nan) + { + switch (ty) + { + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: + case Timaginary32: + case Timaginary64: + case Timaginary80: + case Tfloat32: + case Tfloat64: + case Tfloat80: + { + fvalue = Port::nan; + goto Lfvalue; + } + } + } + else if (ident == Id::infinity) + { + switch (ty) + { + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: + case Timaginary32: + case Timaginary64: + case Timaginary80: + case Tfloat32: + case Tfloat64: + case Tfloat80: + fvalue = Port::infinity; + goto Lfvalue; + } + } + else if (ident == Id::dig) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_DIG; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_DIG; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_DIG; goto Lint; + } + } + else if (ident == Id::epsilon) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: fvalue = FLT_EPSILON; goto Lfvalue; + case Tcomplex64: + case Timaginary64: + case Tfloat64: fvalue = DBL_EPSILON; goto Lfvalue; + case Tcomplex80: + case Timaginary80: + case Tfloat80: fvalue = LDBL_EPSILON; goto Lfvalue; + } + } + else if (ident == Id::mant_dig) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_MANT_DIG; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_MANT_DIG; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_MANT_DIG; goto Lint; + } + } + else if (ident == Id::max_10_exp) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_MAX_10_EXP; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_MAX_10_EXP; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_MAX_10_EXP; goto Lint; + } + } + else if (ident == Id::max_exp) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_MAX_EXP; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_MAX_EXP; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_MAX_EXP; goto Lint; + } + } + else if (ident == Id::min_10_exp) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_MIN_10_EXP; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_MIN_10_EXP; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_MIN_10_EXP; goto Lint; + } + } + else if (ident == Id::min_exp) + { + switch (ty) + { + case Tcomplex32: + case Timaginary32: + case Tfloat32: ivalue = FLT_MIN_EXP; goto Lint; + case Tcomplex64: + case Timaginary64: + case Tfloat64: ivalue = DBL_MIN_EXP; goto Lint; + case Tcomplex80: + case Timaginary80: + case Tfloat80: ivalue = LDBL_MIN_EXP; goto Lint; + } + } + + return Type::getProperty(loc, ident); + +Livalue: + e = new IntegerExp(loc, ivalue, this); + return e; + +Lfvalue: + if (isreal() || isimaginary()) + e = new RealExp(loc, fvalue, this); + else + { + complex_t cvalue; + +#if __DMC__ + //((real_t *)&cvalue)[0] = fvalue; + //((real_t *)&cvalue)[1] = fvalue; + cvalue = fvalue + fvalue * I; +#else + cvalue.re = fvalue; + cvalue.im = fvalue; +#endif + //for (int i = 0; i < 20; i++) + // printf("%02x ", ((unsigned char *)&cvalue)[i]); + //printf("\n"); + e = new ComplexExp(loc, cvalue, this); + } + return e; + +Lint: + e = new IntegerExp(loc, ivalue, Type::tint32); + return e; +} + +Expression *TypeBasic::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeBasic::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + Type *t; + + if (ident == Id::re) + { + switch (ty) + { + case Tcomplex32: t = tfloat32; goto L1; + case Tcomplex64: t = tfloat64; goto L1; + case Tcomplex80: t = tfloat80; goto L1; + L1: + e = e->castTo(sc, t); + break; + + case Tfloat32: + case Tfloat64: + case Tfloat80: + break; + + case Timaginary32: t = tfloat32; goto L2; + case Timaginary64: t = tfloat64; goto L2; + case Timaginary80: t = tfloat80; goto L2; + L2: + e = new RealExp(0, 0.0, t); + break; + + default: + e = Type::getProperty(e->loc, ident); + break; + } + } + else if (ident == Id::im) + { Type *t2; + + switch (ty) + { + case Tcomplex32: t = timaginary32; t2 = tfloat32; goto L3; + case Tcomplex64: t = timaginary64; t2 = tfloat64; goto L3; + case Tcomplex80: t = timaginary80; t2 = tfloat80; goto L3; + L3: + e = e->castTo(sc, t); + e->type = t2; + break; + + case Timaginary32: t = tfloat32; goto L4; + case Timaginary64: t = tfloat64; goto L4; + case Timaginary80: t = tfloat80; goto L4; + L4: + e = e->copy(); + e->type = t; + break; + + case Tfloat32: + case Tfloat64: + case Tfloat80: + e = new RealExp(0, 0.0, this); + break; + + default: + e = Type::getProperty(e->loc, ident); + break; + } + } + else + { + return Type::dotExp(sc, e, ident); + } + e = e->semantic(sc); + return e; +} + +Expression *TypeBasic::defaultInit(Loc loc) +{ dinteger_t value = 0; + +#if SNAN_DEFAULT_INIT + /* + * Use a payload which is different from the machine NaN, + * so that uninitialised variables can be + * detected even if exceptions are disabled. + */ + union + { unsigned short us[8]; + long double ld; + } snan = {{ 0, 0, 0, 0xA000, 0x7FFF }}; + /* + * Although long doubles are 10 bytes long, some + * C ABIs pad them out to 12 or even 16 bytes, so + * leave enough space in the snan array. + */ + assert(REALSIZE <= sizeof(snan)); + d_float80 fvalue = snan.ld; +#endif + +#if LOGDEFAULTINIT + printf("TypeBasic::defaultInit() '%s'\n", toChars()); +#endif + switch (ty) + { + case Tchar: + value = 0xFF; + break; + + case Twchar: + case Tdchar: + value = 0xFFFF; + break; + + case Timaginary32: + case Timaginary64: + case Timaginary80: + case Tfloat32: + case Tfloat64: + case Tfloat80: +#if SNAN_DEFAULT_INIT + return new RealExp(loc, fvalue, this); +#else + return getProperty(loc, Id::nan); +#endif + + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: +#if SNAN_DEFAULT_INIT + { // Can't use fvalue + I*fvalue (the im part becomes a quiet NaN). + complex_t cvalue; + ((real_t *)&cvalue)[0] = fvalue; + ((real_t *)&cvalue)[1] = fvalue; + return new ComplexExp(loc, cvalue, this); + } +#else + return getProperty(loc, Id::nan); +#endif + + case Tvoid: + error(loc, "void does not have a default initializer"); + return new ErrorExp(); + } + return new IntegerExp(loc, value, this); +} + +int TypeBasic::isZeroInit(Loc loc) +{ + switch (ty) + { + case Tchar: + case Twchar: + case Tdchar: + case Timaginary32: + case Timaginary64: + case Timaginary80: + case Tfloat32: + case Tfloat64: + case Tfloat80: + case Tcomplex32: + case Tcomplex64: + case Tcomplex80: + return 0; // no + } + return 1; // yes +} + +int TypeBasic::isintegral() +{ + //printf("TypeBasic::isintegral('%s') x%x\n", toChars(), flags); + return flags & TFLAGSintegral; +} + +int TypeBasic::isfloating() +{ + return flags & TFLAGSfloating; +} + +int TypeBasic::isreal() +{ + return flags & TFLAGSreal; +} + +int TypeBasic::isimaginary() +{ + return flags & TFLAGSimaginary; +} + +int TypeBasic::iscomplex() +{ + return flags & TFLAGScomplex; +} + +int TypeBasic::isunsigned() +{ + return flags & TFLAGSunsigned; +} + +int TypeBasic::isscalar() +{ + return flags & (TFLAGSintegral | TFLAGSfloating); +} + +MATCH TypeBasic::implicitConvTo(Type *to) +{ + //printf("TypeBasic::implicitConvTo(%s) from %s\n", to->toChars(), toChars()); + if (this == to) + return MATCHexact; + +#if DMDV2 + if (ty == to->ty) + { + if (mod == to->mod) + return MATCHexact; + else if (MODimplicitConv(mod, to->mod)) + return MATCHconst; + else if (!((mod ^ to->mod) & MODshared)) // for wild matching + return MATCHconst; + else + return MATCHconvert; + } +#endif + + if (ty == Tvoid || to->ty == Tvoid) + return MATCHnomatch; + if (to->ty == Tbool) + return MATCHnomatch; + + TypeBasic *tob; + if (to->ty == Tvector) + { + TypeVector *tv = (TypeVector *)to; + tob = tv->elementType(); + } + else + tob = to->isTypeBasic(); + if (!tob) + return MATCHnomatch; + + if (flags & TFLAGSintegral) + { + // Disallow implicit conversion of integers to imaginary or complex + if (tob->flags & (TFLAGSimaginary | TFLAGScomplex)) + return MATCHnomatch; + +#if DMDV2 + // If converting from integral to integral + if (tob->flags & TFLAGSintegral) + { d_uns64 sz = size(0); + d_uns64 tosz = tob->size(0); + + /* Can't convert to smaller size + */ + if (sz > tosz) + return MATCHnomatch; + + /* Can't change sign if same size + */ + /*if (sz == tosz && (flags ^ tob->flags) & TFLAGSunsigned) + return MATCHnomatch;*/ + } +#endif + } + else if (flags & TFLAGSfloating) + { + // Disallow implicit conversion of floating point to integer + if (tob->flags & TFLAGSintegral) + return MATCHnomatch; + + assert(tob->flags & TFLAGSfloating); + + // Disallow implicit conversion from complex to non-complex + if (flags & TFLAGScomplex && !(tob->flags & TFLAGScomplex)) + return MATCHnomatch; + + // Disallow implicit conversion of real or imaginary to complex + if (flags & (TFLAGSreal | TFLAGSimaginary) && + tob->flags & TFLAGScomplex) + return MATCHnomatch; + + // Disallow implicit conversion to-from real and imaginary + if ((flags & (TFLAGSreal | TFLAGSimaginary)) != + (tob->flags & (TFLAGSreal | TFLAGSimaginary))) + return MATCHnomatch; + } + return MATCHconvert; +} + +TypeBasic *TypeBasic::isTypeBasic() +{ + return (TypeBasic *)this; +} + +/* ============================= TypeVector =========================== */ + +/* The basetype must be one of: + * byte[16],ubyte[16],short[8],ushort[8],int[4],uint[4],long[2],ulong[2],float[4],double[2] + */ +TypeVector::TypeVector(Loc loc, Type *basetype) + : Type(Tvector) +{ + this->basetype = basetype; +} + +Type *TypeVector::syntaxCopy() +{ + return new TypeVector(0, basetype->syntaxCopy()); +} + +Type *TypeVector::semantic(Loc loc, Scope *sc) +{ + int errors = global.errors; + basetype = basetype->semantic(loc, sc); + if (errors != global.errors) + return terror; + basetype = basetype->toBasetype()->mutableOf(); + if (basetype->ty != Tsarray || basetype->size() != 16) + { error(loc, "base type of __vector must be a 16 byte static array, not %s", basetype->toChars()); + return terror; + } + TypeSArray *t = (TypeSArray *)basetype; + TypeBasic *tb = t->nextOf()->isTypeBasic(); + if (!tb || !(tb->flags & TFLAGSvector)) + { error(loc, "base type of __vector must be a static array of an arithmetic type, not %s", t->toChars()); + return terror; + } + return merge(); +} + +TypeBasic *TypeVector::elementType() +{ + assert(basetype->ty == Tsarray); + TypeSArray *t = (TypeSArray *)basetype; + TypeBasic *tb = t->nextOf()->isTypeBasic(); + assert(tb); + return tb; +} + +int TypeVector::checkBoolean() +{ + return FALSE; +} + +char *TypeVector::toChars() +{ + return Type::toChars(); +} + +void TypeVector::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + //printf("TypeVector::toCBuffer2(mod = %d, this->mod = %d)\n", mod, this->mod); + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring("__vector("); + basetype->toCBuffer2(buf, hgs, this->mod); + buf->writestring(")"); +} + +void TypeVector::toDecoBuffer(OutBuffer *buf, int flag) +{ + if (flag != mod && flag != 0x100) + { + MODtoDecoBuffer(buf, mod); + } + buf->writestring("Nh"); + basetype->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod); +} + +d_uns64 TypeVector::size(Loc loc) +{ + return 16; +} + +unsigned TypeVector::alignsize() +{ + return 16; +} + +Expression *TypeVector::getProperty(Loc loc, Identifier *ident) +{ + return basetype->getProperty(loc, ident); +} + +Expression *TypeVector::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeVector::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (ident == Id::array) + { + e = e->castTo(sc, basetype); + return e; + } + return basetype->dotExp(sc, e->castTo(sc, basetype), ident); +} + +Expression *TypeVector::defaultInit(Loc loc) +{ + return basetype->defaultInit(loc); +} + +int TypeVector::isZeroInit(Loc loc) +{ + return basetype->isZeroInit(loc); +} + +int TypeVector::isintegral() +{ + //printf("TypeVector::isintegral('%s') x%x\n", toChars(), flags); + return basetype->nextOf()->isintegral(); +} + +int TypeVector::isfloating() +{ + return basetype->nextOf()->isfloating(); +} + +int TypeVector::isunsigned() +{ + return basetype->nextOf()->isunsigned(); +} + +int TypeVector::isscalar() +{ + return basetype->nextOf()->isscalar(); +} + +MATCH TypeVector::implicitConvTo(Type *to) +{ + //printf("TypeVector::implicitConvTo(%s) from %s\n", to->toChars(), toChars()); + if (this == to) + return MATCHexact; + if (ty == to->ty) + return MATCHconvert; + return MATCHnomatch; +} + +/***************************** TypeArray *****************************/ + +TypeArray::TypeArray(TY ty, Type *next) + : TypeNext(ty, next) +{ +} + +Expression *TypeArray::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ + Type *n = this->next->toBasetype(); // uncover any typedef's + +#if LOGDOTEXP + printf("TypeArray::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + + if (!n->isMutable()) + if (ident == Id::sort || ident == Id::reverse) + error(e->loc, "can only %s a mutable array\n", ident->toChars()); + + if (ident == Id::reverse && (n->ty == Tchar || n->ty == Twchar)) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + const char *nm; + static const char *name[2] = { "_adReverseChar", "_adReverseWchar" }; + + nm = name[n->ty == Twchar]; + fd = FuncDeclaration::genCfunc(Type::tindex, nm); + ec = new VarExp(0, fd); + e = e->castTo(sc, n->arrayOf()); // convert to dynamic array + arguments = new Expressions(); + arguments->push(e); + e = new CallExp(e->loc, ec, arguments); + e->type = next->arrayOf(); + } + else if (ident == Id::sort && (n->ty == Tchar || n->ty == Twchar)) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + const char *nm; + static const char *name[2] = { "_adSortChar", "_adSortWchar" }; + + nm = name[n->ty == Twchar]; + fd = FuncDeclaration::genCfunc(Type::tindex, nm); + ec = new VarExp(0, fd); + e = e->castTo(sc, n->arrayOf()); // convert to dynamic array + arguments = new Expressions(); + arguments->push(e); + e = new CallExp(e->loc, ec, arguments); + e->type = next->arrayOf(); + } + else if (ident == Id::reverse || ident == Id::dup || ident == Id::idup) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + int size = next->size(e->loc); + int dup; + + Expression *olde = e; + assert(size); + dup = (ident == Id::dup || ident == Id::idup); + fd = FuncDeclaration::genCfunc(Type::tindex, dup ? Id::adDup : Id::adReverse); + ec = new VarExp(0, fd); + e = e->castTo(sc, n->arrayOf()); // convert to dynamic array + arguments = new Expressions(); + if (dup) + arguments->push(getTypeInfo(sc)); + arguments->push(e); + if (!dup) + arguments->push(new IntegerExp(0, size, Type::tsize_t)); + e = new CallExp(e->loc, ec, arguments); + if (ident == Id::idup) + { Type *einv = next->invariantOf(); + if (next->implicitConvTo(einv) < MATCHconst) + error(e->loc, "cannot implicitly convert element type %s to immutable in %s.idup", + next->toChars(), olde->toChars()); + e->type = einv->arrayOf(); + } + else if (ident == Id::dup) + { + Type *emut = next->mutableOf(); + if (next->implicitConvTo(emut) < MATCHconst) + error(e->loc, "cannot implicitly convert element type %s to mutable in %s.dup", + next->toChars(), olde->toChars()); + e->type = emut->arrayOf(); + } + else + e->type = next->mutableOf()->arrayOf(); + } + else if (ident == Id::sort) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + + fd = FuncDeclaration::genCfunc(tint32->arrayOf(), "_adSort"); + ec = new VarExp(0, fd); + e = e->castTo(sc, n->arrayOf()); // convert to dynamic array + arguments = new Expressions(); + arguments->push(e); + arguments->push(n->ty == Tsarray + ? n->getTypeInfo(sc) // don't convert to dynamic array + : n->getInternalTypeInfo(sc)); + e = new CallExp(e->loc, ec, arguments); + e->type = next->arrayOf(); + } + else + { + e = Type::dotExp(sc, e, ident); + } + e = e->semantic(sc); + return e; +} + + +/***************************** TypeSArray *****************************/ + +TypeSArray::TypeSArray(Type *t, Expression *dim) + : TypeArray(Tsarray, t) +{ + //printf("TypeSArray(%s)\n", dim->toChars()); + this->dim = dim; +} + +Type *TypeSArray::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + Expression *e = dim->syntaxCopy(); + t = new TypeSArray(t, e); + t->mod = mod; + return t; +} + +d_uns64 TypeSArray::size(Loc loc) +{ dinteger_t sz; + + if (!dim) + return Type::size(loc); + sz = dim->toInteger(); + + { dinteger_t n, n2; + + n = next->size(); + n2 = n * sz; + if (n && (n2 / n) != sz) + goto Loverflow; + sz = n2; + } + return sz; + +Loverflow: + error(loc, "index %jd overflow for static array", sz); + return 1; +} + +unsigned TypeSArray::alignsize() +{ + return next->alignsize(); +} + +/************************** + * This evaluates exp while setting length to be the number + * of elements in the tuple t. + */ +Expression *semanticLength(Scope *sc, Type *t, Expression *exp) +{ + if (t->ty == Ttuple) + { ScopeDsymbol *sym = new ArrayScopeSymbol(sc, (TypeTuple *)t); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + exp = exp->semantic(sc); + + sc->pop(); + } + else + exp = exp->semantic(sc); + return exp; +} + +Expression *semanticLength(Scope *sc, TupleDeclaration *s, Expression *exp) +{ + ScopeDsymbol *sym = new ArrayScopeSymbol(sc, s); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + exp = exp->semantic(sc); + + sc->pop(); + return exp; +} + +void TypeSArray::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + //printf("TypeSArray::resolve() %s\n", toChars()); + next->resolve(loc, sc, pe, pt, ps); + //printf("s = %p, e = %p, t = %p\n", *ps, *pe, *pt); + if (*pe) + { // It's really an index expression + Expression *e = new IndexExp(loc, *pe, dim); + *pe = e; + } + else if (*ps) + { Dsymbol *s = *ps; + TupleDeclaration *td = s->isTupleDeclaration(); + if (td) + { + ScopeDsymbol *sym = new ArrayScopeSymbol(sc, td); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + dim = dim->semantic(sc); + dim = dim->optimize(WANTvalue | WANTinterpret); + uinteger_t d = dim->toUInteger(); + + sc = sc->pop(); + + if (d >= td->objects->dim) + { error(loc, "tuple index %ju exceeds length %u", d, td->objects->dim); + goto Ldefault; + } + Object *o = td->objects->tdata()[(size_t)d]; + if (o->dyncast() == DYNCAST_DSYMBOL) + { + *ps = (Dsymbol *)o; + return; + } + if (o->dyncast() == DYNCAST_EXPRESSION) + { + *ps = NULL; + *pe = (Expression *)o; + return; + } + if (o->dyncast() == DYNCAST_TYPE) + { + *ps = NULL; + *pt = (Type *)o; + return; + } + + /* Create a new TupleDeclaration which + * is a slice [d..d+1] out of the old one. + * Do it this way because TemplateInstance::semanticTiargs() + * can handle unresolved Objects this way. + */ + Objects *objects = new Objects; + objects->setDim(1); + objects->tdata()[0] = o; + + TupleDeclaration *tds = new TupleDeclaration(loc, td->ident, objects); + *ps = tds; + } + else + goto Ldefault; + } + else + { + Ldefault: + Type::resolve(loc, sc, pe, pt, ps); + } +} + +Type *TypeSArray::semantic(Loc loc, Scope *sc) +{ + //printf("TypeSArray::semantic() %s\n", toChars()); + + Type *t; + Expression *e; + Dsymbol *s; + next->resolve(loc, sc, &e, &t, &s); + if (dim && s && s->isTupleDeclaration()) + { TupleDeclaration *sd = s->isTupleDeclaration(); + + dim = semanticLength(sc, sd, dim); + dim = dim->optimize(WANTvalue | WANTinterpret); + uinteger_t d = dim->toUInteger(); + + if (d >= sd->objects->dim) + { error(loc, "tuple index %ju exceeds %u", d, sd->objects->dim); + return Type::terror; + } + Object *o = sd->objects->tdata()[(size_t)d]; + if (o->dyncast() != DYNCAST_TYPE) + { error(loc, "%s is not a type", toChars()); + return Type::terror; + } + t = (Type *)o; + return t; + } + + Type *tn = next->semantic(loc,sc); + if (tn->ty == Terror) + return terror; + + Type *tbn = tn->toBasetype(); + + if (dim) + { dinteger_t n, n2; + + int errors = global.errors; + dim = semanticLength(sc, tbn, dim); + if (errors != global.errors) + goto Lerror; + + dim = dim->optimize(WANTvalue); + if (sc && sc->parameterSpecialization && dim->op == TOKvar && + ((VarExp *)dim)->var->storage_class & STCtemplateparameter) + { + /* It could be a template parameter N which has no value yet: + * template Foo(T : T[N], size_t N); + */ + return this; + } + dim = dim->optimize(WANTvalue | WANTinterpret); + dinteger_t d1 = dim->toInteger(); + dim = dim->implicitCastTo(sc, tsize_t); + dim = dim->optimize(WANTvalue); + dinteger_t d2 = dim->toInteger(); + + if (dim->op == TOKerror) + goto Lerror; + + if (d1 != d2) + goto Loverflow; + + if (tbn->isintegral() || + tbn->isfloating() || + tbn->ty == Tpointer || + tbn->ty == Tarray || + tbn->ty == Tsarray || + tbn->ty == Taarray || + tbn->ty == Tclass) + { + /* Only do this for types that don't need to have semantic() + * run on them for the size, since they may be forward referenced. + */ + n = tbn->size(loc); + n2 = n * d2; + if ((int)n2 < 0) + goto Loverflow; + if (n2 >= 0x1000000) // put a 'reasonable' limit on it + goto Loverflow; + if (n && n2 / n != d2) + { + Loverflow: + error(loc, "index %jd overflow for static array", d1); + goto Lerror; + } + } + } + switch (tbn->ty) + { + case Ttuple: + { // Index the tuple to get the type + assert(dim); + TypeTuple *tt = (TypeTuple *)tbn; + uinteger_t d = dim->toUInteger(); + + if (d >= tt->arguments->dim) + { error(loc, "tuple index %ju exceeds %u", d, tt->arguments->dim); + goto Lerror; + } + Parameter *arg = tt->arguments->tdata()[(size_t)d]; + return arg->type; + } + case Tstruct: + { TypeStruct *ts = (TypeStruct *)tbn; + if (0 && ts->sym->isnested) + { error(loc, "cannot have static array of inner struct %s", ts->toChars()); + goto Lerror; + } + break; + } + case Tfunction: + case Tnone: + error(loc, "can't have array of %s", tbn->toChars()); + goto Lerror; + } + if (tbn->isscope()) + { error(loc, "cannot have array of scope %s", tbn->toChars()); + goto Lerror; + } + + /* Ensure things like const(immutable(T)[3]) become immutable(T[3]) + * and const(T)[3] become const(T[3]) + */ + next = tn; + transitive(); + t = addMod(tn->mod); + + return t->merge(); + +Lerror: + return Type::terror; +} + +void TypeSArray::toDecoBuffer(OutBuffer *buf, int flag) +{ + Type::toDecoBuffer(buf, flag); + if (dim) + buf->printf("%ju", dim->toInteger()); + if (next) + /* Note that static arrays are value types, so + * for a parameter, propagate the 0x100 to the next + * level, since for T[4][3], any const should apply to the T, + * not the [4]. + */ + next->toDecoBuffer(buf, (flag & 0x100) ? flag : mod); +} + +void TypeSArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + next->toCBuffer2(buf, hgs, this->mod); + buf->printf("[%s]", dim->toChars()); +} + +Expression *TypeSArray::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeSArray::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (ident == Id::length) + { + e = dim; + } + else if (ident == Id::ptr) + { + e = e->castTo(sc, next->pointerTo()); + } + else + { + e = TypeArray::dotExp(sc, e, ident); + } + e = e->semantic(sc); + return e; +} + +int TypeSArray::isString() +{ + TY nty = next->toBasetype()->ty; + return nty == Tchar || nty == Twchar || nty == Tdchar; +} + +unsigned TypeSArray::memalign(unsigned salign) +{ + return next->memalign(salign); +} + +MATCH TypeSArray::constConv(Type *to) +{ + if (to->ty == Tsarray) + { + TypeSArray *tsa = (TypeSArray *)to; + if (!dim->equals(tsa->dim)) + return MATCHnomatch; + } + return TypeNext::constConv(to); +} + +MATCH TypeSArray::implicitConvTo(Type *to) +{ + //printf("TypeSArray::implicitConvTo(to = %s) this = %s\n", to->toChars(), toChars()); + + // Allow implicit conversion of static array to pointer or dynamic array + if (IMPLICIT_ARRAY_TO_PTR && to->ty == Tpointer) + { + TypePointer *tp = (TypePointer *)to; + + if (!MODimplicitConv(next->mod, tp->next->mod)) + return MATCHnomatch; + + if (tp->next->ty == Tvoid || next->constConv(tp->next) != MATCHnomatch) + { + return MATCHconvert; + } + return MATCHnomatch; + } + if (to->ty == Tarray) + { + TypeDArray *ta = (TypeDArray *)to; + + if (!MODimplicitConv(next->mod, ta->next->mod)) + return MATCHnomatch; + + /* Allow conversion to void[] + */ + if (ta->next->ty == Tvoid) + { + return MATCHconvert; + } + + MATCH m = next->constConv(ta->next); + if (m != MATCHnomatch) + { + return MATCHconvert; + } + return MATCHnomatch; + } + + if (to->ty == Tsarray) + { + if (this == to) + return MATCHexact; + + TypeSArray *tsa = (TypeSArray *)to; + + if (dim->equals(tsa->dim)) + { + /* Since static arrays are value types, allow + * conversions from const elements to non-const + * ones, just like we allow conversion from const int + * to int. + */ + MATCH m = next->implicitConvTo(tsa->next); + if (m >= MATCHconst) + { + if (mod != to->mod) + m = MATCHconst; + return m; + } + } + } + return MATCHnomatch; +} + +Expression *TypeSArray::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeSArray::defaultInit() '%s'\n", toChars()); +#endif + return next->defaultInit(loc); +} + +int TypeSArray::isZeroInit(Loc loc) +{ + return next->isZeroInit(loc); +} + +int TypeSArray::needsDestruction() +{ + return next->needsDestruction(); +} + +Expression *TypeSArray::defaultInitLiteral(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeSArray::defaultInitLiteral() '%s'\n", toChars()); +#endif + size_t d = dim->toInteger(); + Expression *elementinit = next->defaultInitLiteral(loc); + Expressions *elements = new Expressions(); + elements->setDim(d); + for (size_t i = 0; i < d; i++) + elements->tdata()[i] = elementinit; + ArrayLiteralExp *ae = new ArrayLiteralExp(0, elements); + ae->type = this; + return ae; +} + +Expression *TypeSArray::toExpression() +{ + Expression *e = next->toExpression(); + if (e) + { Expressions *arguments = new Expressions(); + arguments->push(dim); + e = new ArrayExp(dim->loc, e, arguments); + } + return e; +} + +int TypeSArray::hasPointers() +{ + /* Don't want to do this, because: + * struct S { T* array[0]; } + * may be a variable length struct. + */ + //if (dim->toInteger() == 0) + //return FALSE; + + if (next->ty == Tvoid) + // Arrays of void contain arbitrary data, which may include pointers + return TRUE; + else + return next->hasPointers(); +} + +/***************************** TypeDArray *****************************/ + +TypeDArray::TypeDArray(Type *t) + : TypeArray(Tarray, t) +{ + //printf("TypeDArray(t = %p)\n", t); +} + +Type *TypeDArray::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + if (t == next) + t = this; + else + { t = new TypeDArray(t); + t->mod = mod; + } + return t; +} + +d_uns64 TypeDArray::size(Loc loc) +{ + //printf("TypeDArray::size()\n"); + return PTRSIZE * 2; +} + +unsigned TypeDArray::alignsize() +{ + // A DArray consists of two ptr-sized values, so align it on pointer size + // boundary + return PTRSIZE; +} + +Type *TypeDArray::semantic(Loc loc, Scope *sc) +{ Type *tn = next; + + tn = next->semantic(loc,sc); + Type *tbn = tn->toBasetype(); + switch (tbn->ty) + { + case Tfunction: + case Tnone: + case Ttuple: + error(loc, "can't have array of %s", tbn->toChars()); + case Terror: + return Type::terror; + + case Tstruct: + { TypeStruct *ts = (TypeStruct *)tbn; + if (0 && ts->sym->isnested) + error(loc, "cannot have dynamic array of inner struct %s", ts->toChars()); + break; + } + } + if (tn->isscope()) + error(loc, "cannot have array of scope %s", tn->toChars()); + + next = tn; + transitive(); + return merge(); +} + +void TypeDArray::toDecoBuffer(OutBuffer *buf, int flag) +{ + Type::toDecoBuffer(buf, flag); + if (next) + next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod); +} + +void TypeDArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + if (equals(tstring)) + buf->writestring("string"); + else + { next->toCBuffer2(buf, hgs, this->mod); + buf->writestring("[]"); + } +} + +Expression *TypeDArray::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeDArray::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (ident == Id::length) + { + if (e->op == TOKstring) + { StringExp *se = (StringExp *)e; + + return new IntegerExp(se->loc, se->len, Type::tindex); + } + if (e->op == TOKnull) + return new IntegerExp(e->loc, 0, Type::tindex); + e = new ArrayLengthExp(e->loc, e); + e->type = Type::tsize_t; + return e; + } + else if (ident == Id::ptr) + { + e = e->castTo(sc, next->pointerTo()); + return e; + } + else + { + e = TypeArray::dotExp(sc, e, ident); + } + return e; +} + +int TypeDArray::isString() +{ + TY nty = next->toBasetype()->ty; + return nty == Tchar || nty == Twchar || nty == Tdchar; +} + +MATCH TypeDArray::implicitConvTo(Type *to) +{ + //printf("TypeDArray::implicitConvTo(to = %s) this = %s\n", to->toChars(), toChars()); + if (equals(to)) + return MATCHexact; + + // Allow implicit conversion of array to pointer + if (IMPLICIT_ARRAY_TO_PTR && to->ty == Tpointer) + { + TypePointer *tp = (TypePointer *)to; + + /* Allow conversion to void* + */ + if (tp->next->ty == Tvoid && + MODimplicitConv(next->mod, tp->next->mod)) + { + return MATCHconvert; + } + + return next->constConv(to); + } + + if (to->ty == Tarray) + { + TypeDArray *ta = (TypeDArray *)to; + + if (!MODimplicitConv(next->mod, ta->next->mod)) + return MATCHnomatch; // not const-compatible + + // Check head inout conversion: + // T [] -> inout(const(T)[]) + // const(T)[] -> inout(const(T)[]) + if (isMutable() && ta->isWild()) + if ((next->isMutable() || next->isConst()) && ta->next->isConst()) + return MATCHnomatch; + + /* Allow conversion to void[] + */ + if (next->ty != Tvoid && ta->next->ty == Tvoid) + { + return MATCHconvert; + } + + MATCH m = next->constConv(ta->next); + if (m != MATCHnomatch) + { + if (m == MATCHexact && mod != to->mod) + m = MATCHconst; + return m; + } + } + return Type::implicitConvTo(to); +} + +Expression *TypeDArray::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeDArray::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypeDArray::isZeroInit(Loc loc) +{ + return 1; +} + +int TypeDArray::checkBoolean() +{ + return TRUE; +} + +int TypeDArray::hasPointers() +{ + return TRUE; +} + + +/***************************** TypeAArray *****************************/ + +TypeAArray::TypeAArray(Type *t, Type *index) + : TypeArray(Taarray, t) +{ + this->index = index; + this->impl = NULL; + this->loc = 0; + this->sc = NULL; +} + +Type *TypeAArray::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + Type *ti = index->syntaxCopy(); + if (t == next && ti == index) + t = this; + else + { t = new TypeAArray(t, ti); + t->mod = mod; + } + return t; +} + +d_uns64 TypeAArray::size(Loc loc) +{ + return PTRSIZE /* * 2*/; +} + + +Type *TypeAArray::semantic(Loc loc, Scope *sc) +{ + //printf("TypeAArray::semantic() %s index->ty = %d\n", toChars(), index->ty); + if (deco) + return this; + + this->loc = loc; + this->sc = sc; + if (sc) + sc->setNoFree(); + + // Deal with the case where we thought the index was a type, but + // in reality it was an expression. + if (index->ty == Tident || index->ty == Tinstance || index->ty == Tsarray) + { + Expression *e; + Type *t; + Dsymbol *s; + + index->resolve(loc, sc, &e, &t, &s); + if (e) + { // It was an expression - + // Rewrite as a static array + TypeSArray *tsa; + + tsa = new TypeSArray(next, e); + return tsa->semantic(loc,sc); + } + else if (t) + index = t; + else + { index->error(loc, "index is not a type or an expression"); + return Type::terror; + } + } + else + index = index->semantic(loc,sc); + + if (index->nextOf() && !index->nextOf()->isImmutable()) + { + index = index->constOf()->mutableOf(); +#if 0 +printf("index is %p %s\n", index, index->toChars()); +index->check(); +printf("index->mod = x%x\n", index->mod); +printf("index->ito = x%x\n", index->ito); +if (index->ito) { +printf("index->ito->mod = x%x\n", index->ito->mod); +printf("index->ito->ito = x%x\n", index->ito->ito); +} +#endif + } + + switch (index->toBasetype()->ty) + { + case Tfunction: + case Tvoid: + case Tnone: + case Ttuple: + error(loc, "can't have associative array key of %s", index->toBasetype()->toChars()); + case Terror: + return Type::terror; + } + next = next->semantic(loc,sc); + transitive(); + + switch (next->toBasetype()->ty) + { + case Tfunction: + case Tvoid: + case Tnone: + error(loc, "can't have associative array of %s", next->toChars()); + case Terror: + return Type::terror; + } + if (next->isscope()) + { error(loc, "cannot have array of scope %s", next->toChars()); + return Type::terror; + } + return merge(); +} + +StructDeclaration *TypeAArray::getImpl() +{ + // Do it lazily + if (!impl) + { + Type *index = this->index; + Type *next = this->next; + if (index->reliesOnTident() || next->reliesOnTident()) + { + error(loc, "cannot create associative array %s", toChars()); + index = terror; + next = terror; + + // Head off future failures + StructDeclaration *s = new StructDeclaration(0, NULL); + s->type = terror; + impl = s; + return impl; + } + /* This is really a proxy for the template instance AssocArray!(index, next) + * But the instantiation can fail if it is a template specialization field + * which has Tident's instead of real types. + */ + Objects *tiargs = new Objects(); + tiargs->push(index); + tiargs->push(next); + + // Create AssociativeArray!(index, next) +#if 1 + if (! Type::associativearray) + { + ObjectNotFound(Id::AssociativeArray); + } + TemplateInstance *ti = new TemplateInstance(loc, Type::associativearray, tiargs); +#else + //Expression *e = new IdentifierExp(loc, Id::object); + Expression *e = new IdentifierExp(loc, Id::empty); + //e = new DotIdExp(loc, e, Id::object); + DotTemplateInstanceExp *dti = new DotTemplateInstanceExp(loc, + e, + Id::AssociativeArray, + tiargs); + dti->semantic(sc); + TemplateInstance *ti = dti->ti; +#endif + ti->semantic(sc); + ti->semantic2(sc); + ti->semantic3(sc); + impl = ti->toAlias()->isStructDeclaration(); +#ifdef DEBUG + if (!impl) + { Dsymbol *s = ti->toAlias(); + printf("%s %s\n", s->kind(), s->toChars()); + } +#endif + assert(impl); + } + return impl; +} + +void TypeAArray::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + //printf("TypeAArray::resolve() %s\n", toChars()); + + // Deal with the case where we thought the index was a type, but + // in reality it was an expression. + if (index->ty == Tident || index->ty == Tinstance || index->ty == Tsarray) + { + Expression *e; + Type *t; + Dsymbol *s; + + index->resolve(loc, sc, &e, &t, &s); + if (e) + { // It was an expression - + // Rewrite as a static array + + TypeSArray *tsa = new TypeSArray(next, e); + return tsa->resolve(loc, sc, pe, pt, ps); + } + else if (t) + index = t; + else + index->error(loc, "index is not a type or an expression"); + } + Type::resolve(loc, sc, pe, pt, ps); +} + + +Expression *TypeAArray::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeAArray::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif +#if 0 + if (ident == Id::length) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + + fd = FuncDeclaration::genCfunc(Type::tsize_t, Id::aaLen); + ec = new VarExp(0, fd); + arguments = new Expressions(); + arguments->push(e); + e = new CallExp(e->loc, ec, arguments); + e->type = ((TypeFunction *)fd->type)->next; + } + else + if (ident == Id::keys) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + int size = index->size(e->loc); + + assert(size); + fd = FuncDeclaration::genCfunc(Type::tindex, Id::aaKeys); + ec = new VarExp(0, fd); + arguments = new Expressions(); + arguments->push(e); + arguments->push(new IntegerExp(0, size, Type::tsize_t)); + e = new CallExp(e->loc, ec, arguments); + e->type = index->arrayOf(); + } + else if (ident == Id::values) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + + fd = FuncDeclaration::genCfunc(Type::tindex, Id::aaValues); + ec = new VarExp(0, fd); + arguments = new Expressions(); + arguments->push(e); + size_t keysize = index->size(e->loc); + keysize = (keysize + PTRSIZE - 1) & ~(PTRSIZE - 1); + arguments->push(new IntegerExp(0, keysize, Type::tsize_t)); + arguments->push(new IntegerExp(0, next->size(e->loc), Type::tsize_t)); + e = new CallExp(e->loc, ec, arguments); + e->type = next->arrayOf(); + } + else if (ident == Id::rehash) + { + Expression *ec; + FuncDeclaration *fd; + Expressions *arguments; + + fd = FuncDeclaration::genCfunc(Type::tint64, Id::aaRehash); + ec = new VarExp(0, fd); + arguments = new Expressions(); + arguments->push(e->addressOf(sc)); + arguments->push(index->getInternalTypeInfo(sc)); + e = new CallExp(e->loc, ec, arguments); + e->type = this; + } + else +#endif + if (ident != Id::__sizeof && + ident != Id::__xalignof && + ident != Id::init && + ident != Id::mangleof && + ident != Id::stringof && + ident != Id::offsetof) + { + e->type = getImpl()->type; + e = e->type->dotExp(sc, e, ident); + } + else + e = Type::dotExp(sc, e, ident); + return e; +} + +void TypeAArray::toDecoBuffer(OutBuffer *buf, int flag) +{ + Type::toDecoBuffer(buf, flag); + index->toDecoBuffer(buf); + next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod); +} + +void TypeAArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + next->toCBuffer2(buf, hgs, this->mod); + buf->writeByte('['); + index->toCBuffer2(buf, hgs, 0); + buf->writeByte(']'); +} + +Expression *TypeAArray::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeAArray::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypeAArray::isZeroInit(Loc loc) +{ + return TRUE; +} + +int TypeAArray::checkBoolean() +{ + return TRUE; +} + +int TypeAArray::hasPointers() +{ + return TRUE; +} + +MATCH TypeAArray::implicitConvTo(Type *to) +{ + //printf("TypeAArray::implicitConvTo(to = %s) this = %s\n", to->toChars(), toChars()); + if (equals(to)) + return MATCHexact; + + if (to->ty == Taarray) + { TypeAArray *ta = (TypeAArray *)to; + + if (!MODimplicitConv(next->mod, ta->next->mod)) + return MATCHnomatch; // not const-compatible + + if (!MODimplicitConv(index->mod, ta->index->mod)) + return MATCHnomatch; // not const-compatible + + // Check head inout conversion: + // V [K] -> inout(const(V)[K]) + // const(V)[K] -> inout(const(V)[K]) + if (isMutable() && ta->isWild()) + if ((next->isMutable() || next->isConst()) && ta->next->isConst()) + return MATCHnomatch; + + MATCH m = next->constConv(ta->next); + MATCH mi = index->constConv(ta->index); + if (m != MATCHnomatch && mi != MATCHnomatch) + { + if (m == MATCHexact && mod != to->mod) + m = MATCHconst; + if (mi < m) + m = mi; + return m; + } + } + else if (to->ty == Tstruct && ((TypeStruct *)to)->sym->ident == Id::AssociativeArray) + { + int errs = global.startGagging(); + Type *from = getImpl()->type; + if (global.endGagging(errs)) + { + return MATCHnomatch; + } + return from->implicitConvTo(to); + } + return Type::implicitConvTo(to); +} + +MATCH TypeAArray::constConv(Type *to) +{ + if (to->ty == Taarray) + { + TypeAArray *taa = (TypeAArray *)to; + MATCH mindex = index->constConv(taa->index); + MATCH mkey = next->constConv(taa->next); + // Pick the worst match + return mkey < mindex ? mkey : mindex; + } + return Type::constConv(to); +} + +/***************************** TypePointer *****************************/ + +TypePointer::TypePointer(Type *t) + : TypeNext(Tpointer, t) +{ +} + +Type *TypePointer::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + if (t == next) + t = this; + else + { t = new TypePointer(t); + t->mod = mod; + } + return t; +} + +Type *TypePointer::semantic(Loc loc, Scope *sc) +{ + //printf("TypePointer::semantic()\n"); + if (deco) + return this; + Type *n = next->semantic(loc, sc); + switch (n->toBasetype()->ty) + { + case Ttuple: + error(loc, "can't have pointer to %s", n->toChars()); + case Terror: + return Type::terror; + } + if (n != next) + { + deco = NULL; + } + next = n; + transitive(); + return merge(); +} + + +d_uns64 TypePointer::size(Loc loc) +{ + return PTRSIZE; +} + +void TypePointer::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + //printf("TypePointer::toCBuffer2() next = %d\n", next->ty); + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + next->toCBuffer2(buf, hgs, this->mod); + if (next->ty != Tfunction) + buf->writeByte('*'); +} + +MATCH TypePointer::implicitConvTo(Type *to) +{ + //printf("TypePointer::implicitConvTo(to = %s) %s\n", to->toChars(), toChars()); + + if (equals(to)) + return MATCHexact; + if (next->ty == Tfunction) + { + if (to->ty == Tpointer) + { + TypePointer *tp = (TypePointer*)to; + if (tp->next->ty == Tfunction) + { + if (next->equals(tp->next)) + return MATCHconst; + + if (next->covariant(tp->next) == 1) + return MATCHconvert; + } + else if (tp->next->ty == Tvoid) + { + // Allow conversions to void* + return MATCHconvert; + } + } + return MATCHnomatch; + } + else if (to->ty == Tpointer) + { + TypePointer *tp = (TypePointer *)to; + assert(tp->next); + + if (!MODimplicitConv(next->mod, tp->next->mod)) + return MATCHnomatch; // not const-compatible + + // Check head inout conversion: + // T * -> inout(const(T)*) + // const(T)* -> inout(const(T)*) + if (isMutable() && tp->isWild()) + if ((next->isMutable() || next->isConst()) && tp->next->isConst()) + return MATCHnomatch; + + /* Alloc conversion to void* + */ + if (next->ty != Tvoid && tp->next->ty == Tvoid) + { + return MATCHconvert; + } + + MATCH m = next->constConv(tp->next); + if (m != MATCHnomatch) + { + if (m == MATCHexact && mod != to->mod) + m = MATCHconst; + return m; + } + } + return MATCHnomatch; +} + +MATCH TypePointer::constConv(Type *to) +{ + if (next->ty == Tfunction) + { + if (to->nextOf() && next->equals(((TypeNext*)to)->next)) + return Type::constConv(to); + else + return MATCHnomatch; + } + return TypeNext::constConv(to); +} + +int TypePointer::isscalar() +{ + return TRUE; +} + +Expression *TypePointer::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypePointer::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypePointer::isZeroInit(Loc loc) +{ + return 1; +} + +int TypePointer::hasPointers() +{ + return TRUE; +} + + +/***************************** TypeReference *****************************/ + +TypeReference::TypeReference(Type *t) + : TypeNext(Treference, t) +{ + // BUG: what about references to static arrays? +} + +Type *TypeReference::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + if (t == next) + t = this; + else + { t = new TypeReference(t); + t->mod = mod; + } + return t; +} + +Type *TypeReference::semantic(Loc loc, Scope *sc) +{ + //printf("TypeReference::semantic()\n"); + Type *n = next->semantic(loc, sc); + if (n != next) + deco = NULL; + next = n; + transitive(); + return merge(); +} + + +d_uns64 TypeReference::size(Loc loc) +{ + return PTRSIZE; +} + +void TypeReference::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + next->toCBuffer2(buf, hgs, this->mod); + buf->writeByte('&'); +} + +Expression *TypeReference::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeReference::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + + // References just forward things along + return next->dotExp(sc, e, ident); +} + +Expression *TypeReference::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeReference::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypeReference::isZeroInit(Loc loc) +{ + return 1; +} + + +/***************************** TypeFunction *****************************/ + +TypeFunction::TypeFunction(Parameters *parameters, Type *treturn, int varargs, enum LINK linkage, StorageClass stc) + : TypeNext(Tfunction, treturn) +{ +//if (!treturn) *(char*)0=0; +// assert(treturn); + assert(0 <= varargs && varargs <= 2); + this->parameters = parameters; + this->varargs = varargs; + this->linkage = linkage; + this->inuse = 0; + this->isnothrow = false; + this->purity = PUREimpure; + this->isproperty = false; + this->isref = false; + this->fargs = NULL; + + if (stc & STCpure) + this->purity = PUREfwdref; + if (stc & STCnothrow) + this->isnothrow = true; + if (stc & STCproperty) + this->isproperty = true; + + if (stc & STCref) + this->isref = true; + + this->trust = TRUSTdefault; + if (stc & STCsafe) + this->trust = TRUSTsafe; + if (stc & STCsystem) + this->trust = TRUSTsystem; + if (stc & STCtrusted) + this->trust = TRUSTtrusted; +} + +Type *TypeFunction::syntaxCopy() +{ + Type *treturn = next ? next->syntaxCopy() : NULL; + Parameters *params = Parameter::arraySyntaxCopy(parameters); + TypeFunction *t = new TypeFunction(params, treturn, varargs, linkage); + t->mod = mod; + t->isnothrow = isnothrow; + t->purity = purity; + t->isproperty = isproperty; + t->isref = isref; + t->trust = trust; + t->fargs = fargs; + return t; +} + +/******************************* + * Covariant means that 'this' can substitute for 't', + * i.e. a pure function is a match for an impure type. + * Returns: + * 0 types are distinct + * 1 this is covariant with t + * 2 arguments match as far as overloading goes, + * but types are not covariant + * 3 cannot determine covariance because of forward references + */ + +int Type::covariant(Type *t) +{ +#if 0 + printf("Type::covariant(t = %s) %s\n", t->toChars(), toChars()); + printf("deco = %p, %p\n", deco, t->deco); +// printf("ty = %d\n", next->ty); + printf("mod = %x, %x\n", mod, t->mod); +#endif + + int inoutmismatch = 0; + + TypeFunction *t1; + TypeFunction *t2; + + if (equals(t)) + return 1; // covariant + + if (ty != Tfunction || t->ty != Tfunction) + goto Ldistinct; + + t1 = (TypeFunction *)this; + t2 = (TypeFunction *)t; + + if (t1->varargs != t2->varargs) + goto Ldistinct; + + if (t1->parameters && t2->parameters) + { + size_t dim = Parameter::dim(t1->parameters); + if (dim != Parameter::dim(t2->parameters)) + goto Ldistinct; + + for (size_t i = 0; i < dim; i++) + { Parameter *arg1 = Parameter::getNth(t1->parameters, i); + Parameter *arg2 = Parameter::getNth(t2->parameters, i); + + if (!arg1->type->equals(arg2->type)) + { +#if 0 // turn on this for contravariant argument types, see bugzilla 3075 + // BUG: cannot convert ref to const to ref to immutable + // We can add const, but not subtract it + if (arg2->type->implicitConvTo(arg1->type) < MATCHconst) +#endif + goto Ldistinct; + } + const StorageClass sc = STCref | STCin | STCout | STClazy; + if ((arg1->storageClass & sc) != (arg2->storageClass & sc)) + inoutmismatch = 1; + // We can add scope, but not subtract it + if (!(arg1->storageClass & STCscope) && (arg2->storageClass & STCscope)) + inoutmismatch = 1; + } + } + else if (t1->parameters != t2->parameters) + { + size_t dim1 = !t1->parameters ? 0 : t1->parameters->dim; + size_t dim2 = !t2->parameters ? 0 : t2->parameters->dim; + if (dim1 || dim2) + goto Ldistinct; + } + + // The argument lists match + if (inoutmismatch) + goto Lnotcovariant; + if (t1->linkage != t2->linkage) + goto Lnotcovariant; + + { + // Return types + Type *t1n = t1->next; + Type *t2n = t2->next; + + if (!t1n || !t2n) // happens with return type inference + goto Lnotcovariant; + + if (t1n->equals(t2n)) + goto Lcovariant; + if (t1n->ty == Tclass && t2n->ty == Tclass) + { + /* If same class type, but t2n is const, then it's + * covariant. Do this test first because it can work on + * forward references. + */ + if (((TypeClass *)t1n)->sym == ((TypeClass *)t2n)->sym && + MODimplicitConv(t1n->mod, t2n->mod)) + goto Lcovariant; + + // If t1n is forward referenced: + ClassDeclaration *cd = ((TypeClass *)t1n)->sym; +// if (cd->scope) +// cd->semantic(NULL); +#if 0 + if (!cd->baseClass && cd->baseclasses->dim && !cd->isInterfaceDeclaration()) +#else + if (!cd->isBaseInfoComplete()) +#endif + { + return 3; // forward references + } + } + if (t1n->ty == Tstruct && t2n->ty == Tstruct) + { + if (((TypeStruct *)t1n)->sym == ((TypeStruct *)t2n)->sym && + MODimplicitConv(t1n->mod, t2n->mod)) + goto Lcovariant; + } + else if (t1n->ty == t2n->ty && t1n->implicitConvTo(t2n)) + goto Lcovariant; + } + goto Lnotcovariant; + +Lcovariant: + /* Can convert mutable to const + */ + if (!MODimplicitConv(t2->mod, t1->mod)) + goto Lnotcovariant; +#if 0 + if (t1->mod != t2->mod) + { + if (!(t1->mod & MODconst) && (t2->mod & MODconst)) + goto Lnotcovariant; + if (!(t1->mod & MODshared) && (t2->mod & MODshared)) + goto Lnotcovariant; + } +#endif + + /* Can convert pure to impure, and nothrow to throw + */ + if (!t1->purity && t2->purity) + goto Lnotcovariant; + + if (!t1->isnothrow && t2->isnothrow) + goto Lnotcovariant; + + if (t1->isref != t2->isref) + goto Lnotcovariant; + + /* Can convert safe/trusted to system + */ + if (t1->trust <= TRUSTsystem && t2->trust >= TRUSTtrusted) + goto Lnotcovariant; + + //printf("\tcovaraint: 1\n"); + return 1; + +Ldistinct: + //printf("\tcovaraint: 0\n"); + return 0; + +Lnotcovariant: + //printf("\tcovaraint: 2\n"); + return 2; +} + +void TypeFunction::toDecoBuffer(OutBuffer *buf, int flag) +{ unsigned char mc; + + //printf("TypeFunction::toDecoBuffer() this = %p %s\n", this, toChars()); + //static int nest; if (++nest == 50) *(char*)0=0; + if (inuse) + { inuse = 2; // flag error to caller + return; + } + inuse++; + MODtoDecoBuffer(buf, mod); + switch (linkage) + { + case LINKd: mc = 'F'; break; + case LINKc: mc = 'U'; break; + case LINKwindows: mc = 'W'; break; + case LINKpascal: mc = 'V'; break; + case LINKcpp: mc = 'R'; break; + default: + assert(0); + } + buf->writeByte(mc); + if (purity || isnothrow || isproperty || isref || trust) + { + if (purity) + buf->writestring("Na"); + if (isnothrow) + buf->writestring("Nb"); + if (isref) + buf->writestring("Nc"); + if (isproperty) + buf->writestring("Nd"); + switch (trust) + { + case TRUSTtrusted: + buf->writestring("Ne"); + break; + case TRUSTsafe: + buf->writestring("Nf"); + break; + } + } + // Write argument types + Parameter::argsToDecoBuffer(buf, parameters); + //if (buf->data[buf->offset - 1] == '@') halt(); + buf->writeByte('Z' - varargs); // mark end of arg list + assert(next); + next->toDecoBuffer(buf); + inuse--; +} + +void TypeFunction::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs) +{ + toCBufferWithAttributes(buf, ident, hgs, this, NULL); +} + +void TypeFunction::toCBufferWithAttributes(OutBuffer *buf, Identifier *ident, HdrGenState* hgs, TypeFunction *attrs, TemplateDeclaration *td) +{ + //printf("TypeFunction::toCBuffer() this = %p\n", this); + if (inuse) + { inuse = 2; // flag error to caller + return; + } + inuse++; + + /* Use 'storage class' style for attributes + */ + if (attrs->mod) + { + MODtoBuffer(buf, attrs->mod); + buf->writeByte(' '); + } + + if (attrs->purity) + buf->writestring("pure "); + if (attrs->isnothrow) + buf->writestring("nothrow "); + if (attrs->isproperty) + buf->writestring("@property "); + if (attrs->isref) + buf->writestring("ref "); + + switch (attrs->trust) + { + case TRUSTsystem: + buf->writestring("@system "); + break; + + case TRUSTtrusted: + buf->writestring("@trusted "); + break; + + case TRUSTsafe: + buf->writestring("@safe "); + break; + } + + if (hgs->ddoc != 1) + { + const char *p = NULL; + switch (attrs->linkage) + { + case LINKd: p = NULL; break; + case LINKc: p = "C"; break; + case LINKwindows: p = "Windows"; break; + case LINKpascal: p = "Pascal"; break; + case LINKcpp: p = "C++"; break; + default: + assert(0); + } + if (!hgs->hdrgen && p) + { + buf->writestring("extern ("); + buf->writestring(p); + buf->writestring(") "); + } + } + + if (!ident || ident->toHChars2() == ident->toChars()) + { if (next) + next->toCBuffer2(buf, hgs, 0); + else if (hgs->ddoc) + buf->writestring("auto"); + } + + if (ident) + { + if (next || hgs->ddoc) + buf->writeByte(' '); + buf->writestring(ident->toHChars2()); + } + + if (td) + { buf->writeByte('('); + for (size_t i = 0; i < td->origParameters->dim; i++) + { + TemplateParameter *tp = td->origParameters->tdata()[i]; + if (i) + buf->writestring(", "); + tp->toCBuffer(buf, hgs); + } + buf->writeByte(')'); + } + Parameter::argsToCBuffer(buf, hgs, parameters, varargs); + inuse--; +} + +void TypeFunction::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + //printf("TypeFunction::toCBuffer2() this = %p, ref = %d\n", this, isref); + if (inuse) + { inuse = 2; // flag error to caller + return; + } + inuse++; + if (hgs->ddoc != 1) + { + const char *p = NULL; + switch (linkage) + { + case LINKd: p = NULL; break; + case LINKc: p = "C"; break; + case LINKwindows: p = "Windows"; break; + case LINKpascal: p = "Pascal"; break; + case LINKcpp: p = "C++"; break; + default: + assert(0); + } + if (!hgs->hdrgen && p) + { + buf->writestring("extern ("); + buf->writestring(p); + buf->writestring(") "); + } + } + if (next) + { + next->toCBuffer2(buf, hgs, 0); + buf->writeByte(' '); + } + buf->writestring("function"); + Parameter::argsToCBuffer(buf, hgs, parameters, varargs); + attributesToCBuffer(buf, mod); + inuse--; +} + +void TypeFunction::attributesToCBuffer(OutBuffer *buf, int mod) +{ + /* Use postfix style for attributes + */ + if (mod != this->mod) + { + modToBuffer(buf); + } + if (purity) + buf->writestring(" pure"); + if (isnothrow) + buf->writestring(" nothrow"); + if (isproperty) + buf->writestring(" @property"); + if (isref) + buf->writestring(" ref"); + + switch (trust) + { + case TRUSTsystem: + buf->writestring(" @system"); + break; + + case TRUSTtrusted: + buf->writestring(" @trusted"); + break; + + case TRUSTsafe: + buf->writestring(" @safe"); + break; + } +} + +Type *TypeFunction::semantic(Loc loc, Scope *sc) +{ + if (deco) // if semantic() already run + { + //printf("already done\n"); + return this; + } + //printf("TypeFunction::semantic() this = %p\n", this); + //printf("TypeFunction::semantic() %s, sc->stc = %llx, fargs = %p\n", toChars(), sc->stc, fargs); + + /* Copy in order to not mess up original. + * This can produce redundant copies if inferring return type, + * as semantic() will get called again on this. + */ + TypeFunction *tf = (TypeFunction *)mem.malloc(sizeof(TypeFunction)); + memcpy(tf, this, sizeof(TypeFunction)); + if (parameters) + { tf->parameters = (Parameters *)parameters->copy(); + for (size_t i = 0; i < parameters->dim; i++) + { Parameter *arg = parameters->tdata()[i]; + Parameter *cpy = (Parameter *)mem.malloc(sizeof(Parameter)); + memcpy(cpy, arg, sizeof(Parameter)); + tf->parameters->tdata()[i] = cpy; + } + } + + if (sc->stc & STCpure) + tf->purity = PUREfwdref; + if (sc->stc & STCnothrow) + tf->isnothrow = TRUE; + if (sc->stc & STCref) + tf->isref = TRUE; + if (sc->stc & STCsafe) + tf->trust = TRUSTsafe; + if (sc->stc & STCtrusted) + tf->trust = TRUSTtrusted; + if (sc->stc & STCproperty) + tf->isproperty = TRUE; + + tf->linkage = sc->linkage; + + /* If the parent is @safe, then this function defaults to safe + * too. + */ + if (tf->trust == TRUSTdefault) + for (Dsymbol *p = sc->func; p; p = p->toParent2()) + { FuncDeclaration *fd = p->isFuncDeclaration(); + if (fd) + { + if (fd->isSafe()) + tf->trust = TRUSTsafe; // default to @safe + break; + } + } + + bool wildreturn = FALSE; + if (tf->next) + { + sc = sc->push(); + sc->stc &= ~(STC_TYPECTOR | STC_FUNCATTR); + tf->next = tf->next->semantic(loc,sc); + sc = sc->pop(); +#if !SARRAYVALUE + if (tf->next->toBasetype()->ty == Tsarray) + { error(loc, "functions cannot return static array %s", tf->next->toChars()); + tf->next = Type::terror; + } +#endif + if (tf->next->toBasetype()->ty == Tfunction) + { error(loc, "functions cannot return a function"); + tf->next = Type::terror; + } + if (tf->next->toBasetype()->ty == Ttuple) + { error(loc, "functions cannot return a tuple"); + tf->next = Type::terror; + } + if (tf->next->isscope() && !(sc->flags & SCOPEctor)) + error(loc, "functions cannot return scope %s", tf->next->toChars()); + if (tf->next->toBasetype()->ty == Tvoid) + tf->isref = FALSE; // rewrite "ref void" as just "void" + if (tf->next->hasWild() && + !(tf->next->ty == Tpointer && tf->next->nextOf()->ty == Tfunction || tf->next->ty == Tdelegate)) + wildreturn = TRUE; + } + + bool wildparams = FALSE; + bool wildsubparams = FALSE; + if (tf->parameters) + { + /* Create a scope for evaluating the default arguments for the parameters + */ + Scope *argsc = sc->push(); + argsc->stc = 0; // don't inherit storage class + argsc->protection = PROTpublic; + argsc->func = NULL; + + size_t dim = Parameter::dim(tf->parameters); + for (size_t i = 0; i < dim; i++) + { Parameter *fparam = Parameter::getNth(tf->parameters, i); + + tf->inuse++; + fparam->type = fparam->type->semantic(loc, argsc); + if (tf->inuse == 1) tf->inuse--; + + fparam->type = fparam->type->addStorageClass(fparam->storageClass); + + if (fparam->storageClass & (STCauto | STCalias | STCstatic)) + { + if (!fparam->type) + continue; + } + + Type *t = fparam->type->toBasetype(); + + if (fparam->storageClass & (STCout | STCref | STClazy)) + { + //if (t->ty == Tsarray) + //error(loc, "cannot have out or ref parameter of type %s", t->toChars()); + if (fparam->storageClass & STCout && fparam->type->mod & (STCconst | STCimmutable)) + error(loc, "cannot have const or immutable out parameter of type %s", t->toChars()); + } + if (!(fparam->storageClass & STClazy) && t->ty == Tvoid) + error(loc, "cannot have parameter of type %s", fparam->type->toChars()); + + if (t->hasWild() && + !(t->ty == Tpointer && t->nextOf()->ty == Tfunction || t->ty == Tdelegate)) + { + wildparams = TRUE; + if (tf->next && !wildreturn) + error(loc, "inout on parameter means inout must be on return type as well (if from D1 code, replace with 'ref')"); + } + else if (!wildsubparams && t->hasWild()) + wildsubparams = TRUE; + + if (fparam->defaultArg) + { + fparam->defaultArg = fparam->defaultArg->semantic(argsc); + fparam->defaultArg = resolveProperties(argsc, fparam->defaultArg); + fparam->defaultArg = fparam->defaultArg->implicitCastTo(argsc, fparam->type); + } + + /* If fparam after semantic() turns out to be a tuple, the number of parameters may + * change. + */ + if (t->ty == Ttuple) + { + TypeTuple *tt = (TypeTuple *)t; + if (fparam->storageClass && tt->arguments && tt->arguments->dim) + { + /* Propagate additional storage class from tuple parameters to their + * element-parameters. + * Make a copy, as original may be referenced elsewhere. + */ + size_t tdim = tt->arguments->dim; + Parameters *newparams = new Parameters(); + newparams->setDim(tdim); + for (size_t j = 0; j < tdim; j++) + { Parameter *narg = (*tt->arguments)[j]; + newparams->tdata()[j] = new Parameter(narg->storageClass | fparam->storageClass, + narg->type, narg->ident, narg->defaultArg); + } + fparam->type = new TypeTuple(newparams); + } + fparam->storageClass = 0; + + /* Reset number of parameters, and back up one to do this fparam again, + * now that it is a tuple + */ + dim = Parameter::dim(tf->parameters); + i--; + continue; + } + + /* Resolve "auto ref" storage class to be either ref or value, + * based on the argument matching the parameter + */ + if (fparam->storageClass & STCauto) + { + if (fargs && i < fargs->dim) + { Expression *farg = fargs->tdata()[i]; + if (farg->isLvalue()) + ; // ref parameter + else + fparam->storageClass &= ~STCref; // value parameter + } + else + error(loc, "auto can only be used for template function parameters"); + } + + // Remove redundant storage classes for type, they are already applied + fparam->storageClass &= ~(STC_TYPECTOR | STCin); + } + argsc->pop(); + } + if (tf->isWild()) + wildparams = TRUE; + + if (wildreturn && !wildparams) + error(loc, "inout on return means inout must be on a parameter as well for %s", toChars()); + if (wildsubparams && wildparams) + error(loc, "inout must be all or none on top level for %s", toChars()); + + if (tf->next) + tf->deco = tf->merge()->deco; + + if (tf->inuse) + { error(loc, "recursive type"); + tf->inuse = 0; + return terror; + } + + if (tf->isproperty && (tf->varargs || Parameter::dim(tf->parameters) > 1)) + error(loc, "properties can only have zero or one parameter"); + + if (tf->varargs == 1 && tf->linkage != LINKd && Parameter::dim(tf->parameters) == 0) + error(loc, "variadic functions with non-D linkage must have at least one parameter"); + + /* Don't return merge(), because arg identifiers and default args + * can be different + * even though the types match + */ + return tf; +} + + +/******************************************** + * Do this lazily, as the parameter types might be forward referenced. + */ +void TypeFunction::purityLevel() +{ + TypeFunction *tf = this; + if (tf->purity == PUREfwdref) + { /* Evaluate what kind of purity based on the modifiers for the parameters + */ + tf->purity = PUREstrong; // assume strong until something weakens it + if (tf->parameters) + { + size_t dim = Parameter::dim(tf->parameters); + for (size_t i = 0; i < dim; i++) + { Parameter *fparam = Parameter::getNth(tf->parameters, i); + if (fparam->storageClass & STClazy) + { + tf->purity = PUREweak; + break; + } + if (fparam->storageClass & STCout) + { + tf->purity = PUREweak; + break; + } + if (!fparam->type) + continue; + if (fparam->storageClass & STCref) + { + if (!(fparam->type->mod & (MODconst | MODimmutable | MODwild))) + { tf->purity = PUREweak; + break; + } + if (fparam->type->mod & MODconst) + { tf->purity = PUREconst; + continue; + } + } + Type *t = fparam->type->toBasetype(); + if (!t->hasPointers()) + continue; + if (t->mod & (MODimmutable | MODwild)) + continue; + /* The rest of this is too strict; fix later. + * For example, the only pointer members of a struct may be immutable, + * which would maintain strong purity. + */ + if (t->mod & MODconst) + { tf->purity = PUREconst; + continue; + } + Type *tn = t->nextOf(); + if (tn) + { tn = tn->toBasetype(); + if (tn->ty == Tpointer || tn->ty == Tarray) + { /* Accept immutable(T)* and immutable(T)[] as being strongly pure + */ + if (tn->mod & (MODimmutable | MODwild)) + continue; + if (tn->mod & MODconst) + { tf->purity = PUREconst; + continue; + } + } + } + /* Should catch delegates and function pointers, and fold in their purity + */ + tf->purity = PUREweak; // err on the side of too strict + break; + } + } + } +} + + +/******************************** + * 'args' are being matched to function 'this' + * Determine match level. + * Input: + * flag 1 performing a partial ordering match + * Returns: + * MATCHxxxx + */ + +int TypeFunction::callMatch(Expression *ethis, Expressions *args, int flag) +{ + //printf("TypeFunction::callMatch() %s\n", toChars()); + MATCH match = MATCHexact; // assume exact match + unsigned wildmatch = 0; + + if (ethis) + { Type *t = ethis->type; + if (t->toBasetype()->ty == Tpointer) + t = t->toBasetype()->nextOf(); // change struct* to struct + if (t->mod != mod) + { + if (MODimplicitConv(t->mod, mod)) + match = MATCHconst; + else if ((mod & MODwild) + && MODimplicitConv(t->mod, (mod & ~MODwild) | MODconst)) + { + match = MATCHconst; + } + else + return MATCHnomatch; + } + if (isWild()) + { + if (t->isWild()) + wildmatch |= MODwild; + else if (t->isConst()) + wildmatch |= MODconst; + else if (t->isImmutable()) + wildmatch |= MODimmutable; + else + wildmatch |= MODmutable; + } + } + + size_t nparams = Parameter::dim(parameters); + size_t nargs = args ? args->dim : 0; + if (nparams == nargs) + ; + else if (nargs > nparams) + { + if (varargs == 0) + goto Nomatch; // too many args; no match + match = MATCHconvert; // match ... with a "conversion" match level + } + + for (size_t u = 0; u < nargs; u++) + { + if (u >= nparams) + break; + Parameter *p = Parameter::getNth(parameters, u); + Expression *arg = args->tdata()[u]; + assert(arg); + + if (!(p->storageClass & STClazy && p->type->ty == Tvoid && arg->type->ty != Tvoid)) + { + unsigned mod = arg->type->wildConvTo(p->type); + if (mod) + { + wildmatch |= mod; + } + } + } + if (wildmatch) + { /* Calculate wild matching modifier + */ + if (wildmatch & MODconst || wildmatch & (wildmatch - 1)) + wildmatch = MODconst; + else if (wildmatch & MODimmutable) + wildmatch = MODimmutable; + else if (wildmatch & MODwild) + wildmatch = MODwild; + else + { assert(wildmatch & MODmutable); + wildmatch = MODmutable; + } + } + + for (size_t u = 0; u < nparams; u++) + { MATCH m; + + // BUG: what about out and ref? + + Parameter *p = Parameter::getNth(parameters, u); + assert(p); + if (u >= nargs) + { + if (p->defaultArg) + continue; + goto L1; // try typesafe variadics + } + { + Expression *arg = args->tdata()[u]; + assert(arg); + + if (arg->op == TOKfunction) + { FuncExp *fe = (FuncExp *)arg; + Type *pt = p->type; + arg = ((FuncExp *)arg)->inferType(NULL, pt); + if (!arg) + goto L1; // try typesafe variadics + } + + //printf("arg: %s, type: %s\n", arg->toChars(), arg->type->toChars()); + + Type *targ = arg->type; + Type *tprm = wildmatch ? p->type->substWildTo(wildmatch) : p->type; + + // Non-lvalues do not match ref or out parameters + if (p->storageClass & STCref) + { if (!arg->isLvalue()) + { if (arg->op == TOKstring && tprm->ty == Tsarray) + { if (targ->ty != Tsarray) + targ = new TypeSArray(targ->nextOf(), + new IntegerExp(0, ((StringExp *)arg)->len, + Type::tindex)); + } + else + goto Nomatch; + } + + /* Don't allow static arrays to be passed to mutable references + * to static arrays if the argument cannot be modified. + */ + Type *targb = targ->toBasetype(); + Type *tprmb = tprm->toBasetype(); + //printf("%s\n", targb->toChars()); + //printf("%s\n", tprmb->toChars()); + if (targb->nextOf() && tprmb->ty == Tsarray && + !MODimplicitConv(targb->nextOf()->mod, tprmb->nextOf()->mod)) + goto Nomatch; + + // ref variable behaves like head-const reference + if (!targb->constConv(tprmb)) + goto Nomatch; + } + else if (p->storageClass & STCout) + { if (!arg->isLvalue()) + goto Nomatch; + } + + if (p->storageClass & STClazy && tprm->ty == Tvoid && targ->ty != Tvoid) + m = MATCHconvert; + else + { + //printf("%s of type %s implicitConvTo %s\n", arg->toChars(), targ->toChars(), tprm->toChars()); + if (flag) + // for partial ordering, value is an irrelevant mockup, just look at the type + m = targ->implicitConvTo(tprm); + else + m = arg->implicitConvTo(tprm); + //printf("match %d\n", m); + } + } + + /* prefer matching the element type rather than the array + * type when more arguments are present with T[]... + */ + if (varargs == 2 && u + 1 == nparams && nargs > nparams) + goto L1; + + //printf("\tm = %d\n", m); + if (m == MATCHnomatch) // if no match + { + L1: + if (varargs == 2 && u + 1 == nparams) // if last varargs param + { Type *tb = p->type->toBasetype(); + TypeSArray *tsa; + dinteger_t sz; + + switch (tb->ty) + { + case Tsarray: + tsa = (TypeSArray *)tb; + sz = tsa->dim->toInteger(); + if (sz != nargs - u) + goto Nomatch; + case Tarray: + { TypeArray *ta = (TypeArray *)tb; + for (; u < nargs; u++) + { + Expression *arg = args->tdata()[u]; + assert(arg); +#if 1 + if (arg->op == TOKfunction) + { FuncExp *fe = (FuncExp *)arg; + Type *pt = tb->nextOf(); + arg = ((FuncExp *)arg)->inferType(NULL, pt); + if (!arg) + goto Nomatch; + } + + /* If lazy array of delegates, + * convert arg(s) to delegate(s) + */ + Type *tret = p->isLazyArray(); + if (tret) + { + if (ta->next->equals(arg->type)) + { m = MATCHexact; + } + else + { + m = arg->implicitConvTo(tret); + if (m == MATCHnomatch) + { + if (tret->toBasetype()->ty == Tvoid) + m = MATCHconvert; + } + } + } + else + m = arg->implicitConvTo(ta->next); +#else + m = arg->implicitConvTo(ta->next); +#endif + if (m == MATCHnomatch) + goto Nomatch; + if (m < match) + match = m; + } + goto Ldone; + } + case Tclass: + // Should see if there's a constructor match? + // Or just leave it ambiguous? + goto Ldone; + + default: + goto Nomatch; + } + } + goto Nomatch; + } + if (m < match) + match = m; // pick worst match + } + +Ldone: + //printf("match = %d\n", match); + return match; + +Nomatch: + //printf("no match\n"); + return MATCHnomatch; +} + +Type *TypeFunction::reliesOnTident() +{ + size_t dim = Parameter::dim(parameters); + for (size_t i = 0; i < dim; i++) + { Parameter *fparam = Parameter::getNth(parameters, i); + Type *t = fparam->type->reliesOnTident(); + if (t) + return t; + } + return next ? next->reliesOnTident() : NULL; +} + +/******************************************** + * Return TRUE if there are lazy parameters. + */ +bool TypeFunction::hasLazyParameters() +{ + size_t dim = Parameter::dim(parameters); + for (size_t i = 0; i < dim; i++) + { Parameter *fparam = Parameter::getNth(parameters, i); + if (fparam->storageClass & STClazy) + return TRUE; + } + return FALSE; +} + +/*************************** + * Examine function signature for parameter p and see if + * p can 'escape' the scope of the function. + */ + +bool TypeFunction::parameterEscapes(Parameter *p) +{ + + /* Scope parameters do not escape. + * Allow 'lazy' to imply 'scope' - + * lazy parameters can be passed along + * as lazy parameters to the next function, but that isn't + * escaping. + */ + if (p->storageClass & (STCscope | STClazy)) + return FALSE; + + if (purity) + { /* With pure functions, we need only be concerned if p escapes + * via any return statement. + */ + Type* tret = nextOf()->toBasetype(); + if (!isref && !tret->hasPointers()) + { /* The result has no references, so p could not be escaping + * that way. + */ + return FALSE; + } + } + + /* Assume it escapes in the absence of better information. + */ + return TRUE; +} + +Expression *TypeFunction::defaultInit(Loc loc) +{ + error(loc, "function does not have a default initializer"); + return new ErrorExp(); +} + +/***************************** TypeDelegate *****************************/ + +TypeDelegate::TypeDelegate(Type *t) + : TypeNext(Tfunction, t) +{ + ty = Tdelegate; +} + +Type *TypeDelegate::syntaxCopy() +{ + Type *t = next->syntaxCopy(); + if (t == next) + t = this; + else + { t = new TypeDelegate(t); + t->mod = mod; + } + return t; +} + +Type *TypeDelegate::semantic(Loc loc, Scope *sc) +{ + if (deco) // if semantic() already run + { + //printf("already done\n"); + return this; + } + next = next->semantic(loc,sc); + /* In order to deal with Bugzilla 4028, perhaps default arguments should + * be removed from next before the merge. + */ + + /* Don't return merge(), because arg identifiers and default args + * can be different + * even though the types match + */ + //deco = merge()->deco; + //return this; + return merge(); +} + +d_uns64 TypeDelegate::size(Loc loc) +{ + return PTRSIZE * 2; +} + +unsigned TypeDelegate::alignsize() +{ +#if DMDV1 + // See Bugzilla 942 for discussion + if (!global.params.is64bit) + return PTRSIZE * 2; +#endif + return PTRSIZE; +} + +MATCH TypeDelegate::implicitConvTo(Type *to) +{ + //printf("TypeDelegate::implicitConvTo(this=%p, to=%p)\n", this, to); + //printf("from: %s\n", toChars()); + //printf("to : %s\n", to->toChars()); + if (this == to) + return MATCHexact; +#if 1 // not allowing covariant conversions because it interferes with overriding + if (to->ty == Tdelegate && this->nextOf()->covariant(to->nextOf()) == 1) + return MATCHconvert; +#endif + return MATCHnomatch; +} + +void TypeDelegate::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + TypeFunction *tf = (TypeFunction *)next; + + tf->next->toCBuffer2(buf, hgs, 0); + buf->writestring(" delegate"); + Parameter::argsToCBuffer(buf, hgs, tf->parameters, tf->varargs); + tf->attributesToCBuffer(buf, mod); +} + +Expression *TypeDelegate::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeDelegate::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypeDelegate::isZeroInit(Loc loc) +{ + return 1; +} + +int TypeDelegate::checkBoolean() +{ + return TRUE; +} + +Expression *TypeDelegate::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeDelegate::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (ident == Id::ptr) + { + e->type = tvoidptr; + return e; + } + else if (ident == Id::funcptr) + { + e = e->addressOf(sc); + e->type = tvoidptr; + e = new AddExp(e->loc, e, new IntegerExp(PTRSIZE)); + e->type = tvoidptr; + e = new PtrExp(e->loc, e); + e->type = next->pointerTo(); + return e; + } + else + { + e = Type::dotExp(sc, e, ident); + } + return e; +} + +int TypeDelegate::hasPointers() +{ + return TRUE; +} + + + +/***************************** TypeQualified *****************************/ + +TypeQualified::TypeQualified(TY ty, Loc loc) + : Type(ty) +{ + this->loc = loc; +} + +void TypeQualified::syntaxCopyHelper(TypeQualified *t) +{ + //printf("TypeQualified::syntaxCopyHelper(%s) %s\n", t->toChars(), toChars()); + idents.setDim(t->idents.dim); + for (size_t i = 0; i < idents.dim; i++) + { + Identifier *id = t->idents.tdata()[i]; + if (id->dyncast() == DYNCAST_DSYMBOL) + { + TemplateInstance *ti = (TemplateInstance *)id; + + ti = (TemplateInstance *)ti->syntaxCopy(NULL); + id = (Identifier *)ti; + } + idents.tdata()[i] = id; + } +} + + +void TypeQualified::addIdent(Identifier *ident) +{ + idents.push(ident); +} + +void TypeQualified::toCBuffer2Helper(OutBuffer *buf, HdrGenState *hgs) +{ + for (size_t i = 0; i < idents.dim; i++) + { Identifier *id = idents.tdata()[i]; + + buf->writeByte('.'); + + if (id->dyncast() == DYNCAST_DSYMBOL) + { + TemplateInstance *ti = (TemplateInstance *)id; + ti->toCBuffer(buf, hgs); + } + else + buf->writestring(id->toChars()); + } +} + +d_uns64 TypeQualified::size(Loc loc) +{ + error(this->loc, "size of type %s is not known", toChars()); + return 1; +} + +/************************************* + * Takes an array of Identifiers and figures out if + * it represents a Type or an Expression. + * Output: + * if expression, *pe is set + * if type, *pt is set + */ + +void TypeQualified::resolveHelper(Loc loc, Scope *sc, + Dsymbol *s, Dsymbol *scopesym, + Expression **pe, Type **pt, Dsymbol **ps) +{ + VarDeclaration *v; + EnumMember *em; + Expression *e; + +#if 0 + printf("TypeQualified::resolveHelper(sc = %p, idents = '%s')\n", sc, toChars()); + if (scopesym) + printf("\tscopesym = '%s'\n", scopesym->toChars()); +#endif + *pe = NULL; + *pt = NULL; + *ps = NULL; + if (s) + { + //printf("\t1: s = '%s' %p, kind = '%s'\n",s->toChars(), s, s->kind()); + s->checkDeprecated(loc, sc); // check for deprecated aliases + s = s->toAlias(); + //printf("\t2: s = '%s' %p, kind = '%s'\n",s->toChars(), s, s->kind()); + for (size_t i = 0; i < idents.dim; i++) + { + Identifier *id = idents.tdata()[i]; + Dsymbol *sm = s->searchX(loc, sc, id); + //printf("\t3: s = '%s' %p, kind = '%s'\n",s->toChars(), s, s->kind()); + //printf("\tgetType = '%s'\n", s->getType()->toChars()); + if (!sm) + { Type *t; + + v = s->isVarDeclaration(); + if (v && id == Id::length) + { + e = v->getConstInitializer(); + if (!e) + e = new VarExp(loc, v); + t = e->type; + if (!t) + goto Lerror; + goto L3; + } + else if (v && (id == Id::stringof || id == Id::offsetof)) + { + e = new DsymbolExp(loc, s, 0); + do + { + id = idents.tdata()[i]; + e = new DotIdExp(loc, e, id); + } while (++i < idents.dim); + e = e->semantic(sc); + *pe = e; + return; + } + + t = s->getType(); + if (!t && s->isDeclaration()) + { t = s->isDeclaration()->type; + if (!t && s->isTupleDeclaration()) + { + e = new TupleExp(loc, s->isTupleDeclaration()); + e = e->semantic(sc); + t = e->type; + } + } + if (t) + { + sm = t->toDsymbol(sc); + if (sm) + { sm = sm->search(loc, id, 0); + if (sm) + goto L2; + } + //e = t->getProperty(loc, id); + e = new TypeExp(loc, t); + e = t->dotExp(sc, e, id); + i++; + L3: + for (; i < idents.dim; i++) + { + id = idents.tdata()[i]; + //printf("e: '%s', id: '%s', type = %s\n", e->toChars(), id->toChars(), e->type->toChars()); + e = new DotIdExp(e->loc, e, id); + e = e->semantic(sc); + } + if (e->op == TOKtype) + *pt = e->type; + else + *pe = e; + } + else + { + Lerror: + error(loc, "identifier '%s' of '%s' is not defined", id->toChars(), toChars()); + *pe = new ErrorExp(); + } + return; + } + L2: + s = sm->toAlias(); + } + + v = s->isVarDeclaration(); + if (v) + { + *pe = new VarExp(loc, v); + return; + } +#if 0 + fd = s->isFuncDeclaration(); + if (fd) + { + *pe = new DsymbolExp(loc, fd, 1); + return; + } +#endif + em = s->isEnumMember(); + if (em) + { + // It's not a type, it's an expression + *pe = em->value->copy(); + return; + } + +L1: + Type *t = s->getType(); + if (!t) + { + // If the symbol is an import, try looking inside the import + Import *si; + + si = s->isImport(); + if (si) + { + s = si->search(loc, s->ident, 0); + if (s && s != si) + goto L1; + s = si; + } + *ps = s; + return; + } + if (t->ty == Tinstance && t != this && !t->deco) + { error(loc, "forward reference to '%s'", t->toChars()); + return; + } + + if (t != this) + { + if (t->reliesOnTident()) + { + if (s->scope) + t = t->semantic(loc, s->scope); + else + { + /* Attempt to find correct scope in which to evaluate t. + * Not sure if this is right or not, or if we should just + * give forward reference error if s->scope is not set. + */ + for (Scope *scx = sc; 1; scx = scx->enclosing) + { + if (!scx) + { error(loc, "forward reference to '%s'", t->toChars()); + return; + } + if (scx->scopesym == scopesym) + { + t = t->semantic(loc, scx); + break; + } + } + } + } + } + if (t->ty == Ttuple) + *pt = t; + else + *pt = t->merge(); + } + if (!s) + { + const char *p = toChars(); + const char *n = importHint(p); + if (n) + error(loc, "'%s' is not defined, perhaps you need to import %s; ?", p, n); + else + { + Identifier *id = new Identifier(p, TOKidentifier); + s = sc->search_correct(id); + if (s) + error(loc, "undefined identifier %s, did you mean %s %s?", p, s->kind(), s->toChars()); + else + error(loc, "undefined identifier %s", p); + } + *pt = Type::terror; + } +} + +/***************************** TypeIdentifier *****************************/ + +TypeIdentifier::TypeIdentifier(Loc loc, Identifier *ident) + : TypeQualified(Tident, loc) +{ + this->ident = ident; +} + + +Type *TypeIdentifier::syntaxCopy() +{ + TypeIdentifier *t; + + t = new TypeIdentifier(loc, ident); + t->syntaxCopyHelper(this); + t->mod = mod; + return t; +} + +void TypeIdentifier::toDecoBuffer(OutBuffer *buf, int flag) +{ unsigned len; + char *name; + + Type::toDecoBuffer(buf, flag); + name = ident->toChars(); + len = strlen(name); + buf->printf("%d%s", len, name); +} + +void TypeIdentifier::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(this->ident->toChars()); + toCBuffer2Helper(buf, hgs); +} + +/************************************* + * Takes an array of Identifiers and figures out if + * it represents a Type or an Expression. + * Output: + * if expression, *pe is set + * if type, *pt is set + */ + +void TypeIdentifier::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + Dsymbol *scopesym; + + //printf("TypeIdentifier::resolve(sc = %p, idents = '%s')\n", sc, toChars()); + + if ((ident->equals(Id::super) || ident->equals(Id::This)) && !hasThis(sc)) + { + AggregateDeclaration *ad = sc->getStructClassScope(); + if (ad) + { + ClassDeclaration *cd = ad->isClassDeclaration(); + if (cd) + { + if (ident->equals(Id::This)) + ident = cd->ident; + else if (cd->baseClass && ident->equals(Id::super)) + ident = cd->baseClass->ident; + } + else + { + StructDeclaration *sd = ad->isStructDeclaration(); + if (sd && ident->equals(Id::This)) + ident = sd->ident; + } + } + } + + Dsymbol *s = sc->search(loc, ident, &scopesym); + resolveHelper(loc, sc, s, scopesym, pe, pt, ps); + if (*pt) + (*pt) = (*pt)->addMod(mod); +} + +/***************************************** + * See if type resolves to a symbol, if so, + * return that symbol. + */ + +Dsymbol *TypeIdentifier::toDsymbol(Scope *sc) +{ + //printf("TypeIdentifier::toDsymbol('%s')\n", toChars()); + if (!sc) + return NULL; + //printf("ident = '%s'\n", ident->toChars()); + + Dsymbol *scopesym; + Dsymbol *s = sc->search(loc, ident, &scopesym); + if (s) + { + for (size_t i = 0; i < idents.dim; i++) + { + Identifier *id = idents.tdata()[i]; + s = s->searchX(loc, sc, id); + if (!s) // failed to find a symbol + { //printf("\tdidn't find a symbol\n"); + break; + } + } + } + return s; +} + +Type *TypeIdentifier::semantic(Loc loc, Scope *sc) +{ + Type *t; + Expression *e; + Dsymbol *s; + + //printf("TypeIdentifier::semantic(%s)\n", toChars()); + resolve(loc, sc, &e, &t, &s); + if (t) + { + //printf("\tit's a type %d, %s, %s\n", t->ty, t->toChars(), t->deco); + + if (t->ty == Ttypedef) + { TypeTypedef *tt = (TypeTypedef *)t; + + if (tt->sym->sem == 1) + error(loc, "circular reference of typedef %s", tt->toChars()); + } + t = t->addMod(mod); + } + else + { +#ifdef DEBUG + if (!global.gag) + printf("1: "); +#endif + if (s) + { + s->error(loc, "is used as a type"); + //halt(); + } + else + error(loc, "%s is used as a type", toChars()); + t = terror; + } + //t->print(); + return t; +} + +Type *TypeIdentifier::reliesOnTident() +{ + return this; +} + +Expression *TypeIdentifier::toExpression() +{ + Expression *e = new IdentifierExp(loc, ident); + for (size_t i = 0; i < idents.dim; i++) + { + Identifier *id = idents.tdata()[i]; + e = new DotIdExp(loc, e, id); + } + + return e; +} + +/***************************** TypeInstance *****************************/ + +TypeInstance::TypeInstance(Loc loc, TemplateInstance *tempinst) + : TypeQualified(Tinstance, loc) +{ + this->tempinst = tempinst; +} + +Type *TypeInstance::syntaxCopy() +{ + //printf("TypeInstance::syntaxCopy() %s, %d\n", toChars(), idents.dim); + TypeInstance *t; + + t = new TypeInstance(loc, (TemplateInstance *)tempinst->syntaxCopy(NULL)); + t->syntaxCopyHelper(this); + t->mod = mod; + return t; +} + + +void TypeInstance::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + tempinst->toCBuffer(buf, hgs); + toCBuffer2Helper(buf, hgs); +} + +void TypeInstance::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + // Note close similarity to TypeIdentifier::resolve() + + Dsymbol *s; + + *pe = NULL; + *pt = NULL; + *ps = NULL; + +#if 0 + if (!idents.dim) + { + error(loc, "template instance '%s' has no identifier", toChars()); + return; + } +#endif + //id = (Identifier *)idents.data[0]; + //printf("TypeInstance::resolve(sc = %p, idents = '%s')\n", sc, id->toChars()); + s = tempinst; + if (s) + { //printf("s = %s\n", s->toChars()); + s->semantic(sc); + } + resolveHelper(loc, sc, s, NULL, pe, pt, ps); + if (*pt) + *pt = (*pt)->addMod(mod); + //printf("pt = '%s'\n", (*pt)->toChars()); +} + +Type *TypeInstance::semantic(Loc loc, Scope *sc) +{ + Type *t; + Expression *e; + Dsymbol *s; + + //printf("TypeInstance::semantic(%s)\n", toChars()); + + if (sc->parameterSpecialization) + { + unsigned errors = global.startGagging(); + + resolve(loc, sc, &e, &t, &s); + + if (global.endGagging(errors)) + { + return this; + } + } + else + resolve(loc, sc, &e, &t, &s); + + if (!t) + { + error(loc, "%s is used as a type", toChars()); + t = terror; + } + return t; +} + +Dsymbol *TypeInstance::toDsymbol(Scope *sc) +{ + Type *t; + Expression *e; + Dsymbol *s; + + //printf("TypeInstance::semantic(%s)\n", toChars()); + + if (sc->parameterSpecialization) + { + unsigned errors = global.startGagging(); + + resolve(loc, sc, &e, &t, &s); + + if (global.endGagging(errors)) + return NULL; + } + else + resolve(loc, sc, &e, &t, &s); + + return s; +} + + +/***************************** TypeTypeof *****************************/ + +TypeTypeof::TypeTypeof(Loc loc, Expression *exp) + : TypeQualified(Ttypeof, loc) +{ + this->exp = exp; + inuse = 0; +} + +Type *TypeTypeof::syntaxCopy() +{ + //printf("TypeTypeof::syntaxCopy() %s\n", toChars()); + TypeTypeof *t; + + t = new TypeTypeof(loc, exp->syntaxCopy()); + t->syntaxCopyHelper(this); + t->mod = mod; + return t; +} + +Dsymbol *TypeTypeof::toDsymbol(Scope *sc) +{ + Type *t; + + t = semantic(loc, sc); + if (t == this) + return NULL; + return t->toDsymbol(sc); +} + +void TypeTypeof::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring("typeof("); + exp->toCBuffer(buf, hgs); + buf->writeByte(')'); + toCBuffer2Helper(buf, hgs); +} + +Type *TypeTypeof::semantic(Loc loc, Scope *sc) +{ + Type *t; + + //printf("TypeTypeof::semantic() %s\n", toChars()); + + //static int nest; if (++nest == 50) *(char*)0=0; + if (inuse) + { + inuse = 2; + error(loc, "circular typeof definition"); + return Type::terror; + } + inuse++; + +#if 0 + /* Special case for typeof(this) and typeof(super) since both + * should work even if they are not inside a non-static member function + */ + if (exp->op == TOKthis || exp->op == TOKsuper) + { + // Find enclosing struct or class + for (Dsymbol *s = sc->parent; 1; s = s->parent) + { + ClassDeclaration *cd; + StructDeclaration *sd; + + if (!s) + { + error(loc, "%s is not in a struct or class scope", exp->toChars()); + goto Lerr; + } + cd = s->isClassDeclaration(); + if (cd) + { + if (exp->op == TOKsuper) + { + cd = cd->baseClass; + if (!cd) + { error(loc, "class %s has no 'super'", s->toChars()); + goto Lerr; + } + } + t = cd->type; + break; + } + sd = s->isStructDeclaration(); + if (sd) + { + if (exp->op == TOKsuper) + { + error(loc, "struct %s has no 'super'", sd->toChars()); + goto Lerr; + } + t = sd->type->pointerTo(); + break; + } + } + } + else +#endif + { + Scope *sc2 = sc->push(); + sc2->intypeof++; + sc2->flags |= sc->flags & SCOPEstaticif; + exp = exp->semantic(sc2); +#if DMDV2 + if (exp->type && exp->type->ty == Tfunction && + ((TypeFunction *)exp->type)->isproperty) + exp = resolveProperties(sc2, exp); +#endif + sc2->pop(); + if (exp->op == TOKtype) + { + error(loc, "argument %s to typeof is not an expression", exp->toChars()); + goto Lerr; + } + t = exp->type; + if (!t) + { + error(loc, "expression (%s) has no type", exp->toChars()); + goto Lerr; + } + if (t->ty == Ttypeof) + { error(loc, "forward reference to %s", toChars()); + goto Lerr; + } + + t = t->addMod(mod); + + /* typeof should reflect the true type, + * not what 'auto' would have gotten us. + */ + //t = t->toHeadMutable(); + } + if (idents.dim) + { + Dsymbol *s = t->toDsymbol(sc); + for (size_t i = 0; i < idents.dim; i++) + { + if (!s) + break; + Identifier *id = idents.tdata()[i]; + s = s->searchX(loc, sc, id); + } + + if (s) + { + t = s->getType(); + if (!t) + { error(loc, "%s is not a type", s->toChars()); + goto Lerr; + } + } + else + { error(loc, "cannot resolve .property for %s", toChars()); + goto Lerr; + } + } + inuse--; + return t; + +Lerr: + inuse--; + return terror; +} + +d_uns64 TypeTypeof::size(Loc loc) +{ + if (exp->type) + return exp->type->size(loc); + else + return TypeQualified::size(loc); +} + + + +/***************************** TypeReturn *****************************/ + +TypeReturn::TypeReturn(Loc loc) + : TypeQualified(Treturn, loc) +{ +} + +Type *TypeReturn::syntaxCopy() +{ + TypeReturn *t = new TypeReturn(loc); + t->syntaxCopyHelper(this); + t->mod = mod; + return t; +} + +Dsymbol *TypeReturn::toDsymbol(Scope *sc) +{ + Type *t = semantic(0, sc); + if (t == this) + return NULL; + return t->toDsymbol(sc); +} + +Type *TypeReturn::semantic(Loc loc, Scope *sc) +{ + Type *t; + if (!sc->func) + { error(loc, "typeof(return) must be inside function"); + goto Lerr; + } + t = sc->func->type->nextOf(); + if (!t) + { + error(loc, "cannot use typeof(return) inside function %s with inferred return type", sc->func->toChars()); + goto Lerr; + } + t = t->addMod(mod); + + if (idents.dim) + { + Dsymbol *s = t->toDsymbol(sc); + for (size_t i = 0; i < idents.dim; i++) + { + if (!s) + break; + Identifier *id = idents.tdata()[i]; + s = s->searchX(loc, sc, id); + } + if (s) + { + t = s->getType(); + if (!t) + { error(loc, "%s is not a type", s->toChars()); + goto Lerr; + } + } + else + { error(loc, "cannot resolve .property for %s", toChars()); + goto Lerr; + } + } + return t; + +Lerr: + return terror; +} + +void TypeReturn::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring("typeof(return)"); + toCBuffer2Helper(buf, hgs); +} + + +/***************************** TypeEnum *****************************/ + +TypeEnum::TypeEnum(EnumDeclaration *sym) + : Type(Tenum) +{ + this->sym = sym; +} + +char *TypeEnum::toChars() +{ + if (mod) + return Type::toChars(); + return sym->toChars(); +} + +Type *TypeEnum::syntaxCopy() +{ + return this; +} + +Type *TypeEnum::semantic(Loc loc, Scope *sc) +{ + //printf("TypeEnum::semantic() %s\n", toChars()); + //sym->semantic(sc); + return merge(); +} + +d_uns64 TypeEnum::size(Loc loc) +{ + if (!sym->memtype) + { + error(loc, "enum %s is forward referenced", sym->toChars()); + return 4; + } + return sym->memtype->size(loc); +} + +unsigned TypeEnum::alignsize() +{ + if (!sym->memtype) + { +#ifdef DEBUG + printf("1: "); +#endif + error(0, "enum %s is forward referenced", sym->toChars()); + return 4; + } + return sym->memtype->alignsize(); +} + +Dsymbol *TypeEnum::toDsymbol(Scope *sc) +{ + return sym; +} + +Type *TypeEnum::toBasetype() +{ + if (sym->scope) + { // Enum is forward referenced. We don't need to resolve the whole thing, + // just the base type + if (sym->memtype) + { sym->memtype = sym->memtype->semantic(sym->loc, sym->scope); + } + else + { if (!sym->isAnonymous()) + sym->memtype = Type::tint32; + } + } + if (!sym->memtype) + { +#ifdef DEBUG + printf("2: "); +#endif + error(sym->loc, "enum %s is forward referenced", sym->toChars()); + return tint32; + } + return sym->memtype->toBasetype(); +} + +void TypeEnum::toDecoBuffer(OutBuffer *buf, int flag) +{ + const char *name = sym->mangle(); + Type::toDecoBuffer(buf, flag); + buf->printf("%s", name); +} + +void TypeEnum::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(sym->toChars()); +} + +Expression *TypeEnum::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeEnum::dotExp(e = '%s', ident = '%s') '%s'\n", e->toChars(), ident->toChars(), toChars()); +#endif + Dsymbol *s = sym->search(e->loc, ident, 0); + if (!s) + { + if (ident == Id::max || + ident == Id::min || + ident == Id::init || + ident == Id::mangleof || + !sym->memtype + ) + { + return getProperty(e->loc, ident); + } + return sym->memtype->dotExp(sc, e, ident); + } + EnumMember *m = s->isEnumMember(); + Expression *em = m->value->copy(); + em->loc = e->loc; + return em; +} + +Expression *TypeEnum::getProperty(Loc loc, Identifier *ident) +{ Expression *e; + + if (ident == Id::max) + { + if (!sym->maxval) + goto Lfwd; + e = sym->maxval; + } + else if (ident == Id::min) + { + if (!sym->minval) + goto Lfwd; + e = sym->minval; + } + else if (ident == Id::init) + { + e = defaultInitLiteral(loc); + } + else if (ident == Id::stringof) + { char *s = toChars(); + e = new StringExp(loc, s, strlen(s), 'c'); + Scope sc; + e = e->semantic(&sc); + } + else if (ident == Id::mangleof) + { + e = Type::getProperty(loc, ident); + } + else + { + e = toBasetype()->getProperty(loc, ident); + } + return e; + +Lfwd: + error(loc, "forward reference of %s.%s", toChars(), ident->toChars()); + return new ErrorExp(); +} + +int TypeEnum::isintegral() +{ + return sym->memtype->isintegral(); +} + +int TypeEnum::isfloating() +{ + return sym->memtype->isfloating(); +} + +int TypeEnum::isreal() +{ + return sym->memtype->isreal(); +} + +int TypeEnum::isimaginary() +{ + return sym->memtype->isimaginary(); +} + +int TypeEnum::iscomplex() +{ + return sym->memtype->iscomplex(); +} + +int TypeEnum::isunsigned() +{ + return sym->memtype->isunsigned(); +} + +int TypeEnum::isscalar() +{ + return sym->memtype->isscalar(); +} + +int TypeEnum::isAssignable() +{ + return sym->memtype->isAssignable(); +} + +int TypeEnum::checkBoolean() +{ + return sym->memtype->checkBoolean(); +} + +int TypeEnum::needsDestruction() +{ + return sym->memtype->needsDestruction(); +} + +MATCH TypeEnum::implicitConvTo(Type *to) +{ MATCH m; + + //printf("TypeEnum::implicitConvTo()\n"); + if (ty == to->ty && sym == ((TypeEnum *)to)->sym) + m = (mod == to->mod) ? MATCHexact : MATCHconst; + else if (sym->memtype->implicitConvTo(to)) + m = MATCHconvert; // match with conversions + else + m = MATCHnomatch; // no match + return m; +} + +MATCH TypeEnum::constConv(Type *to) +{ + if (equals(to)) + return MATCHexact; + if (ty == to->ty && sym == ((TypeEnum *)to)->sym && + MODimplicitConv(mod, to->mod)) + return MATCHconst; + return MATCHnomatch; +} + + +Expression *TypeEnum::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeEnum::defaultInit() '%s'\n", toChars()); +#endif + // Initialize to first member of enum + //printf("%s\n", sym->defaultval->type->toChars()); + if (!sym->defaultval) + { + error(loc, "forward reference of %s.init", toChars()); + return new ErrorExp(); + } + return sym->defaultval; +} + +int TypeEnum::isZeroInit(Loc loc) +{ + if (!sym->defaultval && sym->scope) + { // Enum is forward referenced. We need to resolve the whole thing. + sym->semantic(NULL); + } + if (!sym->defaultval) + { +#ifdef DEBUG + printf("3: "); +#endif + error(loc, "enum %s is forward referenced", sym->toChars()); + return 0; + } + return sym->defaultval->isBool(FALSE); +} + +int TypeEnum::hasPointers() +{ + return toBasetype()->hasPointers(); +} + +/***************************** TypeTypedef *****************************/ + +TypeTypedef::TypeTypedef(TypedefDeclaration *sym) + : Type(Ttypedef) +{ + this->sym = sym; +} + +Type *TypeTypedef::syntaxCopy() +{ + return this; +} + +char *TypeTypedef::toChars() +{ + return Type::toChars(); +} + +Type *TypeTypedef::semantic(Loc loc, Scope *sc) +{ + //printf("TypeTypedef::semantic(%s), sem = %d\n", toChars(), sym->sem); + int errors = global.errors; + sym->semantic(sc); + if (errors != global.errors) + return terror; + return merge(); +} + +d_uns64 TypeTypedef::size(Loc loc) +{ + return sym->basetype->size(loc); +} + +unsigned TypeTypedef::alignsize() +{ + return sym->basetype->alignsize(); +} + +Dsymbol *TypeTypedef::toDsymbol(Scope *sc) +{ + return sym; +} + +void TypeTypedef::toDecoBuffer(OutBuffer *buf, int flag) +{ + Type::toDecoBuffer(buf, flag); + const char *name = sym->mangle(); + buf->printf("%s", name); +} + +void TypeTypedef::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + //printf("TypeTypedef::toCBuffer2() '%s'\n", sym->toChars()); + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(sym->toChars()); +} + +Expression *TypeTypedef::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeTypedef::dotExp(e = '%s', ident = '%s') '%s'\n", e->toChars(), ident->toChars(), toChars()); +#endif + if (ident == Id::init) + { + return Type::dotExp(sc, e, ident); + } + return sym->basetype->dotExp(sc, e, ident); +} + +Expression *TypeTypedef::getProperty(Loc loc, Identifier *ident) +{ +#if LOGDOTEXP + printf("TypeTypedef::getProperty(ident = '%s') '%s'\n", ident->toChars(), toChars()); +#endif + if (ident == Id::init) + { + return Type::getProperty(loc, ident); + } + return sym->basetype->getProperty(loc, ident); +} + +int TypeTypedef::isintegral() +{ + //printf("TypeTypedef::isintegral()\n"); + //printf("sym = '%s'\n", sym->toChars()); + //printf("basetype = '%s'\n", sym->basetype->toChars()); + return sym->basetype->isintegral(); +} + +int TypeTypedef::isfloating() +{ + return sym->basetype->isfloating(); +} + +int TypeTypedef::isreal() +{ + return sym->basetype->isreal(); +} + +int TypeTypedef::isimaginary() +{ + return sym->basetype->isimaginary(); +} + +int TypeTypedef::iscomplex() +{ + return sym->basetype->iscomplex(); +} + +int TypeTypedef::isunsigned() +{ + return sym->basetype->isunsigned(); +} + +int TypeTypedef::isscalar() +{ + return sym->basetype->isscalar(); +} + +int TypeTypedef::isAssignable() +{ + return sym->basetype->isAssignable(); +} + +int TypeTypedef::checkBoolean() +{ + return sym->basetype->checkBoolean(); +} + +int TypeTypedef::needsDestruction() +{ + return sym->basetype->needsDestruction(); +} + +Type *TypeTypedef::toBasetype() +{ + if (sym->inuse) + { + sym->error("circular definition"); + sym->basetype = Type::terror; + return Type::terror; + } + sym->inuse = 1; + Type *t = sym->basetype->toBasetype(); + sym->inuse = 0; + t = t->addMod(mod); + return t; +} + +MATCH TypeTypedef::implicitConvTo(Type *to) +{ MATCH m; + + //printf("TypeTypedef::implicitConvTo(to = %s) %s\n", to->toChars(), toChars()); + if (equals(to)) + m = MATCHexact; // exact match + else if (sym->basetype->implicitConvTo(to)) + m = MATCHconvert; // match with conversions + else if (ty == to->ty && sym == ((TypeTypedef *)to)->sym) + { + m = constConv(to); + } + else + m = MATCHnomatch; // no match + return m; +} + +MATCH TypeTypedef::constConv(Type *to) +{ + if (equals(to)) + return MATCHexact; + if (ty == to->ty && sym == ((TypeTypedef *)to)->sym) + return sym->basetype->implicitConvTo(((TypeTypedef *)to)->sym->basetype); + return MATCHnomatch; +} + +Type *TypeTypedef::toHeadMutable() +{ + if (!mod) + return this; + + Type *tb = toBasetype(); + Type *t = tb->toHeadMutable(); + if (t->equals(tb)) + return this; + else + return mutableOf(); +} + +Expression *TypeTypedef::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeTypedef::defaultInit() '%s'\n", toChars()); +#endif + if (sym->init) + { + //sym->init->toExpression()->print(); + return sym->init->toExpression(); + } + Type *bt = sym->basetype; + Expression *e = bt->defaultInit(loc); + e->type = this; + while (bt->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)bt; + e->type = tsa->next; + bt = tsa->next->toBasetype(); + } + return e; +} + +Expression *TypeTypedef::defaultInitLiteral(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeTypedef::defaultInitLiteral() '%s'\n", toChars()); +#endif + if (sym->init) + { + //sym->init->toExpression()->print(); + return sym->init->toExpression(); + } + Type *bt = sym->basetype; + Expression *e = bt->defaultInitLiteral(loc); + e->type = this; + return e; +} + +int TypeTypedef::isZeroInit(Loc loc) +{ + if (sym->init) + { + if (sym->init->isVoidInitializer()) + return 1; // initialize voids to 0 + Expression *e = sym->init->toExpression(); + if (e && e->isBool(FALSE)) + return 1; + return 0; // assume not + } + if (sym->inuse) + { + sym->error("circular definition"); + sym->basetype = Type::terror; + } + sym->inuse = 1; + int result = sym->basetype->isZeroInit(loc); + sym->inuse = 0; + return result; +} + +int TypeTypedef::hasPointers() +{ + return toBasetype()->hasPointers(); +} + +int TypeTypedef::hasWild() +{ + assert(toBasetype()); + return mod & MODwild || toBasetype()->hasWild(); +} + +/***************************** TypeStruct *****************************/ + +TypeStruct::TypeStruct(StructDeclaration *sym) + : Type(Tstruct) +{ + this->sym = sym; +} + +char *TypeStruct::toChars() +{ + //printf("sym.parent: %s, deco = %s\n", sym->parent->toChars(), deco); + if (mod) + return Type::toChars(); + TemplateInstance *ti = sym->parent->isTemplateInstance(); + if (ti && ti->toAlias() == sym) + { + return ti->toChars(); + } + return sym->toChars(); +} + +Type *TypeStruct::syntaxCopy() +{ + return this; +} + +Type *TypeStruct::semantic(Loc loc, Scope *sc) +{ + //printf("TypeStruct::semantic('%s')\n", sym->toChars()); + + /* Cannot do semantic for sym because scope chain may not + * be right. + */ + //sym->semantic(sc); + + return merge(); +} + +d_uns64 TypeStruct::size(Loc loc) +{ + return sym->size(loc); +} + +unsigned TypeStruct::alignsize() +{ unsigned sz; + + sym->size(0); // give error for forward references + sz = sym->alignsize; + if (sz > sym->structalign) + sz = sym->structalign; + return sz; +} + +Dsymbol *TypeStruct::toDsymbol(Scope *sc) +{ + return sym; +} + +void TypeStruct::toDecoBuffer(OutBuffer *buf, int flag) +{ + const char *name = sym->mangle(); + //printf("TypeStruct::toDecoBuffer('%s') = '%s'\n", toChars(), name); + Type::toDecoBuffer(buf, flag); + buf->printf("%s", name); +} + +void TypeStruct::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + TemplateInstance *ti = sym->parent->isTemplateInstance(); + if (ti && ti->toAlias() == sym) + buf->writestring(ti->toChars()); + else + buf->writestring(sym->toChars()); +} + +Expression *TypeStruct::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ + VarDeclaration *v; + Dsymbol *s; + DotVarExp *de; + Declaration *d; + +#if LOGDOTEXP + printf("TypeStruct::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars()); +#endif + if (!sym->members) + { + error(e->loc, "struct %s is forward referenced", sym->toChars()); + return new ErrorExp(); + } + + /* If e.tupleof + */ + if (ident == Id::tupleof) + { + /* Create a TupleExp out of the fields of the struct e: + * (e.field0, e.field1, e.field2, ...) + */ + e = e->semantic(sc); // do this before turning on noaccesscheck + e->type->size(); // do semantic of type + Expressions *exps = new Expressions; + exps->reserve(sym->fields.dim); + + Expression *ev = e; + for (size_t i = 0; i < sym->fields.dim; i++) + { VarDeclaration *v = sym->fields.tdata()[i]; + Expression *fe; + if (i == 0 && sc->func && sym->fields.dim > 1 && + e->hasSideEffect()) + { + Identifier *id = Lexer::uniqueId("__tup"); + ExpInitializer *ei = new ExpInitializer(e->loc, e); + VarDeclaration *vd = new VarDeclaration(e->loc, NULL, id, ei); + vd->storage_class |= STCctfe | STCref | STCforeach; + + ev = new VarExp(e->loc, vd); + fe = new CommaExp(e->loc, new DeclarationExp(e->loc, vd), ev); + fe = new DotVarExp(e->loc, fe, v); + } + else + fe = new DotVarExp(ev->loc, ev, v); + exps->push(fe); + } + e = new TupleExp(e->loc, exps); + sc = sc->push(); + sc->noaccesscheck = 1; + e = e->semantic(sc); + sc->pop(); + return e; + } + + if (e->op == TOKdotexp) + { DotExp *de = (DotExp *)e; + + if (de->e1->op == TOKimport) + { + assert(0); // cannot find a case where this happens; leave + // assert in until we do + ScopeExp *se = (ScopeExp *)de->e1; + + s = se->sds->search(e->loc, ident, 0); + e = de->e1; + goto L1; + } + } + + s = sym->search(e->loc, ident, 0); +L1: + if (!s) + { + return noMember(sc, e, ident); + } + if (!s->isFuncDeclaration()) // because of overloading + s->checkDeprecated(e->loc, sc); + s = s->toAlias(); + + v = s->isVarDeclaration(); + if (v && !v->isDataseg()) + { + Expression *ei = v->getConstInitializer(); + if (ei) + { e = ei->copy(); // need to copy it if it's a StringExp + e = e->semantic(sc); + return e; + } + } + + if (s->getType()) + { + //return new DotTypeExp(e->loc, e, s); + return new TypeExp(e->loc, s->getType()); + } + + EnumMember *em = s->isEnumMember(); + if (em) + { + assert(em->value); + return em->value->copy(); + } + + TemplateMixin *tm = s->isTemplateMixin(); + if (tm) + { + Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, tm)); + de->type = e->type; + return de; + } + + TemplateDeclaration *td = s->isTemplateDeclaration(); + if (td) + { + e = new DotTemplateExp(e->loc, e, td); + e = e->semantic(sc); + return e; + } + + TemplateInstance *ti = s->isTemplateInstance(); + if (ti) + { if (!ti->semanticRun) + { + if (global.errors) + return new ErrorExp(); // TemplateInstance::semantic() will fail anyway + ti->semantic(sc); + } + s = ti->inst->toAlias(); + if (!s->isTemplateInstance()) + goto L1; + Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti)); + de->type = e->type; + return de; + } + + if (s->isImport() || s->isModule() || s->isPackage()) + { + e = new DsymbolExp(e->loc, s, 0); + e = e->semantic(sc); + return e; + } + + OverloadSet *o = s->isOverloadSet(); + if (o) + { + OverExp *oe = new OverExp(o); + if (e->op == TOKtype) + return oe; + return new DotExp(e->loc, e, oe); + } + + d = s->isDeclaration(); +#ifdef DEBUG + if (!d) + printf("d = %s '%s'\n", s->kind(), s->toChars()); +#endif + assert(d); + + if (e->op == TOKtype) + { FuncDeclaration *fd = sc->func; + + if (d->isTupleDeclaration()) + { + e = new TupleExp(e->loc, d->isTupleDeclaration()); + e = e->semantic(sc); + return e; + } + else if (d->needThis() && fd && fd->vthis) + { + e = new DotVarExp(e->loc, new ThisExp(e->loc), d); + e = e->semantic(sc); + return e; + } + return new VarExp(e->loc, d, 1); + } + + if (d->isDataseg()) + { + // (e, d) + VarExp *ve; + + accessCheck(e->loc, sc, e, d); + ve = new VarExp(e->loc, d); + e = new CommaExp(e->loc, e, ve); + e = e->semantic(sc); + return e; + } + + if (v) + { + if (v->toParent() != sym) + sym->error(e->loc, "'%s' is not a member", v->toChars()); + + // *(&e + offset) + accessCheck(e->loc, sc, e, d); +#if 0 + Expression *b = new AddrExp(e->loc, e); + b->type = e->type->pointerTo(); + b = new AddExp(e->loc, b, new IntegerExp(e->loc, v->offset, Type::tint32)); + b->type = v->type->pointerTo(); + b = new PtrExp(e->loc, b); + b->type = v->type->addMod(e->type->mod); + return b; +#endif + } + + de = new DotVarExp(e->loc, e, d); + return de->semantic(sc); +} + +unsigned TypeStruct::memalign(unsigned salign) +{ + sym->size(0); // give error for forward references + return sym->structalign; +} + +Expression *TypeStruct::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeStruct::defaultInit() '%s'\n", toChars()); +#endif + Symbol *s = sym->toInitializer(); + Declaration *d = new SymbolDeclaration(sym->loc, s, sym); + assert(d); + d->type = this; + return new VarExp(sym->loc, d); +} + +/*************************************** + * Use when we prefer the default initializer to be a literal, + * rather than a global immutable variable. + */ +Expression *TypeStruct::defaultInitLiteral(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeStruct::defaultInitLiteral() '%s'\n", toChars()); +#endif + if (sym->isNested()) + return defaultInit(loc); + Expressions *structelems = new Expressions(); + structelems->setDim(sym->fields.dim); + for (size_t j = 0; j < structelems->dim; j++) + { + VarDeclaration *vd = sym->fields.tdata()[j]; + Expression *e; + if (vd->init) + { if (vd->init->isVoidInitializer()) + e = NULL; + else + e = vd->init->toExpression(); + } + else + e = vd->type->defaultInitLiteral(); + structelems->tdata()[j] = e; + } + StructLiteralExp *structinit = new StructLiteralExp(loc, (StructDeclaration *)sym, structelems); + // Why doesn't the StructLiteralExp constructor do this, when + // sym->type != NULL ? + structinit->type = sym->type; + return structinit; +} + + +int TypeStruct::isZeroInit(Loc loc) +{ + return sym->zeroInit; +} + +int TypeStruct::checkBoolean() +{ + return FALSE; +} + +int TypeStruct::needsDestruction() +{ + return sym->dtor != NULL; +} + +int TypeStruct::isAssignable() +{ + int assignable = TRUE; + unsigned offset; + + /* If any of the fields are const or invariant, + * then one cannot assign this struct. + */ + for (size_t i = 0; i < sym->fields.dim; i++) + { VarDeclaration *v = sym->fields.tdata()[i]; + //printf("%s [%d] v = (%s) %s, v->offset = %d, v->parent = %s", sym->toChars(), i, v->kind(), v->toChars(), v->offset, v->parent->kind()); + if (i == 0) + ; + else if (v->offset == offset) + { + /* If any fields of anonymous union are assignable, + * then regard union as assignable. + * This is to support unsafe things like Rebindable templates. + */ + if (assignable) + continue; + } + else + { + if (!assignable) + return FALSE; + } + assignable = v->type->isMutable() && v->type->isAssignable(); + offset = v->offset; + //printf(" -> assignable = %d\n", assignable); + } + + return assignable; +} + +int TypeStruct::hasPointers() +{ + // Probably should cache this information in sym rather than recompute + StructDeclaration *s = sym; + + sym->size(0); // give error for forward references + for (size_t i = 0; i < s->fields.dim; i++) + { + Dsymbol *sm = s->fields.tdata()[i]; + Declaration *d = sm->isDeclaration(); + if (d->storage_class & STCref || d->hasPointers()) + return TRUE; + } + return FALSE; +} + +MATCH TypeStruct::implicitConvTo(Type *to) +{ MATCH m; + + //printf("TypeStruct::implicitConvTo(%s => %s)\n", toChars(), to->toChars()); + if (to->ty == Taarray) + { + /* If there is an error instantiating AssociativeArray!(), it shouldn't + * be reported -- it just means implicit conversion is impossible. + */ + int errs = global.startGagging(); + to = ((TypeAArray*)to)->getImpl()->type; + if (global.endGagging(errs)) + { + return MATCHnomatch; + } + } + + if (ty == to->ty && sym == ((TypeStruct *)to)->sym) + { m = MATCHexact; // exact match + if (mod != to->mod) + { + if (MODimplicitConv(mod, to->mod)) + m = MATCHconst; + else + { /* Check all the fields. If they can all be converted, + * allow the conversion. + */ + for (size_t i = 0; i < sym->fields.dim; i++) + { Dsymbol *s = sym->fields.tdata()[i]; + VarDeclaration *v = s->isVarDeclaration(); + assert(v && v->storage_class & STCfield); + + // 'from' type + Type *tvf = v->type->addMod(mod); + + // 'to' type + Type *tv = v->type->castMod(to->mod); + + //printf("\t%s => %s, match = %d\n", v->type->toChars(), tv->toChars(), tvf->implicitConvTo(tv)); + if (tvf->implicitConvTo(tv) < MATCHconst) + return MATCHnomatch; + } + m = MATCHconst; + } + } + } + else if (sym->aliasthis) + m = aliasthisOf()->implicitConvTo(to); + else + m = MATCHnomatch; // no match + return m; +} + +MATCH TypeStruct::constConv(Type *to) +{ + if (equals(to)) + return MATCHexact; + if (ty == to->ty && sym == ((TypeStruct *)to)->sym && + MODimplicitConv(mod, to->mod)) + return MATCHconst; + return MATCHnomatch; +} + +unsigned TypeStruct::wildConvTo(Type *tprm) +{ + if (ty == tprm->ty && sym == ((TypeStruct *)tprm)->sym) + return Type::wildConvTo(tprm); + + if (sym->aliasthis) + { Type *t = aliasthisOf(); + assert(t); + return t->wildConvTo(tprm); + } + + return 0; +} + +Type *TypeStruct::toHeadMutable() +{ + return this; +} + + +/***************************** TypeClass *****************************/ + +TypeClass::TypeClass(ClassDeclaration *sym) + : Type(Tclass) +{ + this->sym = sym; +} + +char *TypeClass::toChars() +{ + if (mod) + return Type::toChars(); + return (char *)sym->toPrettyChars(); +} + +Type *TypeClass::syntaxCopy() +{ + return this; +} + +Type *TypeClass::semantic(Loc loc, Scope *sc) +{ + //printf("TypeClass::semantic(%s)\n", sym->toChars()); + if (deco) + return this; + //printf("\t%s\n", merge()->deco); + return merge(); +} + +d_uns64 TypeClass::size(Loc loc) +{ + return PTRSIZE; +} + +Dsymbol *TypeClass::toDsymbol(Scope *sc) +{ + return sym; +} + +void TypeClass::toDecoBuffer(OutBuffer *buf, int flag) +{ + const char *name = sym->mangle(); + //printf("TypeClass::toDecoBuffer('%s' flag=%d mod=%x) = '%s'\n", toChars(), flag, mod, name); + Type::toDecoBuffer(buf, flag); + buf->printf("%s", name); +} + +void TypeClass::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + buf->writestring(sym->toChars()); +} + +Expression *TypeClass::dotExp(Scope *sc, Expression *e, Identifier *ident) +{ + VarDeclaration *v; + Dsymbol *s; + +#if LOGDOTEXP + printf("TypeClass::dotExp(e='%s', ident='%s')\n", e->toChars(), ident->toChars()); +#endif + + if (e->op == TOKdotexp) + { DotExp *de = (DotExp *)e; + + if (de->e1->op == TOKimport) + { + ScopeExp *se = (ScopeExp *)de->e1; + + s = se->sds->search(e->loc, ident, 0); + e = de->e1; + goto L1; + } + } + + if (ident == Id::tupleof) + { + /* Create a TupleExp + */ + e = e->semantic(sc); // do this before turning on noaccesscheck + + /* If this is called in the middle of a class declaration, + * class Inner { + * int x; + * alias typeof(Inner.tupleof) T; + * int y; + * } + * then Inner.y will be omitted from the tuple. + */ + // Detect that error, and at least try to run semantic() on it if we can + sym->size(e->loc); + + Expressions *exps = new Expressions; + exps->reserve(sym->fields.dim); + + Expression *ev = e; + for (size_t i = 0; i < sym->fields.dim; i++) + { VarDeclaration *v = sym->fields.tdata()[i]; + // Don't include hidden 'this' pointer + if (v->isThisDeclaration()) + continue; + Expression *fe; + if (i == 0 && sc->func && sym->fields.dim > 1 && + e->hasSideEffect()) + { + Identifier *id = Lexer::uniqueId("__tup"); + ExpInitializer *ei = new ExpInitializer(e->loc, e); + VarDeclaration *vd = new VarDeclaration(e->loc, NULL, id, ei); + vd->storage_class |= STCctfe | STCref | STCforeach; + + ev = new VarExp(e->loc, vd); + fe = new CommaExp(e->loc, new DeclarationExp(e->loc, vd), ev); + fe = new DotVarExp(e->loc, fe, v); + } + else + fe = new DotVarExp(e->loc, ev, v); + exps->push(fe); + } + e = new TupleExp(e->loc, exps); + sc = sc->push(); + sc->noaccesscheck = 1; + e = e->semantic(sc); + sc->pop(); + return e; + } + + s = sym->search(e->loc, ident, 0); +L1: + if (!s) + { + // See if it's a base class + if (Dsymbol *cbase = sym->searchBase(e->loc, ident)) + { + e = new DotTypeExp(0, e, cbase); + return e; + } + + if (ident == Id::classinfo) + { + assert(ClassDeclaration::classinfo); + Type *t = ClassDeclaration::classinfo->type; + if (e->op == TOKtype || e->op == TOKdottype) + { + /* For type.classinfo, we know the classinfo + * at compile time. + */ + if (!sym->vclassinfo) + sym->vclassinfo = new TypeInfoClassDeclaration(sym->type); + e = new VarExp(e->loc, sym->vclassinfo); + e = e->addressOf(sc); + e->type = t; // do this so we don't get redundant dereference + } + else + { /* For class objects, the classinfo reference is the first + * entry in the vtbl[] + */ + e = new PtrExp(e->loc, e); + e->type = t->pointerTo(); + if (sym->isInterfaceDeclaration()) + { + if (sym->isCPPinterface()) + { /* C++ interface vtbl[]s are different in that the + * first entry is always pointer to the first virtual + * function, not classinfo. + * We can't get a .classinfo for it. + */ + error(e->loc, "no .classinfo for C++ interface objects"); + } + /* For an interface, the first entry in the vtbl[] + * is actually a pointer to an instance of struct Interface. + * The first member of Interface is the .classinfo, + * so add an extra pointer indirection. + */ + e->type = e->type->pointerTo(); + e = new PtrExp(e->loc, e); + e->type = t->pointerTo(); + } + e = new PtrExp(e->loc, e, t); + } + return e; + } + + if (ident == Id::__vptr) + { /* The pointer to the vtbl[] + * *cast(invariant(void*)**)e + */ + e = e->castTo(sc, tvoidptr->invariantOf()->pointerTo()->pointerTo()); + e = new PtrExp(e->loc, e); + e = e->semantic(sc); + return e; + } + + if (ident == Id::__monitor) + { /* The handle to the monitor (call it a void*) + * *(cast(void**)e + 1) + */ + e = e->castTo(sc, tvoidptr->pointerTo()); + e = new AddExp(e->loc, e, new IntegerExp(1)); + e = new PtrExp(e->loc, e); + e = e->semantic(sc); + return e; + } + + if (ident == Id::typeinfo) + { + if (!global.params.useDeprecated) + error(e->loc, ".typeinfo deprecated, use typeid(type)"); + return getTypeInfo(sc); + } + if (ident == Id::outer && sym->vthis) + { + s = sym->vthis; + } + else + { + return noMember(sc, e, ident); + } + } + if (!s->isFuncDeclaration()) // because of overloading + s->checkDeprecated(e->loc, sc); + s = s->toAlias(); + v = s->isVarDeclaration(); + if (v && !v->isDataseg()) + { Expression *ei = v->getConstInitializer(); + + if (ei) + { e = ei->copy(); // need to copy it if it's a StringExp + e = e->semantic(sc); + return e; + } + } + + if (s->getType()) + { +// if (e->op == TOKtype) + return new TypeExp(e->loc, s->getType()); +// return new DotTypeExp(e->loc, e, s); + } + + EnumMember *em = s->isEnumMember(); + if (em) + { + assert(em->value); + return em->value->copy(); + } + + TemplateMixin *tm = s->isTemplateMixin(); + if (tm) + { + Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, tm)); + de->type = e->type; + return de; + } + + TemplateDeclaration *td = s->isTemplateDeclaration(); + if (td) + { + e = new DotTemplateExp(e->loc, e, td); + e = e->semantic(sc); + return e; + } + + TemplateInstance *ti = s->isTemplateInstance(); + if (ti) + { if (!ti->semanticRun) + { + if (global.errors) + return new ErrorExp(); // TemplateInstance::semantic() will fail anyway + ti->semantic(sc); + } + s = ti->inst->toAlias(); + if (!s->isTemplateInstance()) + goto L1; + Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti)); + de->type = e->type; + return de; + } + +#if 0 // shouldn't this be here? + if (s->isImport() || s->isModule() || s->isPackage()) + { + e = new DsymbolExp(e->loc, s, 0); + e = e->semantic(sc); + return e; + } +#endif + + OverloadSet *o = s->isOverloadSet(); + if (o) + { + OverExp *oe = new OverExp(o); + if (e->op == TOKtype) + return oe; + return new DotExp(e->loc, e, oe); + } + + Declaration *d = s->isDeclaration(); + if (!d) + { + e->error("%s.%s is not a declaration", e->toChars(), ident->toChars()); + return new ErrorExp(); + } + + if (e->op == TOKtype) + { + /* It's: + * Class.d + */ + if (d->isTupleDeclaration()) + { + e = new TupleExp(e->loc, d->isTupleDeclaration()); + e = e->semantic(sc); + return e; + } + else if (d->needThis() && (hasThis(sc) || !(sc->intypeof || d->isFuncDeclaration()))) + { + if (sc->func) + { + ClassDeclaration *thiscd; + thiscd = sc->func->toParent()->isClassDeclaration(); + + if (thiscd) + { + ClassDeclaration *cd = e->type->isClassHandle(); + + if (cd == thiscd) + { + e = new ThisExp(e->loc); + e = new DotTypeExp(e->loc, e, cd); + DotVarExp *de = new DotVarExp(e->loc, e, d); + e = de->semantic(sc); + return e; + } + else if ((!cd || !cd->isBaseOf(thiscd, NULL)) && + !d->isFuncDeclaration()) + e->error("'this' is required, but %s is not a base class of %s", e->type->toChars(), thiscd->toChars()); + } + } + + /* Rewrite as: + * this.d + */ + DotVarExp *de = new DotVarExp(e->loc, new ThisExp(e->loc), d); + e = de->semantic(sc); + return e; + } + else + { + VarExp *ve = new VarExp(e->loc, d, 1); + return ve; + } + } + + if (d->isDataseg()) + { + // (e, d) + VarExp *ve; + + accessCheck(e->loc, sc, e, d); + ve = new VarExp(e->loc, d); + e = new CommaExp(e->loc, e, ve); + e = e->semantic(sc); + return e; + } + + if (d->parent && d->toParent()->isModule()) + { + // (e, d) + VarExp *ve = new VarExp(e->loc, d, 1); + e = new CommaExp(e->loc, e, ve); + e->type = d->type; + return e; + } + + DotVarExp *de = new DotVarExp(e->loc, e, d); + return de->semantic(sc); +} + +ClassDeclaration *TypeClass::isClassHandle() +{ + return sym; +} + +int TypeClass::isscope() +{ + return sym->isscope; +} + +int TypeClass::isBaseOf(Type *t, int *poffset) +{ + if (t->ty == Tclass) + { ClassDeclaration *cd; + + cd = ((TypeClass *)t)->sym; + if (sym->isBaseOf(cd, poffset)) + return 1; + } + return 0; +} + +MATCH TypeClass::implicitConvTo(Type *to) +{ + //printf("TypeClass::implicitConvTo(to = '%s') %s\n", to->toChars(), toChars()); + MATCH m = constConv(to); + if (m != MATCHnomatch) + return m; + + ClassDeclaration *cdto = to->isClassHandle(); + if (cdto) + { + if (cdto->scope) + cdto->semantic(NULL); + if (cdto->isBaseOf(sym, NULL)) + { //printf("'to' is base\n"); + return MATCHconvert; + } + } + + if (global.params.Dversion == 1) + { + // Allow conversion to (void *) + if (to->ty == Tpointer && ((TypePointer *)to)->next->ty == Tvoid) + return MATCHconvert; + } + + m = MATCHnomatch; + if (sym->aliasthis) + m = aliasthisOf()->implicitConvTo(to); + + return m; +} + +MATCH TypeClass::constConv(Type *to) +{ + if (equals(to)) + return MATCHexact; + if (ty == to->ty && sym == ((TypeClass *)to)->sym && + MODimplicitConv(mod, to->mod)) + return MATCHconst; + + /* Conversion derived to const(base) + */ + int offset = 0; + if (to->isBaseOf(this, &offset) && offset == 0 && !to->isMutable()) + return MATCHconvert; + + return MATCHnomatch; +} + +unsigned TypeClass::wildConvTo(Type *tprm) +{ + Type *tcprm = tprm->substWildTo(MODconst); + + if (constConv(tcprm)) + return Type::wildConvTo(tprm); + + ClassDeclaration *cdprm = tcprm->isClassHandle(); + if (cdprm && cdprm->isBaseOf(sym, NULL)) + return Type::wildConvTo(tprm); + + if (sym->aliasthis) + return aliasthisOf()->wildConvTo(tprm); + + return 0; +} + +Type *TypeClass::toHeadMutable() +{ + return this; +} + +Expression *TypeClass::defaultInit(Loc loc) +{ +#if LOGDEFAULTINIT + printf("TypeClass::defaultInit() '%s'\n", toChars()); +#endif + return new NullExp(loc, this); +} + +int TypeClass::isZeroInit(Loc loc) +{ + return 1; +} + +int TypeClass::checkBoolean() +{ + return TRUE; +} + +int TypeClass::hasPointers() +{ + return TRUE; +} + +/***************************** TypeTuple *****************************/ + +TypeTuple::TypeTuple(Parameters *arguments) + : Type(Ttuple) +{ + //printf("TypeTuple(this = %p)\n", this); + this->arguments = arguments; + //printf("TypeTuple() %p, %s\n", this, toChars()); +#ifdef DEBUG + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { + Parameter *arg = arguments->tdata()[i]; + assert(arg && arg->type); + } + } +#endif +} + +/**************** + * Form TypeTuple from the types of the expressions. + * Assume exps[] is already tuple expanded. + */ + +TypeTuple::TypeTuple(Expressions *exps) + : Type(Ttuple) +{ + Parameters *arguments = new Parameters; + if (exps) + { + arguments->setDim(exps->dim); + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = exps->tdata()[i]; + if (e->type->ty == Ttuple) + e->error("cannot form tuple of tuples"); + Parameter *arg = new Parameter(STCundefined, e->type, NULL, NULL); + arguments->tdata()[i] = arg; + } + } + this->arguments = arguments; + //printf("TypeTuple() %p, %s\n", this, toChars()); +} + +/******************************************* + * Type tuple with 0, 1 or 2 types in it. + */ +TypeTuple::TypeTuple() + : Type(Ttuple) +{ + arguments = new Parameters(); +} + +TypeTuple::TypeTuple(Type *t1) + : Type(Ttuple) +{ + arguments = new Parameters(); + arguments->push(new Parameter(0, t1, NULL, NULL)); +} + +TypeTuple::TypeTuple(Type *t1, Type *t2) + : Type(Ttuple) +{ + arguments = new Parameters(); + arguments->push(new Parameter(0, t1, NULL, NULL)); + arguments->push(new Parameter(0, t2, NULL, NULL)); +} + +Type *TypeTuple::syntaxCopy() +{ + Parameters *args = Parameter::arraySyntaxCopy(arguments); + Type *t = new TypeTuple(args); + t->mod = mod; + return t; +} + +Type *TypeTuple::semantic(Loc loc, Scope *sc) +{ + //printf("TypeTuple::semantic(this = %p)\n", this); + //printf("TypeTuple::semantic() %p, %s\n", this, toChars()); + if (!deco) + deco = merge()->deco; + + /* Don't return merge(), because a tuple with one type has the + * same deco as that type. + */ + return this; +} + +int TypeTuple::equals(Object *o) +{ Type *t; + + t = (Type *)o; + //printf("TypeTuple::equals(%s, %s)\n", toChars(), t->toChars()); + if (this == t) + { + return 1; + } + if (t->ty == Ttuple) + { TypeTuple *tt = (TypeTuple *)t; + + if (arguments->dim == tt->arguments->dim) + { + for (size_t i = 0; i < tt->arguments->dim; i++) + { Parameter *arg1 = arguments->tdata()[i]; + Parameter *arg2 = tt->arguments->tdata()[i]; + + if (!arg1->type->equals(arg2->type)) + return 0; + } + return 1; + } + } + return 0; +} + +Type *TypeTuple::reliesOnTident() +{ + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { + Parameter *arg = arguments->tdata()[i]; + Type *t = arg->type->reliesOnTident(); + if (t) + return t; + } + } + return NULL; +} + +#if 0 +Type *TypeTuple::makeConst() +{ + //printf("TypeTuple::makeConst() %s\n", toChars()); + if (cto) + return cto; + TypeTuple *t = (TypeTuple *)Type::makeConst(); + t->arguments = new Parameters(); + t->arguments->setDim(arguments->dim); + for (size_t i = 0; i < arguments->dim; i++) + { Parameter *arg = arguments->tdata()[i]; + Parameter *narg = new Parameter(arg->storageClass, arg->type->constOf(), arg->ident, arg->defaultArg); + t->arguments->tdata()[i] = (Parameter *)narg; + } + return t; +} +#endif + +void TypeTuple::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + Parameter::argsToCBuffer(buf, hgs, arguments, 0); +} + +void TypeTuple::toDecoBuffer(OutBuffer *buf, int flag) +{ + //printf("TypeTuple::toDecoBuffer() this = %p, %s\n", this, toChars()); + Type::toDecoBuffer(buf, flag); + OutBuffer buf2; + Parameter::argsToDecoBuffer(&buf2, arguments); + unsigned len = buf2.offset; + buf->printf("%d%.*s", len, len, (char *)buf2.extractData()); +} + +Expression *TypeTuple::getProperty(Loc loc, Identifier *ident) +{ Expression *e; + +#if LOGDOTEXP + printf("TypeTuple::getProperty(type = '%s', ident = '%s')\n", toChars(), ident->toChars()); +#endif + if (ident == Id::length) + { + e = new IntegerExp(loc, arguments->dim, Type::tsize_t); + } + else + { + error(loc, "no property '%s' for tuple '%s'", ident->toChars(), toChars()); + e = new ErrorExp(); + } + return e; +} + +/***************************** TypeSlice *****************************/ + +/* This is so we can slice a TypeTuple */ + +TypeSlice::TypeSlice(Type *next, Expression *lwr, Expression *upr) + : TypeNext(Tslice, next) +{ + //printf("TypeSlice[%s .. %s]\n", lwr->toChars(), upr->toChars()); + this->lwr = lwr; + this->upr = upr; +} + +Type *TypeSlice::syntaxCopy() +{ + Type *t = new TypeSlice(next->syntaxCopy(), lwr->syntaxCopy(), upr->syntaxCopy()); + t->mod = mod; + return t; +} + +Type *TypeSlice::semantic(Loc loc, Scope *sc) +{ + //printf("TypeSlice::semantic() %s\n", toChars()); + next = next->semantic(loc, sc); + transitive(); + //printf("next: %s\n", next->toChars()); + + Type *tbn = next->toBasetype(); + if (tbn->ty != Ttuple) + { error(loc, "can only slice tuple types, not %s", tbn->toChars()); + return Type::terror; + } + TypeTuple *tt = (TypeTuple *)tbn; + + lwr = semanticLength(sc, tbn, lwr); + lwr = lwr->optimize(WANTvalue | WANTinterpret); + uinteger_t i1 = lwr->toUInteger(); + + upr = semanticLength(sc, tbn, upr); + upr = upr->optimize(WANTvalue | WANTinterpret); + uinteger_t i2 = upr->toUInteger(); + + if (!(i1 <= i2 && i2 <= tt->arguments->dim)) + { error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, tt->arguments->dim); + return Type::terror; + } + + Parameters *args = new Parameters; + args->reserve(i2 - i1); + for (size_t i = i1; i < i2; i++) + { Parameter *arg = tt->arguments->tdata()[i]; + args->push(arg); + } + + Type *t = (new TypeTuple(args))->semantic(loc, sc); + return t; +} + +void TypeSlice::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) +{ + next->resolve(loc, sc, pe, pt, ps); + if (*pe) + { // It's really a slice expression + Expression *e; + e = new SliceExp(loc, *pe, lwr, upr); + *pe = e; + } + else if (*ps) + { Dsymbol *s = *ps; + TupleDeclaration *td = s->isTupleDeclaration(); + if (td) + { + /* It's a slice of a TupleDeclaration + */ + ScopeDsymbol *sym = new ArrayScopeSymbol(sc, td); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + lwr = lwr->semantic(sc); + lwr = lwr->optimize(WANTvalue | WANTinterpret); + uinteger_t i1 = lwr->toUInteger(); + + upr = upr->semantic(sc); + upr = upr->optimize(WANTvalue | WANTinterpret); + uinteger_t i2 = upr->toUInteger(); + + sc = sc->pop(); + + if (!(i1 <= i2 && i2 <= td->objects->dim)) + { error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, td->objects->dim); + goto Ldefault; + } + + if (i1 == 0 && i2 == td->objects->dim) + { + *ps = td; + return; + } + + /* Create a new TupleDeclaration which + * is a slice [i1..i2] out of the old one. + */ + Objects *objects = new Objects; + objects->setDim(i2 - i1); + for (size_t i = 0; i < objects->dim; i++) + { + objects->tdata()[i] = td->objects->tdata()[(size_t)i1 + i]; + } + + TupleDeclaration *tds = new TupleDeclaration(loc, td->ident, objects); + *ps = tds; + } + else + goto Ldefault; + } + else + { + Ldefault: + Type::resolve(loc, sc, pe, pt, ps); + } +} + +void TypeSlice::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) +{ + if (mod != this->mod) + { toCBuffer3(buf, hgs, mod); + return; + } + next->toCBuffer2(buf, hgs, this->mod); + + buf->printf("[%s .. ", lwr->toChars()); + buf->printf("%s]", upr->toChars()); +} + +/***************************** TypeNull *****************************/ + +TypeNull::TypeNull() + : Type(Tnull) +{ +} + +Type *TypeNull::syntaxCopy() +{ + // No semantic analysis done, no need to copy + return this; +} + +MATCH TypeNull::implicitConvTo(Type *to) +{ + //printf("TypeNull::implicitConvTo(this=%p, to=%p)\n", this, to); + //printf("from: %s\n", toChars()); + //printf("to : %s\n", to->toChars()); + MATCH m = Type::implicitConvTo(to); + if (m) + return m; + + // NULL implicitly converts to any pointer type or dynamic array + //if (type->ty == Tpointer && type->nextOf()->ty == Tvoid) + { + Type *tb= to->toBasetype(); + if (tb->ty == Tpointer || tb->ty == Tarray || + tb->ty == Taarray || tb->ty == Tclass || + tb->ty == Tdelegate) + return MATCHconst; + } + + return MATCHnomatch; +} + +void TypeNull::toDecoBuffer(OutBuffer *buf, int flag) +{ + //tvoidptr->toDecoBuffer(buf, flag); + Type::toDecoBuffer(buf, flag); +} + +void TypeNull::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs) +{ + buf->writestring("typeof(null)"); +} + +d_uns64 TypeNull::size(Loc loc) { return tvoidptr->size(loc); } +//Expression *TypeNull::getProperty(Loc loc, Identifier *ident) { return new ErrorExp(); } +//Expression *TypeNull::dotExp(Scope *sc, Expression *e, Identifier *ident) { return new ErrorExp(); } +Expression *TypeNull::defaultInit(Loc loc) { return new NullExp(0, Type::tnull); } +//Expression *TypeNull::defaultInitLiteral(Loc loc) { return new ErrorExp(); } + +/***************************** Parameter *****************************/ + +Parameter::Parameter(StorageClass storageClass, Type *type, Identifier *ident, Expression *defaultArg) +{ + this->type = type; + this->ident = ident; + this->storageClass = storageClass; + this->defaultArg = defaultArg; +} + +Parameter *Parameter::syntaxCopy() +{ + Parameter *a = new Parameter(storageClass, + type ? type->syntaxCopy() : NULL, + ident, + defaultArg ? defaultArg->syntaxCopy() : NULL); + return a; +} + +Parameters *Parameter::arraySyntaxCopy(Parameters *args) +{ Parameters *a = NULL; + + if (args) + { + a = new Parameters(); + a->setDim(args->dim); + for (size_t i = 0; i < a->dim; i++) + { Parameter *arg = args->tdata()[i]; + + arg = arg->syntaxCopy(); + a->tdata()[i] = arg; + } + } + return a; +} + +char *Parameter::argsTypesToChars(Parameters *args, int varargs) +{ + OutBuffer *buf = new OutBuffer(); + +#if 1 + HdrGenState hgs; + argsToCBuffer(buf, &hgs, args, varargs); +#else + buf->writeByte('('); + if (args) + { OutBuffer argbuf; + HdrGenState hgs; + + for (size_t i = 0; i < args->dim; i++) + { if (i) + buf->writeByte(','); + Parameter *arg = args->tdata()[i]; + argbuf.reset(); + arg->type->toCBuffer2(&argbuf, &hgs, 0); + buf->write(&argbuf); + } + if (varargs) + { + if (i && varargs == 1) + buf->writeByte(','); + buf->writestring("..."); + } + } + buf->writeByte(')'); +#endif + return buf->toChars(); +} + +void Parameter::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Parameters *arguments, int varargs) +{ + buf->writeByte('('); + if (arguments) + { + OutBuffer argbuf; + + size_t dim = Parameter::dim(arguments); + for (size_t i = 0; i < dim; i++) + { + if (i) + buf->writestring(", "); + Parameter *arg = Parameter::getNth(arguments, i); + + if (arg->storageClass & STCauto) + buf->writestring("auto "); + + if (arg->storageClass & STCout) + buf->writestring("out "); + else if (arg->storageClass & STCref) + buf->writestring((global.params.Dversion == 1) + ? "inout " : "ref "); + else if (arg->storageClass & STCin) + buf->writestring("in "); + else if (arg->storageClass & STClazy) + buf->writestring("lazy "); + else if (arg->storageClass & STCalias) + buf->writestring("alias "); + + StorageClass stc = arg->storageClass; + if (arg->type && arg->type->mod & MODshared) + stc &= ~STCshared; + + StorageClassDeclaration::stcToCBuffer(buf, + stc & (STCconst | STCimmutable | STCshared | STCscope)); + + argbuf.reset(); + if (arg->storageClass & STCalias) + { if (arg->ident) + argbuf.writestring(arg->ident->toChars()); + } + else + arg->type->toCBuffer(&argbuf, arg->ident, hgs); + if (arg->defaultArg) + { + argbuf.writestring(" = "); + arg->defaultArg->toCBuffer(&argbuf, hgs); + } + buf->write(&argbuf); + } + if (varargs) + { + if (arguments->dim && varargs == 1) + buf->writeByte(','); + buf->writestring("..."); + } + } + buf->writeByte(')'); +} + +static int argsToDecoBufferDg(void *ctx, size_t n, Parameter *arg) +{ + arg->toDecoBuffer((OutBuffer *)ctx); + return 0; +} + +void Parameter::argsToDecoBuffer(OutBuffer *buf, Parameters *arguments) +{ + //printf("Parameter::argsToDecoBuffer()\n"); + // Write argument types + foreach(arguments, &argsToDecoBufferDg, buf); +} + +/**************************************** + * Determine if parameter list is really a template parameter list + * (i.e. it has auto or alias parameters) + */ + +static int isTPLDg(void *ctx, size_t n, Parameter *arg) +{ + if (arg->storageClass & (STCalias | STCauto | STCstatic)) + return 1; + return 0; +} + +int Parameter::isTPL(Parameters *arguments) +{ + //printf("Parameter::isTPL()\n"); + return foreach(arguments, &isTPLDg, NULL); +} + +/**************************************************** + * Determine if parameter is a lazy array of delegates. + * If so, return the return type of those delegates. + * If not, return NULL. + */ + +Type *Parameter::isLazyArray() +{ +// if (inout == Lazy) + { + Type *tb = type->toBasetype(); + if (tb->ty == Tsarray || tb->ty == Tarray) + { + Type *tel = ((TypeArray *)tb)->next->toBasetype(); + if (tel->ty == Tdelegate) + { + TypeDelegate *td = (TypeDelegate *)tel; + TypeFunction *tf = (TypeFunction *)td->next; + + if (!tf->varargs && Parameter::dim(tf->parameters) == 0) + { + return tf->next; // return type of delegate + } + } + } + } + return NULL; +} + +void Parameter::toDecoBuffer(OutBuffer *buf) +{ + if (storageClass & STCscope) + buf->writeByte('M'); + switch (storageClass & (STCin | STCout | STCref | STClazy)) + { case 0: + case STCin: + break; + case STCout: + buf->writeByte('J'); + break; + case STCref: + buf->writeByte('K'); + break; + case STClazy: + buf->writeByte('L'); + break; + default: +#ifdef DEBUG + printf("storageClass = x%llx\n", storageClass & (STCin | STCout | STCref | STClazy)); + halt(); +#endif + assert(0); + } +#if 0 + int mod = 0x100; + if (type->toBasetype()->ty == Tclass) + mod = 0; + type->toDecoBuffer(buf, mod); +#else + //type->toHeadMutable()->toDecoBuffer(buf, 0); + type->toDecoBuffer(buf, 0); +#endif +} + +/*************************************** + * Determine number of arguments, folding in tuples. + */ + +static int dimDg(void *ctx, size_t n, Parameter *) +{ + ++*(size_t *)ctx; + return 0; +} + +size_t Parameter::dim(Parameters *args) +{ + size_t n = 0; + foreach(args, &dimDg, &n); + return n; +} + +/*************************************** + * Get nth Parameter, folding in tuples. + * Returns: + * Parameter* nth Parameter + * NULL not found, *pn gets incremented by the number + * of Parameters + */ + +struct GetNthParamCtx +{ + size_t nth; + Parameter *arg; +}; + +static int getNthParamDg(void *ctx, size_t n, Parameter *arg) +{ + GetNthParamCtx *p = (GetNthParamCtx *)ctx; + if (n == p->nth) + { p->arg = arg; + return 1; + } + return 0; +} + +Parameter *Parameter::getNth(Parameters *args, size_t nth, size_t *pn) +{ + GetNthParamCtx ctx = { nth, NULL }; + int res = foreach(args, &getNthParamDg, &ctx); + return res ? ctx.arg : NULL; +} + +/*************************************** + * Expands tuples in args in depth first order. Calls + * dg(void *ctx, size_t argidx, Parameter *arg) for each Parameter. + * If dg returns !=0, stops and returns that value else returns 0. + * Use this function to avoid the O(N + N^2/2) complexity of + * calculating dim and calling N times getNth. + */ + +int Parameter::foreach(Parameters *args, Parameter::ForeachDg dg, void *ctx, size_t *pn) +{ + assert(dg); + if (!args) + return 0; + + size_t n = pn ? *pn : 0; // take over index + int result = 0; + for (size_t i = 0; i < args->dim; i++) + { Parameter *arg = args->tdata()[i]; + Type *t = arg->type->toBasetype(); + + if (t->ty == Ttuple) + { TypeTuple *tu = (TypeTuple *)t; + result = foreach(tu->arguments, dg, ctx, &n); + } + else + result = dg(ctx, n++, arg); + + if (result) + break; + } + + if (pn) + *pn = n; // update index + return result; +} diff --git a/mtype.h b/mtype.h new file mode 100644 index 00000000..b5bedf9e --- /dev/null +++ b/mtype.h @@ -0,0 +1,992 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_MTYPE_H +#define DMD_MTYPE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "stringtable.h" + +#include "arraytypes.h" +#include "expression.h" + +struct Scope; +struct Identifier; +struct Expression; +struct StructDeclaration; +struct ClassDeclaration; +struct VarDeclaration; +struct EnumDeclaration; +struct TypedefDeclaration; +struct TypeInfoDeclaration; +struct Dsymbol; +struct TemplateInstance; +struct CppMangleState; +struct TemplateDeclaration; +enum LINK; + +struct TypeBasic; +struct HdrGenState; +struct Parameter; + +// Back end +#if IN_GCC +union tree_node; typedef union tree_node TYPE; +typedef TYPE type; +#else +typedef struct TYPE type; +#endif +struct Symbol; +struct TypeTuple; + +enum ENUMTY +{ + Tarray, // slice array, aka T[] + Tsarray, // static array, aka T[dimension] + Taarray, // associative array, aka T[type] + Tpointer, + Treference, + Tfunction, + Tident, + Tclass, + Tstruct, + Tenum, + + Ttypedef, + Tdelegate, + Tnone, + Tvoid, + Tint8, + Tuns8, + Tint16, + Tuns16, + Tint32, + Tuns32, + + Tint64, + Tuns64, + Tfloat32, + Tfloat64, + Tfloat80, + Timaginary32, + Timaginary64, + Timaginary80, + Tcomplex32, + Tcomplex64, + + Tcomplex80, + Tbool, + Tchar, + Twchar, + Tdchar, + Terror, + Tinstance, + Ttypeof, + Ttuple, + Tslice, + + Treturn, + Tnull, + Tvector, + TMAX +}; +typedef unsigned char TY; // ENUMTY + +#define Tascii Tchar + +extern int Tsize_t; +extern int Tptrdiff_t; + + +struct Type : Object +{ + TY ty; + unsigned char mod; // modifiers MODxxxx + /* pick this order of numbers so switch statements work better + */ + #define MODconst 1 // type is const + #define MODimmutable 4 // type is immutable + #define MODshared 2 // type is shared + #define MODwild 8 // type is wild + #define MODmutable 0x10 // type is mutable (only used in wildcard matching) + char *deco; + + /* These are cached values that are lazily evaluated by constOf(), invariantOf(), etc. + * They should not be referenced by anybody but mtype.c. + * They can be NULL if not lazily evaluated yet. + * Note that there is no "shared immutable", because that is just immutable + * Naked == no MOD bits + */ + + Type *cto; // MODconst ? naked version of this type : const version + Type *ito; // MODimmutable ? naked version of this type : immutable version + Type *sto; // MODshared ? naked version of this type : shared mutable version + Type *scto; // MODshared|MODconst ? naked version of this type : shared const version + Type *wto; // MODwild ? naked version of this type : wild version + Type *swto; // MODshared|MODwild ? naked version of this type : shared wild version + + Type *pto; // merged pointer to this type + Type *rto; // reference to this type + Type *arrayof; // array of this type + TypeInfoDeclaration *vtinfo; // TypeInfo object for this Type + + type *ctype; // for back end + + #define tvoid basic[Tvoid] + #define tint8 basic[Tint8] + #define tuns8 basic[Tuns8] + #define tint16 basic[Tint16] + #define tuns16 basic[Tuns16] + #define tint32 basic[Tint32] + #define tuns32 basic[Tuns32] + #define tint64 basic[Tint64] + #define tuns64 basic[Tuns64] + #define tfloat32 basic[Tfloat32] + #define tfloat64 basic[Tfloat64] + #define tfloat80 basic[Tfloat80] + + #define timaginary32 basic[Timaginary32] + #define timaginary64 basic[Timaginary64] + #define timaginary80 basic[Timaginary80] + + #define tcomplex32 basic[Tcomplex32] + #define tcomplex64 basic[Tcomplex64] + #define tcomplex80 basic[Tcomplex80] + + #define tbool basic[Tbool] + #define tchar basic[Tchar] + #define twchar basic[Twchar] + #define tdchar basic[Tdchar] + + // Some special types + #define tshiftcnt tint32 // right side of shift expression +// #define tboolean tint32 // result of boolean expression + #define tboolean tbool // result of boolean expression + #define tindex tsize_t // array/ptr index + static Type *tvoidptr; // void* + static Type *tstring; // immutable(char)[] + #define terror basic[Terror] // for error recovery + + #define tnull basic[Tnull] // for null type + + #define tsize_t basic[Tsize_t] // matches size_t alias + #define tptrdiff_t basic[Tptrdiff_t] // matches ptrdiff_t alias + #define thash_t tsize_t // matches hash_t alias + + static ClassDeclaration *typeinfo; + static ClassDeclaration *typeinfoclass; + static ClassDeclaration *typeinfointerface; + static ClassDeclaration *typeinfostruct; + static ClassDeclaration *typeinfotypedef; + static ClassDeclaration *typeinfopointer; + static ClassDeclaration *typeinfoarray; + static ClassDeclaration *typeinfostaticarray; + static ClassDeclaration *typeinfoassociativearray; + static ClassDeclaration *typeinfovector; + static ClassDeclaration *typeinfoenum; + static ClassDeclaration *typeinfofunction; + static ClassDeclaration *typeinfodelegate; + static ClassDeclaration *typeinfotypelist; + static ClassDeclaration *typeinfoconst; + static ClassDeclaration *typeinfoinvariant; + static ClassDeclaration *typeinfoshared; + static ClassDeclaration *typeinfowild; + + static TemplateDeclaration *associativearray; + + static Type *basic[TMAX]; + static unsigned char mangleChar[TMAX]; + static unsigned char sizeTy[TMAX]; + static StringTable stringtable; + + // These tables are for implicit conversion of binary ops; + // the indices are the type of operand one, followed by operand two. + static unsigned char impcnvResult[TMAX][TMAX]; + static unsigned char impcnvType1[TMAX][TMAX]; + static unsigned char impcnvType2[TMAX][TMAX]; + + // If !=0, give warning on implicit conversion + static unsigned char impcnvWarn[TMAX][TMAX]; + + Type(TY ty); + virtual Type *syntaxCopy(); + int equals(Object *o); + int dyncast() { return DYNCAST_TYPE; } // kludge for template.isType() + int covariant(Type *t); + char *toChars(); + static char needThisPrefix(); + static void init(); + d_uns64 size(); + virtual d_uns64 size(Loc loc); + virtual unsigned alignsize(); + virtual Type *semantic(Loc loc, Scope *sc); + Type *trySemantic(Loc loc, Scope *sc); + virtual void toDecoBuffer(OutBuffer *buf, int flag = 0); + Type *merge(); + Type *merge2(); + virtual void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); + virtual void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void toCBuffer3(OutBuffer *buf, HdrGenState *hgs, int mod); + void modToBuffer(OutBuffer *buf); +#if CPP_MANGLE + virtual void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + virtual int isintegral(); + virtual int isfloating(); // real, imaginary, or complex + virtual int isreal(); + virtual int isimaginary(); + virtual int iscomplex(); + virtual int isscalar(); + virtual int isunsigned(); + virtual int isscope(); + virtual int isString(); + virtual int isAssignable(); + virtual int checkBoolean(); // if can be converted to boolean value + virtual void checkDeprecated(Loc loc, Scope *sc); + int isConst() { return mod & MODconst; } + int isImmutable() { return mod & MODimmutable; } + int isMutable() { return !(mod & (MODconst | MODimmutable | MODwild)); } + int isShared() { return mod & MODshared; } + int isSharedConst() { return mod == (MODshared | MODconst); } + int isWild() { return mod & MODwild; } + int isSharedWild() { return mod == (MODshared | MODwild); } + int isNaked() { return mod == 0; } + Type *constOf(); + Type *invariantOf(); + Type *mutableOf(); + Type *sharedOf(); + Type *sharedConstOf(); + Type *unSharedOf(); + Type *wildOf(); + Type *sharedWildOf(); + void fixTo(Type *t); + void check(); + Type *addSTC(StorageClass stc); + Type *castMod(unsigned mod); + Type *addMod(unsigned mod); + Type *addStorageClass(StorageClass stc); + Type *pointerTo(); + Type *referenceTo(); + Type *arrayOf(); + Type *aliasthisOf(); + virtual Type *makeConst(); + virtual Type *makeInvariant(); + virtual Type *makeShared(); + virtual Type *makeSharedConst(); + virtual Type *makeWild(); + virtual Type *makeSharedWild(); + virtual Type *makeMutable(); + virtual Dsymbol *toDsymbol(Scope *sc); + virtual Type *toBasetype(); + virtual int isBaseOf(Type *t, int *poffset); + virtual MATCH implicitConvTo(Type *to); + virtual MATCH constConv(Type *to); + virtual unsigned wildConvTo(Type *tprm); + Type *substWildTo(unsigned mod); + virtual Type *toHeadMutable(); + virtual ClassDeclaration *isClassHandle(); + virtual Expression *getProperty(Loc loc, Identifier *ident); + virtual Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *noMember(Scope *sc, Expression *e, Identifier *ident); + virtual unsigned memalign(unsigned salign); + virtual Expression *defaultInit(Loc loc = 0); + virtual Expression *defaultInitLiteral(Loc loc = 0); + virtual int isZeroInit(Loc loc = 0); // if initializer is 0 + virtual dt_t **toDt(dt_t **pdt); + Identifier *getTypeInfoIdent(int internal); + virtual MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + virtual void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + Expression *getInternalTypeInfo(Scope *sc); + Expression *getTypeInfo(Scope *sc); + virtual TypeInfoDeclaration *getTypeInfoDeclaration(); + virtual int builtinTypeInfo(); + virtual Type *reliesOnTident(); + virtual int hasWild(); + virtual Expression *toExpression(); + virtual int hasPointers(); + virtual TypeTuple *toArgTypes(); + virtual Type *nextOf(); + uinteger_t sizemask(); + virtual int needsDestruction(); + + static void error(Loc loc, const char *format, ...); + static void warning(Loc loc, const char *format, ...); + + // For backend + virtual unsigned totym(); + virtual type *toCtype(); + virtual type *toCParamtype(); + virtual Symbol *toSymbol(); + + // For eliminating dynamic_cast + virtual TypeBasic *isTypeBasic(); +}; + +struct TypeError : Type +{ + TypeError(); + Type *syntaxCopy(); + + void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); + + d_uns64 size(Loc loc); + Expression *getProperty(Loc loc, Identifier *ident); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *defaultInit(Loc loc); + Expression *defaultInitLiteral(Loc loc); +}; + +struct TypeNext : Type +{ + Type *next; + + TypeNext(TY ty, Type *next); + void toDecoBuffer(OutBuffer *buf, int flag); + void checkDeprecated(Loc loc, Scope *sc); + Type *reliesOnTident(); + int hasWild(); + Type *nextOf(); + Type *makeConst(); + Type *makeInvariant(); + Type *makeShared(); + Type *makeSharedConst(); + Type *makeWild(); + Type *makeSharedWild(); + Type *makeMutable(); + MATCH constConv(Type *to); + unsigned wildConvTo(Type *tprm); + void transitive(); +}; + +struct TypeBasic : Type +{ + const char *dstring; + unsigned flags; + + TypeBasic(TY ty); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + unsigned alignsize(); + Expression *getProperty(Loc loc, Identifier *ident); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + char *toChars(); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + int isintegral(); + int isfloating(); + int isreal(); + int isimaginary(); + int iscomplex(); + int isscalar(); + int isunsigned(); + MATCH implicitConvTo(Type *to); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); + int builtinTypeInfo(); + TypeTuple *toArgTypes(); + + // For eliminating dynamic_cast + TypeBasic *isTypeBasic(); +}; + +struct TypeVector : Type +{ + Type *basetype; + + TypeVector(Loc loc, Type *basetype); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + d_uns64 size(Loc loc); + unsigned alignsize(); + Expression *getProperty(Loc loc, Identifier *ident); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + char *toChars(); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void toDecoBuffer(OutBuffer *buf, int flag); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + int isintegral(); + int isfloating(); + int isscalar(); + int isunsigned(); + int checkBoolean(); + MATCH implicitConvTo(Type *to); + Expression *defaultInit(Loc loc); + TypeBasic *elementType(); + int isZeroInit(Loc loc); + TypeInfoDeclaration *getTypeInfoDeclaration(); + TypeTuple *toArgTypes(); +}; + +struct TypeArray : TypeNext +{ + TypeArray(TY ty, Type *next); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); +}; + +// Static array, one with a fixed dimension +struct TypeSArray : TypeArray +{ + Expression *dim; + + TypeSArray(Type *t, Expression *dim); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + unsigned alignsize(); + Type *semantic(Loc loc, Scope *sc); + void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + int isString(); + int isZeroInit(Loc loc); + unsigned memalign(unsigned salign); + MATCH constConv(Type *to); + MATCH implicitConvTo(Type *to); + Expression *defaultInit(Loc loc); + Expression *defaultInitLiteral(Loc loc); + dt_t **toDt(dt_t **pdt); + dt_t **toDtElem(dt_t **pdt, Expression *e); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + Expression *toExpression(); + int hasPointers(); + int needsDestruction(); + TypeTuple *toArgTypes(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); + type *toCParamtype(); +}; + +// Dynamic array, no dimension +struct TypeDArray : TypeArray +{ + TypeDArray(Type *t); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + unsigned alignsize(); + Type *semantic(Loc loc, Scope *sc); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + int isString(); + int isZeroInit(Loc loc); + int checkBoolean(); + MATCH implicitConvTo(Type *to); + Expression *defaultInit(Loc loc); + int builtinTypeInfo(); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); +}; + +struct TypeAArray : TypeArray +{ + Type *index; // key type + Loc loc; + Scope *sc; + + StructDeclaration *impl; // implementation + + TypeAArray(Type *t, Type *index); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + Type *semantic(Loc loc, Scope *sc); + StructDeclaration *getImpl(); + void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *defaultInit(Loc loc); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + int isZeroInit(Loc loc); + int checkBoolean(); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + // Back end + Symbol *aaGetSymbol(const char *func, int flags); + + type *toCtype(); +}; + +struct TypePointer : TypeNext +{ + TypePointer(Type *t); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + d_uns64 size(Loc loc); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); + int isscalar(); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); +}; + +struct TypeReference : TypeNext +{ + TypeReference(Type *t); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + d_uns64 size(Loc loc); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif +}; + +enum RET +{ + RETregs = 1, // returned in registers + RETstack = 2, // returned on stack +}; + +enum TRUST +{ + TRUSTdefault = 0, + TRUSTsystem = 1, // @system (same as TRUSTdefault) + TRUSTtrusted = 2, // @trusted + TRUSTsafe = 3, // @safe +}; + +enum PURE +{ + PUREimpure = 0, // not pure at all + PUREweak = 1, // no mutable globals are read or written + PUREconst = 2, // parameters are values or const + PUREstrong = 3, // parameters are values or immutable + PUREfwdref = 4, // it's pure, but not known which level yet +}; + +struct TypeFunction : TypeNext +{ + // .next is the return type + + Parameters *parameters; // function parameters + int varargs; // 1: T t, ...) style for variable number of arguments + // 2: T t ...) style for variable number of arguments + bool isnothrow; // true: nothrow + bool isproperty; // can be called without parentheses + bool isref; // true: returns a reference + enum LINK linkage; // calling convention + enum TRUST trust; // level of trust + enum PURE purity; // PURExxxx + Expressions *fargs; // function arguments + + int inuse; + + TypeFunction(Parameters *parameters, Type *treturn, int varargs, enum LINK linkage, StorageClass stc = 0); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + void purityLevel(); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); + void toCBufferWithAttributes(OutBuffer *buf, Identifier *ident, HdrGenState* hgs, TypeFunction *attrs, TemplateDeclaration *td); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void attributesToCBuffer(OutBuffer *buf, int mod); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + Type *reliesOnTident(); + bool hasLazyParameters(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + bool parameterEscapes(Parameter *p); + + int callMatch(Expression *ethis, Expressions *toargs, int flag = 0); + type *toCtype(); + enum RET retStyle(); + + unsigned totym(); + + Expression *defaultInit(Loc loc); +}; + +struct TypeDelegate : TypeNext +{ + // .next is a TypeFunction + + TypeDelegate(Type *t); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + d_uns64 size(Loc loc); + unsigned alignsize(); + MATCH implicitConvTo(Type *to); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); + int checkBoolean(); + TypeInfoDeclaration *getTypeInfoDeclaration(); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + int hasPointers(); + TypeTuple *toArgTypes(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); +}; + +struct TypeQualified : Type +{ + Loc loc; + Identifiers idents; // array of Identifier's representing ident.ident.ident etc. + + TypeQualified(TY ty, Loc loc); + void syntaxCopyHelper(TypeQualified *t); + void addIdent(Identifier *ident); + void toCBuffer2Helper(OutBuffer *buf, HdrGenState *hgs); + d_uns64 size(Loc loc); + void resolveHelper(Loc loc, Scope *sc, Dsymbol *s, Dsymbol *scopesym, + Expression **pe, Type **pt, Dsymbol **ps); +}; + +struct TypeIdentifier : TypeQualified +{ + Identifier *ident; + + TypeIdentifier(Loc loc, Identifier *ident); + Type *syntaxCopy(); + //char *toChars(); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + Dsymbol *toDsymbol(Scope *sc); + Type *semantic(Loc loc, Scope *sc); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + Type *reliesOnTident(); + Expression *toExpression(); +}; + +/* Similar to TypeIdentifier, but with a TemplateInstance as the root + */ +struct TypeInstance : TypeQualified +{ + TemplateInstance *tempinst; + + TypeInstance(Loc loc, TemplateInstance *tempinst); + Type *syntaxCopy(); + //char *toChars(); + //void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + Type *semantic(Loc loc, Scope *sc); + Dsymbol *toDsymbol(Scope *sc); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); +}; + +struct TypeTypeof : TypeQualified +{ + Expression *exp; + int inuse; + + TypeTypeof(Loc loc, Expression *exp); + Type *syntaxCopy(); + Dsymbol *toDsymbol(Scope *sc); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Type *semantic(Loc loc, Scope *sc); + d_uns64 size(Loc loc); +}; + +struct TypeReturn : TypeQualified +{ + TypeReturn(Loc loc); + Type *syntaxCopy(); + Dsymbol *toDsymbol(Scope *sc); + Type *semantic(Loc loc, Scope *sc); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); +}; + +struct TypeStruct : Type +{ + StructDeclaration *sym; + + TypeStruct(StructDeclaration *sym); + d_uns64 size(Loc loc); + unsigned alignsize(); + char *toChars(); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + Dsymbol *toDsymbol(Scope *sc); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + unsigned memalign(unsigned salign); + Expression *defaultInit(Loc loc); + Expression *defaultInitLiteral(Loc loc); + int isZeroInit(Loc loc); + int isAssignable(); + int checkBoolean(); + int needsDestruction(); + dt_t **toDt(dt_t **pdt); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); + unsigned wildConvTo(Type *tprm); + Type *toHeadMutable(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); +}; + +struct TypeEnum : Type +{ + EnumDeclaration *sym; + + TypeEnum(EnumDeclaration *sym); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + unsigned alignsize(); + char *toChars(); + Type *semantic(Loc loc, Scope *sc); + Dsymbol *toDsymbol(Scope *sc); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *getProperty(Loc loc, Identifier *ident); + int isintegral(); + int isfloating(); + int isreal(); + int isimaginary(); + int iscomplex(); + int isscalar(); + int isunsigned(); + int checkBoolean(); + int isAssignable(); + int needsDestruction(); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); + Type *toBasetype(); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); +}; + +struct TypeTypedef : Type +{ + TypedefDeclaration *sym; + + TypeTypedef(TypedefDeclaration *sym); + Type *syntaxCopy(); + d_uns64 size(Loc loc); + unsigned alignsize(); + char *toChars(); + Type *semantic(Loc loc, Scope *sc); + Dsymbol *toDsymbol(Scope *sc); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *getProperty(Loc loc, Identifier *ident); + int isintegral(); + int isfloating(); + int isreal(); + int isimaginary(); + int iscomplex(); + int isscalar(); + int isunsigned(); + int checkBoolean(); + int isAssignable(); + int needsDestruction(); + Type *toBasetype(); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); + Type *toHeadMutable(); + Expression *defaultInit(Loc loc); + Expression *defaultInitLiteral(Loc loc); + int isZeroInit(Loc loc); + dt_t **toDt(dt_t **pdt); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); + int hasWild(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); + type *toCParamtype(); +}; + +struct TypeClass : Type +{ + ClassDeclaration *sym; + + TypeClass(ClassDeclaration *sym); + d_uns64 size(Loc loc); + char *toChars(); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + Dsymbol *toDsymbol(Scope *sc); + void toDecoBuffer(OutBuffer *buf, int flag); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + ClassDeclaration *isClassHandle(); + int isBaseOf(Type *t, int *poffset); + MATCH implicitConvTo(Type *to); + MATCH constConv(Type *to); + unsigned wildConvTo(Type *tprm); + Type *toHeadMutable(); + Expression *defaultInit(Loc loc); + int isZeroInit(Loc loc); + MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch = NULL); + int isscope(); + int checkBoolean(); + TypeInfoDeclaration *getTypeInfoDeclaration(); + int hasPointers(); + TypeTuple *toArgTypes(); + int builtinTypeInfo(); +#if CPP_MANGLE + void toCppMangle(OutBuffer *buf, CppMangleState *cms); +#endif + + type *toCtype(); + + Symbol *toSymbol(); +}; + +struct TypeTuple : Type +{ + Parameters *arguments; // types making up the tuple + + TypeTuple(Parameters *arguments); + TypeTuple(Expressions *exps); + TypeTuple(); + TypeTuple(Type *t1); + TypeTuple(Type *t1, Type *t2); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + int equals(Object *o); + Type *reliesOnTident(); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); + void toDecoBuffer(OutBuffer *buf, int flag); + Expression *getProperty(Loc loc, Identifier *ident); + TypeInfoDeclaration *getTypeInfoDeclaration(); +}; + +struct TypeSlice : TypeNext +{ + Expression *lwr; + Expression *upr; + + TypeSlice(Type *next, Expression *lwr, Expression *upr); + Type *syntaxCopy(); + Type *semantic(Loc loc, Scope *sc); + void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); + void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); +}; + +struct TypeNull : Type +{ + TypeNull(); + + Type *syntaxCopy(); + void toDecoBuffer(OutBuffer *buf, int flag); + MATCH implicitConvTo(Type *to); + + void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); + + d_uns64 size(Loc loc); + //Expression *getProperty(Loc loc, Identifier *ident); + //Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); + Expression *defaultInit(Loc loc); + //Expression *defaultInitLiteral(Loc loc); +}; + +/**************************************************************/ + +//enum InOut { None, In, Out, InOut, Lazy }; + +struct Parameter : Object +{ + //enum InOut inout; + StorageClass storageClass; + Type *type; + Identifier *ident; + Expression *defaultArg; + + Parameter(StorageClass storageClass, Type *type, Identifier *ident, Expression *defaultArg); + Parameter *syntaxCopy(); + Type *isLazyArray(); + void toDecoBuffer(OutBuffer *buf); + static Parameters *arraySyntaxCopy(Parameters *args); + static char *argsTypesToChars(Parameters *args, int varargs); + static void argsCppMangle(OutBuffer *buf, CppMangleState *cms, Parameters *arguments, int varargs); + static void argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Parameters *arguments, int varargs); + static void argsToDecoBuffer(OutBuffer *buf, Parameters *arguments); + static int isTPL(Parameters *arguments); + static size_t dim(Parameters *arguments); + static Parameter *getNth(Parameters *arguments, size_t nth, size_t *pn = NULL); + + typedef int (*ForeachDg)(void *ctx, size_t paramidx, Parameter *param); + static int foreach(Parameters *args, ForeachDg dg, void *ctx, size_t *pn=NULL); +}; + +extern int PTRSIZE; +extern int REALSIZE; +extern int REALPAD; +extern int Tsize_t; +extern int Tptrdiff_t; + +int arrayTypeCompatible(Loc loc, Type *t1, Type *t2); +int arrayTypeCompatibleWithoutCasting(Loc loc, Type *t1, Type *t2); +void MODtoBuffer(OutBuffer *buf, unsigned char mod); +int MODimplicitConv(unsigned char modfrom, unsigned char modto); +int MODmethodConv(unsigned char modfrom, unsigned char modto); +int MODmerge(unsigned char mod1, unsigned char mod2); + +#endif /* DMD_MTYPE_H */ diff --git a/objfile.h b/objfile.h new file mode 100644 index 00000000..a872f4d0 --- /dev/null +++ b/objfile.h @@ -0,0 +1,61 @@ + + +#ifndef OBJFILE_H +#define OBJFILE_H + +#include "root.h" + +typedef void *SymHandle; +typedef unsigned SegOffset; + +enum ObjFormat +{ + NTCOFF, + ELF +}; + +struct ObjFile : File +{ + ObjFile(FileName *); + ~ObjFile(); + + ObjFile *init(ObjFormat); + + void comment(const char *); // insert comment into object file + void modulename(const char *); // set module name + void library(const char *); // add default library + void startaddress(SegHandle seg, SegOffset offset); // set start address + + // Segments + enum SegHandle + { code = 1, + data, bss + }; + + SymHandle defineSym(const char *name, SegHandle seg, SegOffset offset); + SymHandle externSym(const char *name); + + SegOffset write(SegHandle seg, const void *data, unsigned nbytes); + SegOffset writestring(SegHandle seg, char *string); + SegOffset write8(SegHandle seg, unsigned b); + SegOffset write16(SegHandle seg, unsigned w); + SegOffset write32(SegHandle seg, unsigned long v); + SegOffset write64(SegHandle seg, unsigned long long v); + SegOffset fill0(SegHandle seg, unsigned nbytes); + SegOffset align(SegHandle seg, unsigned size); + SegOffset writefixup(SegHandle seg, SymHandle sym, unsigned value, int selfrelative); + + // Non-binding hint as to how big seg will grow + void reserve(SegHandle seg, SegOffset size); + + // Set actual size + void setSize(SegHandle seg, SegOffset size); + + // Get/set offset for subsequent writes + void setOffset(SegHandle seg, SegOffset offset); + SegOffset getOffset(SegHandle seg); + + SegHandle createSeg(const char *name); +}; + +#endif diff --git a/opover.c b/opover.c new file mode 100644 index 00000000..786fac06 --- /dev/null +++ b/opover.c @@ -0,0 +1,1611 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#if _MSC_VER +#include +#else +#include +#endif + +#ifdef __APPLE__ +#define integer_t dmd_integer_t +#endif + +#include "rmem.h" + +//#include "port.h" +#include "mtype.h" +#include "init.h" +#include "expression.h" +#include "statement.h" +#include "scope.h" +#include "id.h" +#include "declaration.h" +#include "aggregate.h" +#include "template.h" + +static Dsymbol *inferApplyArgTypesX(Expression *ethis, FuncDeclaration *fstart, Parameters *arguments); +static void inferApplyArgTypesZ(TemplateDeclaration *tstart, Parameters *arguments); +static int inferApplyArgTypesY(TypeFunction *tf, Parameters *arguments, int flags = 0); +static void templateResolve(Match *m, TemplateDeclaration *td, Scope *sc, Loc loc, Objects *targsi, Expression *ethis, Expressions *arguments); + +/******************************** Expression **************************/ + + +/*********************************** + * Determine if operands of binary op can be reversed + * to fit operator overload. + */ + +int Expression::isCommutative() +{ + return FALSE; // default is no reverse +} + +/*********************************** + * Get Identifier for operator overload. + */ + +Identifier *Expression::opId() +{ + assert(0); + return NULL; +} + +/*********************************** + * Get Identifier for reverse operator overload, + * NULL if not supported for this operator. + */ + +Identifier *Expression::opId_r() +{ + return NULL; +} + +/************************* Operators *****************************/ + +Identifier *UAddExp::opId() { return Id::uadd; } + +Identifier *NegExp::opId() { return Id::neg; } + +Identifier *ComExp::opId() { return Id::com; } + +Identifier *CastExp::opId() { return Id::cast; } + +Identifier *InExp::opId() { return Id::opIn; } +Identifier *InExp::opId_r() { return Id::opIn_r; } + +Identifier *PostExp::opId() { return (op == TOKplusplus) + ? Id::postinc + : Id::postdec; } + +int AddExp::isCommutative() { return TRUE; } +Identifier *AddExp::opId() { return Id::add; } +Identifier *AddExp::opId_r() { return Id::add_r; } + +Identifier *MinExp::opId() { return Id::sub; } +Identifier *MinExp::opId_r() { return Id::sub_r; } + +int MulExp::isCommutative() { return TRUE; } +Identifier *MulExp::opId() { return Id::mul; } +Identifier *MulExp::opId_r() { return Id::mul_r; } + +Identifier *DivExp::opId() { return Id::div; } +Identifier *DivExp::opId_r() { return Id::div_r; } + +Identifier *ModExp::opId() { return Id::mod; } +Identifier *ModExp::opId_r() { return Id::mod_r; } + +#if DMDV2 +Identifier *PowExp::opId() { return Id::pow; } +Identifier *PowExp::opId_r() { return Id::pow_r; } +#endif + +Identifier *ShlExp::opId() { return Id::shl; } +Identifier *ShlExp::opId_r() { return Id::shl_r; } + +Identifier *ShrExp::opId() { return Id::shr; } +Identifier *ShrExp::opId_r() { return Id::shr_r; } + +Identifier *UshrExp::opId() { return Id::ushr; } +Identifier *UshrExp::opId_r() { return Id::ushr_r; } + +int AndExp::isCommutative() { return TRUE; } +Identifier *AndExp::opId() { return Id::iand; } +Identifier *AndExp::opId_r() { return Id::iand_r; } + +int OrExp::isCommutative() { return TRUE; } +Identifier *OrExp::opId() { return Id::ior; } +Identifier *OrExp::opId_r() { return Id::ior_r; } + +int XorExp::isCommutative() { return TRUE; } +Identifier *XorExp::opId() { return Id::ixor; } +Identifier *XorExp::opId_r() { return Id::ixor_r; } + +Identifier *CatExp::opId() { return Id::cat; } +Identifier *CatExp::opId_r() { return Id::cat_r; } + +Identifier * AssignExp::opId() { return Id::assign; } +Identifier * AddAssignExp::opId() { return Id::addass; } +Identifier * MinAssignExp::opId() { return Id::subass; } +Identifier * MulAssignExp::opId() { return Id::mulass; } +Identifier * DivAssignExp::opId() { return Id::divass; } +Identifier * ModAssignExp::opId() { return Id::modass; } +Identifier * AndAssignExp::opId() { return Id::andass; } +Identifier * OrAssignExp::opId() { return Id::orass; } +Identifier * XorAssignExp::opId() { return Id::xorass; } +Identifier * ShlAssignExp::opId() { return Id::shlass; } +Identifier * ShrAssignExp::opId() { return Id::shrass; } +Identifier *UshrAssignExp::opId() { return Id::ushrass; } +Identifier * CatAssignExp::opId() { return Id::catass; } +Identifier * PowAssignExp::opId() { return Id::powass; } + +int EqualExp::isCommutative() { return TRUE; } +Identifier *EqualExp::opId() { return Id::eq; } + +int CmpExp::isCommutative() { return TRUE; } +Identifier *CmpExp::opId() { return Id::cmp; } + +Identifier *ArrayExp::opId() { return Id::index; } +Identifier *PtrExp::opId() { return Id::opStar; } + +/************************************ + * If type is a class or struct, return the symbol for it, + * else NULL + */ +AggregateDeclaration *isAggregate(Type *t) +{ + t = t->toBasetype(); + if (t->ty == Tclass) + { + return ((TypeClass *)t)->sym; + } + else if (t->ty == Tstruct) + { + return ((TypeStruct *)t)->sym; + } + return NULL; +} + +/******************************************* + * Helper function to turn operator into template argument list + */ +Objects *opToArg(Scope *sc, enum TOK op) +{ + /* Remove the = from op= + */ + switch (op) + { + case TOKaddass: op = TOKadd; break; + case TOKminass: op = TOKmin; break; + case TOKmulass: op = TOKmul; break; + case TOKdivass: op = TOKdiv; break; + case TOKmodass: op = TOKmod; break; + case TOKandass: op = TOKand; break; + case TOKorass: op = TOKor; break; + case TOKxorass: op = TOKxor; break; + case TOKshlass: op = TOKshl; break; + case TOKshrass: op = TOKshr; break; + case TOKushrass: op = TOKushr; break; + case TOKcatass: op = TOKcat; break; + case TOKpowass: op = TOKpow; break; + } + Expression *e = new StringExp(0, (char *)Token::toChars(op)); + e = e->semantic(sc); + Objects *targsi = new Objects(); + targsi->push(e); + return targsi; +} + +/************************************ + * Operator overload. + * Check for operator overload, if so, replace + * with function call. + * Return NULL if not an operator overload. + */ + +Expression *UnaExp::op_overload(Scope *sc) +{ + //printf("UnaExp::op_overload() (%s)\n", toChars()); + +#if DMDV2 + if (e1->op == TOKarray) + { + ArrayExp *ae = (ArrayExp *)e1; + ae->e1 = ae->e1->semantic(sc); + ae->e1 = resolveProperties(sc, ae->e1); + + AggregateDeclaration *ad = isAggregate(ae->e1->type); + if (ad) + { + /* Rewrite as: + * a.opIndexUnary!("+")(args); + */ + Dsymbol *fd = search_function(ad, Id::opIndexUnary); + if (fd) + { + Objects *targsi = opToArg(sc, op); + Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi); + e = new CallExp(loc, e, ae->arguments); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite op(a[arguments]) as: + * op(a.aliasthis[arguments]) + */ + Expression *e1 = ae->copy(); + ((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + } + else if (e1->op == TOKslice) + { + SliceExp *se = (SliceExp *)e1; + se->e1 = se->e1->semantic(sc); + se->e1 = resolveProperties(sc, se->e1); + + AggregateDeclaration *ad = isAggregate(se->e1->type); + if (ad) + { + /* Rewrite as: + * a.opSliceUnary!("+")(lwr, upr); + */ + Dsymbol *fd = search_function(ad, Id::opSliceUnary); + if (fd) + { + Expressions *a = new Expressions(); + if (se->lwr) + { a->push(se->lwr); + a->push(se->upr); + } + + Objects *targsi = opToArg(sc, op); + Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi); + e = new CallExp(loc, e, a); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite op(a[lwr..upr]) as: + * op(a.aliasthis[lwr..upr]) + */ + Expression *e1 = se->copy(); + ((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + } +#endif + + e1 = e1->semantic(sc); + e1 = resolveProperties(sc, e1); + + AggregateDeclaration *ad = isAggregate(e1->type); + if (ad) + { + Dsymbol *fd = NULL; +#if 1 // Old way, kept for compatibility with D1 + if (op != TOKpreplusplus && op != TOKpreminusminus) + { fd = search_function(ad, opId()); + if (fd) + { + if (op == TOKarray) + { + /* Rewrite op e1[arguments] as: + * e1.fd(arguments) + */ + Expression *e = new DotIdExp(loc, e1, fd->ident); + ArrayExp *ae = (ArrayExp *)this; + e = new CallExp(loc, e, ae->arguments); + e = e->semantic(sc); + return e; + } + else + { + // Rewrite +e1 as e1.add() + return build_overload(loc, sc, e1, NULL, fd); + } + } + } +#endif + +#if DMDV2 + /* Rewrite as: + * e1.opUnary!("+")(); + */ + fd = search_function(ad, Id::opUnary); + if (fd) + { + Objects *targsi = opToArg(sc, op); + Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi); + e = new CallExp(loc, e); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite op(e1) as: + * op(e1.aliasthis) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } +#endif + } + return NULL; +} + +Expression *ArrayExp::op_overload(Scope *sc) +{ + //printf("ArrayExp::op_overload() (%s)\n", toChars()); + AggregateDeclaration *ad = isAggregate(e1->type); + if (ad) + { + Dsymbol *fd = search_function(ad, opId()); + if (fd) + { + for (size_t i = 0; i < arguments->dim; i++) + { Expression *x = arguments->tdata()[i]; + // Create scope for '$' variable for this dimension + ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, this); + sym->loc = loc; + sym->parent = sc->scopesym; + sc = sc->push(sym); + lengthVar = NULL; // Create it only if required + currentDimension = i; // Dimension for $, if required + + x = x->semantic(sc); + x = resolveProperties(sc, x); + if (!x->type) + error("%s has no value", x->toChars()); + if (lengthVar) + { // If $ was used, declare it now + Expression *av = new DeclarationExp(loc, lengthVar); + x = new CommaExp(0, av, x); + x->semantic(sc); + } + arguments->tdata()[i] = x; + sc = sc->pop(); + } + + /* Rewrite op e1[arguments] as: + * e1.opIndex(arguments) + */ + Expression *e = new DotIdExp(loc, e1, fd->ident); + e = new CallExp(loc, e, arguments); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite op(e1) as: + * op(e1.aliasthis) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + return NULL; +} + +/*********************************************** + * This is mostly the same as UnaryExp::op_overload(), but has + * a different rewrite. + */ +Expression *CastExp::op_overload(Scope *sc) +{ + //printf("CastExp::op_overload() (%s)\n", toChars()); + AggregateDeclaration *ad = isAggregate(e1->type); + if (ad) + { + Dsymbol *fd = NULL; + /* Rewrite as: + * e1.opCast!(T)(); + */ + fd = search_function(ad, Id::cast); + if (fd) + { +#if 1 // Backwards compatibility with D1 if opCast is a function, not a template + if (fd->isFuncDeclaration()) + { // Rewrite as: e1.opCast() + return build_overload(loc, sc, e1, NULL, fd); + } +#endif + Objects *targsi = new Objects(); + targsi->push(to); + Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi); + e = new CallExp(loc, e); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite op(e1) as: + * op(e1.aliasthis) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + return NULL; +} + +Expression *BinExp::op_overload(Scope *sc) +{ + //printf("BinExp::op_overload() (%s)\n", toChars()); + + Identifier *id = opId(); + Identifier *id_r = opId_r(); + + Expressions args1; + Expressions args2; + int argsset = 0; + + AggregateDeclaration *ad1 = isAggregate(e1->type); + AggregateDeclaration *ad2 = isAggregate(e2->type); + + Dsymbol *s = NULL; + Dsymbol *s_r = NULL; + +#if 1 // the old D1 scheme + if (ad1 && id) + { + s = search_function(ad1, id); + } + if (ad2 && id_r) + { + s_r = search_function(ad2, id_r); + } +#endif + + Objects *targsi = NULL; +#if DMDV2 + if (op == TOKplusplus || op == TOKminusminus) + { // Bug4099 fix + if (ad1 && search_function(ad1, Id::opUnary)) + return NULL; + } + if (!s && !s_r && op != TOKequal && op != TOKnotequal && op != TOKassign && + op != TOKplusplus && op != TOKminusminus) + { + /* Try the new D2 scheme, opBinary and opBinaryRight + */ + if (ad1) + s = search_function(ad1, Id::opBinary); + if (ad2) + s_r = search_function(ad2, Id::opBinaryRight); + + // Set targsi, the template argument list, which will be the operator string + if (s || s_r) + { + id = Id::opBinary; + id_r = Id::opBinaryRight; + targsi = opToArg(sc, op); + } + } +#endif + + if (s || s_r) + { + /* Try: + * a.opfunc(b) + * b.opfunc_r(a) + * and see which is better. + */ + + args1.setDim(1); + args1.tdata()[0] = e1; + args2.setDim(1); + args2.tdata()[0] = e2; + argsset = 1; + + Match m; + memset(&m, 0, sizeof(m)); + m.last = MATCHnomatch; + + if (s) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args2); + } + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, e1, &args2); + } + } + + FuncDeclaration *lastf = m.lastf; + + if (s_r) + { + FuncDeclaration *fd = s_r->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args1); + } + else + { TemplateDeclaration *td = s_r->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, e2, &args1); + } + } + + if (m.count > 1) + { + // Error, ambiguous + error("overloads %s and %s both match argument list for %s", + m.lastf->type->toChars(), + m.nextf->type->toChars(), + m.lastf->toChars()); + } + else if (m.last == MATCHnomatch) + { + m.lastf = m.anyf; + if (targsi) + goto L1; + } + + Expression *e; + if (op == TOKplusplus || op == TOKminusminus) + // Kludge because operator overloading regards e++ and e-- + // as unary, but it's implemented as a binary. + // Rewrite (e1 ++ e2) as e1.postinc() + // Rewrite (e1 -- e2) as e1.postdec() + e = build_overload(loc, sc, e1, NULL, m.lastf ? m.lastf : s); + else if (lastf && m.lastf == lastf || !s_r && m.last == MATCHnomatch) + // Rewrite (e1 op e2) as e1.opfunc(e2) + e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s); + else + // Rewrite (e1 op e2) as e2.opfunc_r(e1) + e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s_r); + return e; + } + +L1: +#if 1 // Retained for D1 compatibility + if (isCommutative() && !targsi) + { + s = NULL; + s_r = NULL; + if (ad1 && id_r) + { + s_r = search_function(ad1, id_r); + } + if (ad2 && id) + { + s = search_function(ad2, id); + } + + if (s || s_r) + { + /* Try: + * a.opfunc_r(b) + * b.opfunc(a) + * and see which is better. + */ + + if (!argsset) + { args1.setDim(1); + args1.tdata()[0] = e1; + args2.setDim(1); + args2.tdata()[0] = e2; + } + + Match m; + memset(&m, 0, sizeof(m)); + m.last = MATCHnomatch; + + if (s_r) + { + FuncDeclaration *fd = s_r->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args2); + } + else + { TemplateDeclaration *td = s_r->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, e1, &args2); + } + } + FuncDeclaration *lastf = m.lastf; + + if (s) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args1); + } + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, e2, &args1); + } + } + + if (m.count > 1) + { + // Error, ambiguous + error("overloads %s and %s both match argument list for %s", + m.lastf->type->toChars(), + m.nextf->type->toChars(), + m.lastf->toChars()); + } + else if (m.last == MATCHnomatch) + { + m.lastf = m.anyf; + } + + Expression *e; + if (lastf && m.lastf == lastf || !s && m.last == MATCHnomatch) + // Rewrite (e1 op e2) as e1.opfunc_r(e2) + e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s_r); + else + // Rewrite (e1 op e2) as e2.opfunc(e1) + e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s); + + // When reversing operands of comparison operators, + // need to reverse the sense of the op + switch (op) + { + case TOKlt: op = TOKgt; break; + case TOKgt: op = TOKlt; break; + case TOKle: op = TOKge; break; + case TOKge: op = TOKle; break; + + // Floating point compares + case TOKule: op = TOKuge; break; + case TOKul: op = TOKug; break; + case TOKuge: op = TOKule; break; + case TOKug: op = TOKul; break; + + // These are symmetric + case TOKunord: + case TOKlg: + case TOKleg: + case TOKue: + break; + } + + return e; + } + } +#endif + +#if DMDV2 + // Try alias this on first operand + if (ad1 && ad1->aliasthis && + !(op == TOKassign && ad2 && ad1 == ad2)) // See Bugzilla 2943 + { + /* Rewrite (e1 op e2) as: + * (e1.aliasthis op e2) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + + // Try alias this on second operand + if (ad2 && ad2->aliasthis && + /* Bugzilla 2943: make sure that when we're copying the struct, we don't + * just copy the alias this member + */ + !(op == TOKassign && ad1 && ad1 == ad2)) + { + /* Rewrite (e1 op e2) as: + * (e1 op e2.aliasthis) + */ + Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e2 = e2; + e = e->trySemantic(sc); + return e; + } +#endif + return NULL; +} + +/****************************************** + * Common code for overloading of EqualExp and CmpExp + */ +Expression *BinExp::compare_overload(Scope *sc, Identifier *id) +{ + //printf("BinExp::compare_overload(id = %s) %s\n", id->toChars(), toChars()); + + AggregateDeclaration *ad1 = isAggregate(e1->type); + AggregateDeclaration *ad2 = isAggregate(e2->type); + + Dsymbol *s = NULL; + Dsymbol *s_r = NULL; + + if (ad1) + { + s = search_function(ad1, id); + } + if (ad2) + { + s_r = search_function(ad2, id); + if (s == s_r) + s_r = NULL; + } + + Objects *targsi = NULL; + + if (s || s_r) + { + /* Try: + * a.opEquals(b) + * b.opEquals(a) + * and see which is better. + */ + + Expressions args1; + Expressions args2; + + args1.setDim(1); + args1.tdata()[0] = e1; + args2.setDim(1); + args2.tdata()[0] = e2; + + Match m; + memset(&m, 0, sizeof(m)); + m.last = MATCHnomatch; + + if (0 && s && s_r) + { + printf("s : %s\n", s->toPrettyChars()); + printf("s_r: %s\n", s_r->toPrettyChars()); + } + + if (s) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args2); + } + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, NULL, &args2); + } + } + + FuncDeclaration *lastf = m.lastf; + int count = m.count; + + if (s_r) + { + FuncDeclaration *fd = s_r->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args1); + } + else + { TemplateDeclaration *td = s_r->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, NULL, &args1); + } + } + + if (m.count > 1) + { + /* The following if says "not ambiguous" if there's one match + * from s and one from s_r, in which case we pick s. + * This doesn't follow the spec, but is a workaround for the case + * where opEquals was generated from templates and we cannot figure + * out if both s and s_r came from the same declaration or not. + * The test case is: + * import std.typecons; + * void main() { + * assert(tuple("has a", 2u) == tuple("has a", 1)); + * } + */ + if (!(m.lastf == lastf && m.count == 2 && count == 1)) + { + // Error, ambiguous + error("overloads %s and %s both match argument list for %s", + m.lastf->type->toChars(), + m.nextf->type->toChars(), + m.lastf->toChars()); + } + } + else if (m.last == MATCHnomatch) + { + m.lastf = m.anyf; + } + + Expression *e; + if (lastf && m.lastf == lastf || !s_r && m.last == MATCHnomatch) + // Rewrite (e1 op e2) as e1.opfunc(e2) + e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s); + else + { // Rewrite (e1 op e2) as e2.opfunc_r(e1) + e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s_r); + + // When reversing operands of comparison operators, + // need to reverse the sense of the op + switch (op) + { + case TOKlt: op = TOKgt; break; + case TOKgt: op = TOKlt; break; + case TOKle: op = TOKge; break; + case TOKge: op = TOKle; break; + + // Floating point compares + case TOKule: op = TOKuge; break; + case TOKul: op = TOKug; break; + case TOKuge: op = TOKule; break; + case TOKug: op = TOKul; break; + + // The rest are symmetric + default: + break; + } + } + + return e; + } + + // Try alias this on first operand + if (ad1 && ad1->aliasthis) + { + /* Rewrite (e1 op e2) as: + * (e1.aliasthis op e2) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + + // Try alias this on second operand + if (ad2 && ad2->aliasthis) + { + /* Rewrite (e1 op e2) as: + * (e1 op e2.aliasthis) + */ + Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e2 = e2; + e = e->trySemantic(sc); + return e; + } + + return NULL; +} + +Expression *EqualExp::op_overload(Scope *sc) +{ + //printf("EqualExp::op_overload() (%s)\n", toChars()); + + Type *t1 = e1->type->toBasetype(); + Type *t2 = e2->type->toBasetype(); + if (t1->ty == Tclass && t2->ty == Tclass) + { ClassDeclaration *cd1 = t1->isClassHandle(); + ClassDeclaration *cd2 = t2->isClassHandle(); + + if (!(cd1->isCPPinterface() || cd2->isCPPinterface())) + { + /* Rewrite as: + * .object.opEquals(cast(Object)e1, cast(Object)e2) + * The explicit cast is necessary for interfaces, + * see http://d.puremagic.com/issues/show_bug.cgi?id=4088 + */ + Expression *e1x = new CastExp(loc, e1, ClassDeclaration::object->getType()); + Expression *e2x = new CastExp(loc, e2, ClassDeclaration::object->getType()); + + Expression *e = new IdentifierExp(loc, Id::empty); + e = new DotIdExp(loc, e, Id::object); + e = new DotIdExp(loc, e, Id::eq); + e = new CallExp(loc, e, e1x, e2x); + e = e->semantic(sc); + return e; + } + } + + return compare_overload(sc, Id::eq); +} + +Expression *CmpExp::op_overload(Scope *sc) +{ + //printf("CmpExp::op_overload() (%s)\n", toChars()); + + return compare_overload(sc, Id::cmp); +} + +/********************************* + * Operator overloading for op= + */ +Expression *BinAssignExp::op_overload(Scope *sc) +{ + //printf("BinAssignExp::op_overload() (%s)\n", toChars()); + +#if DMDV2 + if (e1->op == TOKarray) + { + ArrayExp *ae = (ArrayExp *)e1; + ae->e1 = ae->e1->semantic(sc); + ae->e1 = resolveProperties(sc, ae->e1); + + AggregateDeclaration *ad = isAggregate(ae->e1->type); + if (ad) + { + /* Rewrite a[args]+=e2 as: + * a.opIndexOpAssign!("+")(e2, args); + */ + Dsymbol *fd = search_function(ad, Id::opIndexOpAssign); + if (fd) + { + Expressions *a = new Expressions(); + a->push(e2); + for (size_t i = 0; i < ae->arguments->dim; i++) + a->push(ae->arguments->tdata()[i]); + + Objects *targsi = opToArg(sc, op); + Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi); + e = new CallExp(loc, e, a); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite a[arguments] op= e2 as: + * a.aliasthis[arguments] op= e2 + */ + Expression *e1 = ae->copy(); + ((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + } + else if (e1->op == TOKslice) + { + SliceExp *se = (SliceExp *)e1; + se->e1 = se->e1->semantic(sc); + se->e1 = resolveProperties(sc, se->e1); + + AggregateDeclaration *ad = isAggregate(se->e1->type); + if (ad) + { + /* Rewrite a[lwr..upr]+=e2 as: + * a.opSliceOpAssign!("+")(e2, lwr, upr); + */ + Dsymbol *fd = search_function(ad, Id::opSliceOpAssign); + if (fd) + { + Expressions *a = new Expressions(); + a->push(e2); + if (se->lwr) + { a->push(se->lwr); + a->push(se->upr); + } + + Objects *targsi = opToArg(sc, op); + Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi); + e = new CallExp(loc, e, a); + e = e->semantic(sc); + return e; + } + + // Didn't find it. Forward to aliasthis + if (ad->aliasthis) + { + /* Rewrite a[lwr..upr] op= e2 as: + * a.aliasthis[lwr..upr] op= e2 + */ + Expression *e1 = se->copy(); + ((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident); + Expression *e = copy(); + ((UnaExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + } + } +#endif + + BinExp::semantic(sc); + e1 = resolveProperties(sc, e1); + e2 = resolveProperties(sc, e2); + + Identifier *id = opId(); + + Expressions args2; + + AggregateDeclaration *ad1 = isAggregate(e1->type); + + Dsymbol *s = NULL; + +#if 1 // the old D1 scheme + if (ad1 && id) + { + s = search_function(ad1, id); + } +#endif + + Objects *targsi = NULL; +#if DMDV2 + if (!s) + { /* Try the new D2 scheme, opOpAssign + */ + if (ad1) + s = search_function(ad1, Id::opOpAssign); + + // Set targsi, the template argument list, which will be the operator string + if (s) + { + id = Id::opOpAssign; + targsi = opToArg(sc, op); + } + } +#endif + + if (s) + { + /* Try: + * a.opOpAssign(b) + */ + + args2.setDim(1); + args2.tdata()[0] = e2; + + Match m; + memset(&m, 0, sizeof(m)); + m.last = MATCHnomatch; + + if (s) + { + FuncDeclaration *fd = s->isFuncDeclaration(); + if (fd) + { + overloadResolveX(&m, fd, NULL, &args2); + } + else + { TemplateDeclaration *td = s->isTemplateDeclaration(); + templateResolve(&m, td, sc, loc, targsi, e1, &args2); + } + } + + if (m.count > 1) + { + // Error, ambiguous + error("overloads %s and %s both match argument list for %s", + m.lastf->type->toChars(), + m.nextf->type->toChars(), + m.lastf->toChars()); + } + else if (m.last == MATCHnomatch) + { + m.lastf = m.anyf; + if (targsi) + goto L1; + } + + // Rewrite (e1 op e2) as e1.opOpAssign(e2) + return build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s); + } + +L1: + +#if DMDV2 + // Try alias this on first operand + if (ad1 && ad1->aliasthis) + { + /* Rewrite (e1 op e2) as: + * (e1.aliasthis op e2) + */ + Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e1 = e1; + e = e->trySemantic(sc); + return e; + } + + // Try alias this on second operand + AggregateDeclaration *ad2 = isAggregate(e2->type); + if (ad2 && ad2->aliasthis) + { + /* Rewrite (e1 op e2) as: + * (e1 op e2.aliasthis) + */ + Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident); + Expression *e = copy(); + ((BinExp *)e)->e2 = e2; + e = e->trySemantic(sc); + return e; + } +#endif + return NULL; +} + +/*********************************** + * Utility to build a function call out of this reference and argument. + */ + +Expression *build_overload(Loc loc, Scope *sc, Expression *ethis, Expression *earg, + Dsymbol *d) +{ + assert(d); + Expression *e; + + //printf("build_overload(id = '%s')\n", id->toChars()); + //earg->print(); + //earg->type->print(); + Declaration *decl = d->isDeclaration(); + if (decl) + e = new DotVarExp(loc, ethis, decl, 0); + else + e = new DotIdExp(loc, ethis, d->ident); + e = new CallExp(loc, e, earg); + + e = e->semantic(sc); + return e; +} + +/*************************************** + * Search for function funcid in aggregate ad. + */ + +Dsymbol *search_function(ScopeDsymbol *ad, Identifier *funcid) +{ + Dsymbol *s; + FuncDeclaration *fd; + TemplateDeclaration *td; + + s = ad->search(0, funcid, 0); + if (s) + { Dsymbol *s2; + + //printf("search_function: s = '%s'\n", s->kind()); + s2 = s->toAlias(); + //printf("search_function: s2 = '%s'\n", s2->kind()); + fd = s2->isFuncDeclaration(); + if (fd && fd->type->ty == Tfunction) + return fd; + + td = s2->isTemplateDeclaration(); + if (td) + return td; + } + return NULL; +} + + +int ForeachStatement::inferAggregate(Scope *sc, Dsymbol *&sapply) +{ + Identifier *idapply = (op == TOKforeach) ? Id::apply : Id::applyReverse; +#if DMDV2 + Identifier *idhead = (op == TOKforeach) ? Id::Ffront : Id::Fback; + int sliced = 0; +#endif + Type *tab; + AggregateDeclaration *ad; + + while (1) + { + aggr = aggr->semantic(sc); + aggr = resolveProperties(sc, aggr); + aggr = aggr->optimize(WANTvalue); + if (!aggr->type) + goto Lerr; + + tab = aggr->type->toBasetype(); + switch (tab->ty) + { + case Tarray: + case Tsarray: + case Ttuple: + case Taarray: + break; + + case Tclass: + ad = ((TypeClass *)tab)->sym; + goto Laggr; + + case Tstruct: + ad = ((TypeStruct *)tab)->sym; + goto Laggr; + + Laggr: +#if DMDV2 + if (!sliced) + { + sapply = search_function(ad, idapply); + if (sapply) + { // opApply aggregate + break; + } + + Dsymbol *s = search_function(ad, Id::slice); + if (s) + { Expression *rinit = new SliceExp(aggr->loc, aggr, NULL, NULL); + rinit = rinit->trySemantic(sc); + if (rinit) // if application of [] succeeded + { aggr = rinit; + sliced = 1; + continue; + } + } + } + + if (Dsymbol *shead = search_function(ad, idhead)) + { // range aggregate + break; + } + + if (ad->aliasthis) + { + aggr = new DotIdExp(aggr->loc, aggr, ad->aliasthis->ident); + continue; + } +#else + sapply = search_function(ad, idapply); + if (sapply) + { // opApply aggregate + break; + } +#endif + goto Lerr; + + case Tdelegate: + if (aggr->op == TOKdelegate) + { DelegateExp *de = (DelegateExp *)aggr; + sapply = de->func->isFuncDeclaration(); + } + break; + + case Terror: + break; + + default: + goto Lerr; + } + break; + } + return 1; + +Lerr: + return 0; +} + +/***************************************** + * Given array of arguments and an aggregate type, + * if any of the argument types are missing, attempt to infer + * them from the aggregate type. + */ + +int ForeachStatement::inferApplyArgTypes(Scope *sc, Dsymbol *&sapply) +{ + if (!arguments || !arguments->dim) + return 0; + + if (sapply) // prefer opApply + { + for (size_t u = 0; u < arguments->dim; u++) + { Parameter *arg = arguments->tdata()[u]; + if (arg->type) + arg->type = arg->type->semantic(loc, sc); + } + + Expression *ethis; + Type *tab = aggr->type->toBasetype(); + if (tab->ty == Tclass || tab->ty == Tstruct) + ethis = aggr; + else + { assert(tab->ty == Tdelegate && aggr->op == TOKdelegate); + ethis = ((DelegateExp *)aggr)->e1; + } + + /* Look for like an + * int opApply(int delegate(ref Type [, ...]) dg); + * overload + */ + FuncDeclaration *fd = sapply->isFuncDeclaration(); + if (fd) + { sapply = inferApplyArgTypesX(ethis, fd, arguments); + } +#if 0 + TemplateDeclaration *td = sapply->isTemplateDeclaration(); + if (td) + { inferApplyArgTypesZ(td, arguments); + } +#endif + return sapply ? 1 : 0; + } + + /* Return if no arguments need types. + */ + for (size_t u = 0; u < arguments->dim; u++) + { Parameter *arg = arguments->tdata()[u]; + if (!arg->type) + break; + } + + AggregateDeclaration *ad; + + Parameter *arg = arguments->tdata()[0]; + Type *taggr = aggr->type; + assert(taggr); + Type *tab = taggr->toBasetype(); + switch (tab->ty) + { + case Tarray: + case Tsarray: + case Ttuple: + if (arguments->dim == 2) + { + if (!arg->type) + arg->type = Type::tsize_t; // key type + arg = arguments->tdata()[1]; + } + if (!arg->type && tab->ty != Ttuple) + arg->type = tab->nextOf(); // value type + break; + + case Taarray: + { TypeAArray *taa = (TypeAArray *)tab; + + if (arguments->dim == 2) + { + if (!arg->type) + arg->type = taa->index; // key type + arg = arguments->tdata()[1]; + } + if (!arg->type) + arg->type = taa->next; // value type + break; + } + + case Tclass: + ad = ((TypeClass *)tab)->sym; + goto Laggr; + + case Tstruct: + ad = ((TypeStruct *)tab)->sym; + goto Laggr; + + Laggr: + if (arguments->dim == 1) + { + if (!arg->type) + { + /* Look for a head() or rear() overload + */ + Identifier *id = (op == TOKforeach) ? Id::Ffront : Id::Fback; + Dsymbol *s = search_function(ad, id); + FuncDeclaration *fd = s ? s->isFuncDeclaration() : NULL; + if (!fd) + { if (s && s->isTemplateDeclaration()) + break; + break; + } + // Resolve inout qualifier of front type + arg->type = fd->type->nextOf(); + if (arg->type) + arg->type = arg->type->substWildTo(tab->mod); + } + break; + } + break; + + case Tdelegate: + { + if (!inferApplyArgTypesY((TypeFunction *)tab->nextOf(), arguments)) + return 0; + break; + } + + default: + break; // ignore error, caught later + } + return 1; +} + +static Dsymbol *inferApplyArgTypesX(Expression *ethis, FuncDeclaration *fstart, Parameters *arguments) +{ + struct Param3 + { + Parameters *arguments; + int mod; + MATCH match; + FuncDeclaration *fd_best; + FuncDeclaration *fd_ambig; + + static int fp(void *param, FuncDeclaration *f) + { + Param3 *p = (Param3 *)param; + TypeFunction *tf = (TypeFunction *)f->type; + MATCH m = MATCHexact; + + if (f->isThis()) + { if (!MODimplicitConv(p->mod, tf->mod)) + m = MATCHnomatch; + else if (p->mod != tf->mod) + m = MATCHconst; + } + if (!inferApplyArgTypesY(tf, p->arguments, 1)) + m = MATCHnomatch; + + if (m > p->match) + { p->fd_best = f; + p->fd_ambig = NULL; + p->match = m; + } + else if (m == p->match) + p->fd_ambig = f; + return 0; + } + }; + + Param3 p; + p.arguments = arguments; + p.mod = ethis->type->mod; + p.match = MATCHnomatch; + p.fd_best = NULL; + p.fd_ambig = NULL; + overloadApply(fstart, &Param3::fp, &p); + if (p.fd_best) + { + inferApplyArgTypesY((TypeFunction *)p.fd_best->type, arguments); + if (p.fd_ambig) + { ::error(ethis->loc, "%s.%s matches more than one declaration:\n\t%s(%d):%s\nand:\n\t%s(%d):%s", + ethis->toChars(), fstart->ident->toChars(), + p.fd_best ->loc.filename, p.fd_best ->loc.linnum, p.fd_best ->type->toChars(), + p.fd_ambig->loc.filename, p.fd_ambig->loc.linnum, p.fd_ambig->type->toChars()); + p.fd_best = NULL; + } + } + return p.fd_best; +} + +/****************************** + * Infer arguments from type of function. + * Returns: + * 1 match for this function + * 0 no match for this function + */ + +static int inferApplyArgTypesY(TypeFunction *tf, Parameters *arguments, int flags) +{ size_t nparams; + Parameter *p; + + if (Parameter::dim(tf->parameters) != 1) + goto Lnomatch; + p = Parameter::getNth(tf->parameters, 0); + if (p->type->ty != Tdelegate) + goto Lnomatch; + tf = (TypeFunction *)p->type->nextOf(); + assert(tf->ty == Tfunction); + + /* We now have tf, the type of the delegate. Match it against + * the arguments, filling in missing argument types. + */ + nparams = Parameter::dim(tf->parameters); + if (nparams == 0 || tf->varargs) + goto Lnomatch; // not enough parameters + if (arguments->dim != nparams) + goto Lnomatch; // not enough parameters + + for (size_t u = 0; u < nparams; u++) + { + Parameter *arg = arguments->tdata()[u]; + Parameter *param = Parameter::getNth(tf->parameters, u); + if (arg->type) + { if (!arg->type->equals(param->type)) + goto Lnomatch; + } + else if (!flags) + arg->type = param->type; + } + Lmatch: + return 1; + + Lnomatch: + return 0; +} + +/******************************************* + * Infer foreach arg types from a template function opApply which looks like: + * int opApply(alias int func(ref uint))() { ... } + */ + +#if 0 +void inferApplyArgTypesZ(TemplateDeclaration *tstart, Parameters *arguments) +{ + for (TemplateDeclaration *td = tstart; td; td = td->overnext) + { + if (!td->scope) + { + error("forward reference to template %s", td->toChars()); + return; + } + if (!td->onemember || !td->onemember->toAlias()->isFuncDeclaration()) + { + error("is not a function template"); + return; + } + if (!td->parameters || td->parameters->dim != 1) + continue; + TemplateParameter *tp = td->parameters->tdata()[0]; + TemplateAliasParameter *tap = tp->isTemplateAliasParameter(); + if (!tap || !tap->specType || tap->specType->ty != Tfunction) + continue; + TypeFunction *tf = (TypeFunction *)tap->specType; + if (inferApplyArgTypesY(tf, arguments) == 0) // found it + return; + } +} +#endif + +/************************************** + */ + +static void templateResolve(Match *m, TemplateDeclaration *td, Scope *sc, Loc loc, Objects *targsi, Expression *ethis, Expressions *arguments) +{ + FuncDeclaration *fd; + + assert(td); + fd = td->deduceFunctionTemplate(sc, loc, targsi, ethis, arguments, 1); + if (!fd) + return; + m->anyf = fd; + if (m->last >= MATCHexact) + { + m->nextf = fd; + m->count++; + } + else + { + m->last = MATCHexact; + m->lastf = fd; + m->count = 1; + } +} + diff --git a/optimize.c b/optimize.c new file mode 100644 index 00000000..315c1793 --- /dev/null +++ b/optimize.c @@ -0,0 +1,1182 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if __DMC__ +#include +#endif + +#include "lexer.h" +#include "mtype.h" +#include "expression.h" +#include "declaration.h" +#include "aggregate.h" +#include "init.h" + + +#ifdef IN_GCC +#include "d-gcc-real.h" + +/* %% fix? */ +extern "C" bool real_isnan (const real_t *); +#endif + +static real_t zero; // work around DMC bug for now + + +/************************************* + * If variable has a const initializer, + * return that initializer. + */ + +Expression *expandVar(int result, VarDeclaration *v) +{ + //printf("expandVar(result = %d, v = %p, %s)\n", result, v, v ? v->toChars() : "null"); + + Expression *e = NULL; + if (!v) + return e; + if (!v->originalType && v->scope) // semantic() not yet run + v->semantic (v->scope); + + if (v->isConst() || v->isImmutable() || v->storage_class & STCmanifest) + { + if (!v->type) + { + //error("ICE"); + return e; + } + Type *tb = v->type->toBasetype(); + if (result & WANTinterpret || + v->storage_class & STCmanifest || + v->type->toBasetype()->isscalar() || + ((result & WANTexpand) && (tb->ty != Tsarray && tb->ty != Tstruct)) + ) + { + if (v->init) + { + if (v->inuse) + { if (v->storage_class & STCmanifest) + v->error("recursive initialization of constant"); + goto L1; + } + Expression *ei = v->init->toExpression(); + if (!ei) + { if (v->storage_class & STCmanifest) + v->error("enum cannot be initialized with %s", v->init->toChars()); + goto L1; + } + if (ei->op == TOKconstruct || ei->op == TOKblit) + { AssignExp *ae = (AssignExp *)ei; + ei = ae->e2; + if (result & WANTinterpret) + { + v->inuse++; + ei = ei->optimize(result); + v->inuse--; + } + else if (ei->isConst() != 1 && ei->op != TOKstring) + goto L1; + + if (ei->type == v->type) + { // const variable initialized with const expression + } + else if (ei->implicitConvTo(v->type) >= MATCHconst) + { // const var initialized with non-const expression + ei = ei->implicitCastTo(0, v->type); + ei = ei->semantic(0); + } + else + goto L1; + } + if (v->scope) + { + v->inuse++; + e = ei->syntaxCopy(); + e = e->semantic(v->scope); + e = e->implicitCastTo(v->scope, v->type); + // enabling this line causes test22 in test suite to fail + //ei->type = e->type; + v->scope = NULL; + v->inuse--; + } + else if (!ei->type) + { + goto L1; + } + else + // Should remove the copy() operation by + // making all mods to expressions copy-on-write + e = ei->copy(); + } + else + { +#if 1 + goto L1; +#else + // BUG: what if const is initialized in constructor? + e = v->type->defaultInit(); + e->loc = e1->loc; +#endif + } + if (e->type != v->type) + { + e = e->castTo(NULL, v->type); + } + v->inuse++; + e = e->optimize(result); + v->inuse--; + } + } +L1: + //if (e) printf("\te = %p, %s, e->type = %d, %s\n", e, e->toChars(), e->type->ty, e->type->toChars()); + return e; +} + + +Expression *fromConstInitializer(int result, Expression *e1) +{ + //printf("fromConstInitializer(result = %x, %s)\n", result, e1->toChars()); + //static int xx; if (xx++ == 10) assert(0); + Expression *e = e1; + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + VarDeclaration *v = ve->var->isVarDeclaration(); + int fwdref = (v && !v->originalType && v->scope); + e = expandVar(result, v); + if (e) + { + // If it is a comma expression involving a declaration, we mustn't + // perform a copy -- we'd get two declarations of the same variable. + // See bugzilla 4465. + if (e->op == TOKcomma && ((CommaExp *)e)->e1->op == TOKdeclaration) + e = e1; + else + + if (e->type != e1->type && e1->type && e1->type->ty != Tident) + { // Type 'paint' operation + e = e->copy(); + e->type = e1->type; + } + e->loc = e1->loc; + } + else + { + e = e1; + /* If we needed to interpret, generate an error. + * Don't give an error if it's a template parameter + */ + if (v && (result & WANTinterpret) && + !(v->storage_class & STCtemplateparameter)) + { + e1->error("variable %s cannot be read at compile time", v->toChars()); + } + } + } + return e; +} + + +Expression *Expression::optimize(int result) +{ + //printf("Expression::optimize(result = x%x) %s\n", result, toChars()); + return this; +} + +Expression *VarExp::optimize(int result) +{ + return fromConstInitializer(result, this); +} + +Expression *TupleExp::optimize(int result) +{ + for (size_t i = 0; i < exps->dim; i++) + { Expression *e = exps->tdata()[i]; + + e = e->optimize(WANTvalue | (result & WANTinterpret)); + exps->tdata()[i] = e; + } + return this; +} + +Expression *ArrayLiteralExp::optimize(int result) +{ + if (elements) + { + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = elements->tdata()[i]; + + e = e->optimize(WANTvalue | (result & (WANTinterpret | WANTexpand))); + elements->tdata()[i] = e; + } + } + return this; +} + +Expression *AssocArrayLiteralExp::optimize(int result) +{ + assert(keys->dim == values->dim); + for (size_t i = 0; i < keys->dim; i++) + { Expression *e = keys->tdata()[i]; + + e = e->optimize(WANTvalue | (result & (WANTinterpret | WANTexpand))); + keys->tdata()[i] = e; + + e = values->tdata()[i]; + e = e->optimize(WANTvalue | (result & (WANTinterpret | WANTexpand))); + values->tdata()[i] = e; + } + return this; +} + +Expression *StructLiteralExp::optimize(int result) +{ + if (elements) + { + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = elements->tdata()[i]; + if (!e) + continue; + e = e->optimize(WANTvalue | (result & (WANTinterpret | WANTexpand))); + elements->tdata()[i] = e; + } + } + return this; +} + +Expression *TypeExp::optimize(int result) +{ + return this; +} + +Expression *UnaExp::optimize(int result) +{ + //printf("UnaExp::optimize() %s\n", toChars()); + e1 = e1->optimize(result); + return this; +} + +Expression *NegExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + if (e1->isConst() == 1) + { + e = Neg(type, e1); + } + else + e = this; + return e; +} + +Expression *ComExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + if (e1->isConst() == 1) + { + e = Com(type, e1); + } + else + e = this; + return e; +} + +Expression *NotExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + if (e1->isConst() == 1) + { + e = Not(type, e1); + } + else + e = this; + return e; +} + +Expression *BoolExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + if (e1->isConst() == 1) + { + e = Bool(type, e1); + } + else + e = this; + return e; +} + +Expression *AddrExp::optimize(int result) +{ Expression *e; + + //printf("AddrExp::optimize(result = %d) %s\n", result, toChars()); + + /* Rewrite &(a,b) as (a,&b) + */ + if (e1->op == TOKcomma) + { CommaExp *ce = (CommaExp *)e1; + AddrExp *ae = new AddrExp(loc, ce->e2); + ae->type = type; + e = new CommaExp(ce->loc, ce->e1, ae); + e->type = type; + return e->optimize(result); + } + + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + if (ve->var->storage_class & STCmanifest) + e1 = e1->optimize(result); + } + else + e1 = e1->optimize(result); + + // Convert &*ex to ex + if (e1->op == TOKstar) + { Expression *ex; + + ex = ((PtrExp *)e1)->e1; + if (type->equals(ex->type)) + e = ex; + else + { + e = ex->copy(); + e->type = type; + } + return e; + } + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + if (!ve->var->isOut() && !ve->var->isRef() && + !ve->var->isImportedSymbol()) + { + SymOffExp *se = new SymOffExp(loc, ve->var, 0, ve->hasOverloads); + se->type = type; + return se; + } + } + if (e1->op == TOKindex) + { // Convert &array[n] to &array+n + IndexExp *ae = (IndexExp *)e1; + + if (ae->e2->op == TOKint64 && ae->e1->op == TOKvar) + { + dinteger_t index = ae->e2->toInteger(); + VarExp *ve = (VarExp *)ae->e1; + if (ve->type->ty == Tsarray + && !ve->var->isImportedSymbol()) + { + TypeSArray *ts = (TypeSArray *)ve->type; + dinteger_t dim = ts->dim->toInteger(); + if (index < 0 || index >= dim) + error("array index %jd is out of bounds [0..%jd]", index, dim); + e = new SymOffExp(loc, ve->var, index * ts->nextOf()->size()); + e->type = type; + return e; + } + } + } + return this; +} + +Expression *PtrExp::optimize(int result) +{ + //printf("PtrExp::optimize(result = x%x) %s\n", result, toChars()); + e1 = e1->optimize(result); + // Convert *&ex to ex + if (e1->op == TOKaddress) + { Expression *e; + Expression *ex; + + ex = ((AddrExp *)e1)->e1; + if (type->equals(ex->type)) + e = ex; + else + { + e = ex->copy(); + e->type = type; + } + return e; + } + // Constant fold *(&structliteral + offset) + if (e1->op == TOKadd) + { + Expression *e; + e = Ptr(type, e1); + if (e != EXP_CANT_INTERPRET) + return e; + } + + if (e1->op == TOKsymoff) + { SymOffExp *se = (SymOffExp *)e1; + VarDeclaration *v = se->var->isVarDeclaration(); + Expression *e = expandVar(result, v); + if (e && e->op == TOKstructliteral) + { StructLiteralExp *sle = (StructLiteralExp *)e; + e = sle->getField(type, se->offset); + if (e && e != EXP_CANT_INTERPRET) + return e; + } + } + return this; +} + +Expression *DotVarExp::optimize(int result) +{ + //printf("DotVarExp::optimize(result = x%x) %s\n", result, toChars()); + e1 = e1->optimize(result); + + Expression *e = e1; + + if (e1->op == TOKvar) + { VarExp *ve = (VarExp *)e1; + VarDeclaration *v = ve->var->isVarDeclaration(); + e = expandVar(result, v); + } + + if (e && e->op == TOKstructliteral) + { StructLiteralExp *sle = (StructLiteralExp *)e; + VarDeclaration *vf = var->isVarDeclaration(); + if (vf) + { + Expression *e = sle->getField(type, vf->offset); + if (e && e != EXP_CANT_INTERPRET) + return e; + } + } + + return this; +} + +Expression *NewExp::optimize(int result) +{ + if (thisexp) + thisexp = thisexp->optimize(WANTvalue); + + // Optimize parameters + if (newargs) + { + for (size_t i = 0; i < newargs->dim; i++) + { Expression *e = newargs->tdata()[i]; + + e = e->optimize(WANTvalue); + newargs->tdata()[i] = e; + } + } + + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { Expression *e = arguments->tdata()[i]; + + e = e->optimize(WANTvalue); + arguments->tdata()[i] = e; + } + } + if (result & WANTinterpret) + { + error("cannot evaluate %s at compile time", toChars()); + } + return this; +} + +Expression *CallExp::optimize(int result) +{ + //printf("CallExp::optimize(result = %d) %s\n", result, toChars()); + Expression *e = this; + + // Optimize parameters + if (arguments) + { + for (size_t i = 0; i < arguments->dim; i++) + { Expression *e = arguments->tdata()[i]; + + e = e->optimize(WANTvalue); + arguments->tdata()[i] = e; + } + } + + e1 = e1->optimize(result); +#if 1 + if (result & WANTinterpret) + { + Expression *eresult = interpret(NULL); + if (eresult == EXP_CANT_INTERPRET) + return e; + if (eresult && eresult != EXP_VOID_INTERPRET) + e = eresult; + else + error("cannot evaluate %s at compile time", toChars()); + } +#else + if (e1->op == TOKvar) + { + FuncDeclaration *fd = ((VarExp *)e1)->var->isFuncDeclaration(); + if (fd) + { + enum BUILTIN b = fd->isBuiltin(); + if (b) + { + e = eval_builtin(b, arguments); + if (!e) // failed + e = this; // evaluate at runtime + } + else if (result & WANTinterpret) + { + Expression *eresult = fd->interpret(NULL, arguments); + if (eresult && eresult != EXP_VOID_INTERPRET) + e = eresult; + else + error("cannot evaluate %s at compile time", toChars()); + } + } + } + else if (e1->op == TOKdotvar && result & WANTinterpret) + { DotVarExp *dve = (DotVarExp *)e1; + FuncDeclaration *fd = dve->var->isFuncDeclaration(); + if (fd) + { + Expression *eresult = fd->interpret(NULL, arguments, dve->e1); + if (eresult && eresult != EXP_VOID_INTERPRET) + e = eresult; + else + error("cannot evaluate %s at compile time", toChars()); + } + } +#endif + return e; +} + + +Expression *CastExp::optimize(int result) +{ + //printf("CastExp::optimize(result = %d) %s\n", result, toChars()); + //printf("from %s to %s\n", type->toChars(), to->toChars()); + //printf("from %s\n", type->toChars()); + //printf("e1->type %s\n", e1->type->toChars()); + //printf("type = %p\n", type); + assert(type); + enum TOK op1 = e1->op; +#define X 0 + + Expression *e1old = e1; + e1 = e1->optimize(result); + e1 = fromConstInitializer(result, e1); + + if (e1 == e1old && + e1->op == TOKarrayliteral && + type->toBasetype()->ty == Tpointer && + e1->type->toBasetype()->ty != Tsarray) + { + // Casting this will result in the same expression, and + // infinite loop because of Expression::implicitCastTo() + return this; // no change + } + + if ((e1->op == TOKstring || e1->op == TOKarrayliteral) && + (type->ty == Tpointer || type->ty == Tarray) && + e1->type->nextOf()->size() == type->nextOf()->size() + ) + { + Expression *e = e1->castTo(NULL, type); + if (X) printf(" returning1 %s\n", e->toChars()); + return e; + } + + if (e1->op == TOKstructliteral && + e1->type->implicitConvTo(type) >= MATCHconst) + { + e1->type = type; + if (X) printf(" returning2 %s\n", e1->toChars()); + return e1; + } + + /* The first test here is to prevent infinite loops + */ + if (op1 != TOKarrayliteral && e1->op == TOKarrayliteral) + return e1->castTo(NULL, to); + if (e1->op == TOKnull && + (type->ty == Tpointer || type->ty == Tclass || type->ty == Tarray)) + { + e1->type = type; + if (X) printf(" returning3 %s\n", e1->toChars()); + return e1; + } + + if (result & WANTflags && type->ty == Tclass && e1->type->ty == Tclass) + { + // See if we can remove an unnecessary cast + ClassDeclaration *cdfrom; + ClassDeclaration *cdto; + int offset; + + cdfrom = e1->type->isClassHandle(); + cdto = type->isClassHandle(); + if (cdto->isBaseOf(cdfrom, &offset) && offset == 0) + { + e1->type = type; + if (X) printf(" returning4 %s\n", e1->toChars()); + return e1; + } + } + + // We can convert 'head const' to mutable + if (to->constOf()->equals(e1->type->constOf())) + { + e1->type = type; + if (X) printf(" returning5 %s\n", e1->toChars()); + return e1; + } + + Expression *e; + + if (e1->isConst()) + { + if (e1->op == TOKsymoff) + { + if (type->size() == e1->type->size() && + type->toBasetype()->ty != Tsarray) + { + e1->type = type; + return e1; + } + return this; + } + if (to->toBasetype()->ty == Tvoid) + e = this; + else + e = Cast(type, to, e1); + } + else + e = this; + if (X) printf(" returning6 %s\n", e->toChars()); + return e; +#undef X +} + +Expression *BinExp::optimize(int result) +{ + //printf("BinExp::optimize(result = %d) %s\n", result, toChars()); + if (op != TOKconstruct && op != TOKblit) // don't replace const variable with its initializer + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (op == TOKshlass || op == TOKshrass || op == TOKushrass) + { + if (e2->isConst() == 1) + { + dinteger_t i2 = e2->toInteger(); + d_uns64 sz = e1->type->size() * 8; + if (i2 < 0 || i2 >= sz) + { error("shift assign by %jd is outside the range 0..%zu", i2, sz - 1); + e2 = new IntegerExp(0); + } + } + } + return this; +} + +Expression *AddExp::optimize(int result) +{ Expression *e; + + //printf("AddExp::optimize(%s)\n", toChars()); + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() && e2->isConst()) + { + if (e1->op == TOKsymoff && e2->op == TOKsymoff) + return this; + e = Add(type, e1, e2); + } + else + e = this; + return e; +} + +Expression *MinExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() && e2->isConst()) + { + if (e2->op == TOKsymoff) + return this; + e = Min(type, e1, e2); + } + else + e = this; + return e; +} + +Expression *MulExp::optimize(int result) +{ Expression *e; + + //printf("MulExp::optimize(result = %d) %s\n", result, toChars()); + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + { + e = Mul(type, e1, e2); + } + else + e = this; + return e; +} + +Expression *DivExp::optimize(int result) +{ Expression *e; + + //printf("DivExp::optimize(%s)\n", toChars()); + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + { + e = Div(type, e1, e2); + } + else + e = this; + return e; +} + +Expression *ModExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + { + e = Mod(type, e1, e2); + } + else + e = this; + return e; +} + +Expression *shift_optimize(int result, BinExp *e, Expression *(*shift)(Type *, Expression *, Expression *)) +{ Expression *ex = e; + + e->e1 = e->e1->optimize(result); + e->e2 = e->e2->optimize(result); + if (e->e2->isConst() == 1) + { + dinteger_t i2 = e->e2->toInteger(); + d_uns64 sz = e->e1->type->size() * 8; + if (i2 < 0 || i2 >= sz) + { e->error("shift by %jd is outside the range 0..%zu", i2, sz - 1); + e->e2 = new IntegerExp(0); + } + if (e->e1->isConst() == 1) + ex = (*shift)(e->type, e->e1, e->e2); + } + return ex; +} + +Expression *ShlExp::optimize(int result) +{ + //printf("ShlExp::optimize(result = %d) %s\n", result, toChars()); + return shift_optimize(result, this, Shl); +} + +Expression *ShrExp::optimize(int result) +{ + //printf("ShrExp::optimize(result = %d) %s\n", result, toChars()); + return shift_optimize(result, this, Shr); +} + +Expression *UshrExp::optimize(int result) +{ + //printf("UshrExp::optimize(result = %d) %s\n", result, toChars()); + return shift_optimize(result, this, Ushr); +} + +Expression *AndExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + e = And(type, e1, e2); + else + e = this; + return e; +} + +Expression *OrExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + e = Or(type, e1, e2); + else + e = this; + return e; +} + +Expression *XorExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + if (e1->isConst() == 1 && e2->isConst() == 1) + e = Xor(type, e1, e2); + else + e = this; + return e; +} + +Expression *PowExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(result); + e2 = e2->optimize(result); + + // Replace 1 ^^ x or 1.0^^x by (x, 1) + if ((e1->op == TOKint64 && e1->toInteger() == 1) || + (e1->op == TOKfloat64 && e1->toReal() == 1.0)) + { + e = new CommaExp(loc, e2, e1); + } + // Replace -1 ^^ x by (x&1) ? -1 : 1, where x is integral + else if (e2->type->isintegral() && e1->op == TOKint64 && (sinteger_t)e1->toInteger() == -1L) + { + Type* resultType = type; + e = new AndExp(loc, e2, new IntegerExp(loc, 1, e2->type)); + e = new CondExp(loc, e, new IntegerExp(loc, -1L, resultType), new IntegerExp(loc, 1L, resultType)); + } + // Replace x ^^ 0 or x^^0.0 by (x, 1) + else if ((e2->op == TOKint64 && e2->toInteger() == 0) || + (e2->op == TOKfloat64 && e2->toReal() == 0.0)) + { + if (e1->type->isintegral()) + e = new IntegerExp(loc, 1, e1->type); + else + e = new RealExp(loc, 1.0, e1->type); + + e = new CommaExp(loc, e1, e); + } + // Replace x ^^ 1 or x^^1.0 by (x) + else if ((e2->op == TOKint64 && e2->toInteger() == 1) || + (e2->op == TOKfloat64 && e2->toReal() == 1.0)) + { + e = e1; + } + // Replace x ^^ -1.0 by (1.0 / x) + else if ((e2->op == TOKfloat64 && e2->toReal() == -1.0)) + { + e = new DivExp(loc, new RealExp(loc, 1.0, e2->type), e1); + } + // All other negative integral powers are illegal + else if ((e1->type->isintegral()) && (e2->op == TOKint64) && (sinteger_t)e2->toInteger() < 0) + { + error("cannot raise %s to a negative integer power. Did you mean (cast(real)%s)^^%s ?", + e1->type->toBasetype()->toChars(), e1->toChars(), e2->toChars()); + e = new ErrorExp(); + } + else + { + // If e2 *could* have been an integer, make it one. + if (e2->op == TOKfloat64 && (e2->toReal() == (sinteger_t)(e2->toReal()))) + e2 = new IntegerExp(loc, e2->toInteger(), Type::tint64); + + if (e1->isConst() == 1 && e2->isConst() == 1) + { + e = Pow(type, e1, e2); + if (e != EXP_CANT_INTERPRET) + return e; + } + e = this; + } + return e; +} + +Expression *CommaExp::optimize(int result) +{ Expression *e; + + //printf("CommaExp::optimize(result = %d) %s\n", result, toChars()); + // Comma needs special treatment, because it may + // contain compiler-generated declarations. We can interpret them, but + // otherwise we must NOT attempt to constant-fold them. + // In particular, if the comma returns a temporary variable, it needs + // to be an lvalue (this is particularly important for struct constructors) + + if (result & WANTinterpret) + { // Interpreting comma needs special treatment, because it may + // contain compiler-generated declarations. + e = interpret(NULL); + return (e == EXP_CANT_INTERPRET) ? this : e; + } + + e1 = e1->optimize(result & WANTinterpret); + e2 = e2->optimize(result); + if (!e1 || e1->op == TOKint64 || e1->op == TOKfloat64 || !e1->hasSideEffect()) + { + e = e2; + if (e) + e->type = type; + } + else + e = this; + //printf("-CommaExp::optimize(result = %d) %s\n", result, e->toChars()); + return e; +} + +Expression *ArrayLengthExp::optimize(int result) +{ Expression *e; + + //printf("ArrayLengthExp::optimize(result = %d) %s\n", result, toChars()); + e1 = e1->optimize(WANTvalue | WANTexpand | (result & WANTinterpret)); + e = this; + if (e1->op == TOKstring || e1->op == TOKarrayliteral || e1->op == TOKassocarrayliteral) + { + e = ArrayLength(type, e1); + } + return e; +} + +Expression *EqualExp::optimize(int result) +{ Expression *e; + + //printf("EqualExp::optimize(result = %x) %s\n", result, toChars()); + e1 = e1->optimize(WANTvalue | (result & WANTinterpret)); + e2 = e2->optimize(WANTvalue | (result & WANTinterpret)); + e = this; + + Expression *e1 = fromConstInitializer(result, this->e1); + Expression *e2 = fromConstInitializer(result, this->e2); + + e = Equal(op, type, e1, e2); + if (e == EXP_CANT_INTERPRET) + e = this; + return e; +} + +Expression *IdentityExp::optimize(int result) +{ + //printf("IdentityExp::optimize(result = %d) %s\n", result, toChars()); + e1 = e1->optimize(WANTvalue | (result & WANTinterpret)); + e2 = e2->optimize(WANTvalue | (result & WANTinterpret)); + Expression *e = this; + + if ((this->e1->isConst() && this->e2->isConst()) || + (this->e1->op == TOKnull && this->e2->op == TOKnull)) + { + e = Identity(op, type, this->e1, this->e2); + if (e == EXP_CANT_INTERPRET) + e = this; + } + return e; +} + +/* It is possible for constant folding to change an array expression of + * unknown length, into one where the length is known. + * If the expression 'arr' is a literal, set lengthVar to be its length. + */ +void setLengthVarIfKnown(VarDeclaration *lengthVar, Expression *arr) +{ + if (!lengthVar) + return; + if (lengthVar->init && !lengthVar->init->isVoidInitializer()) + return; // we have previously calculated the length + size_t len; + if (arr->op == TOKstring) + len = ((StringExp *)arr)->len; + else if (arr->op == TOKarrayliteral) + len = ((ArrayLiteralExp *)arr)->elements->dim; + else + return; // we don't know the length yet + + Expression *dollar = new IntegerExp(0, len, Type::tsize_t); + lengthVar->init = new ExpInitializer(0, dollar); + lengthVar->storage_class |= STCstatic | STCconst; +} + + +Expression *IndexExp::optimize(int result) +{ Expression *e; + + //printf("IndexExp::optimize(result = %d) %s\n", result, toChars()); + Expression *e1 = this->e1->optimize( + WANTvalue | (result & (WANTinterpret| WANTexpand))); + e1 = fromConstInitializer(result, e1); + if (this->e1->op == TOKvar) + { VarExp *ve = (VarExp *)this->e1; + if (ve->var->storage_class & STCmanifest) + { /* We generally don't want to have more than one copy of an + * array literal, but if it's an enum we have to because the + * enum isn't stored elsewhere. See Bugzilla 2559 + */ + this->e1 = e1; + } + } + // We might know $ now + setLengthVarIfKnown(lengthVar, e1); + e2 = e2->optimize(WANTvalue | (result & WANTinterpret)); + e = Index(type, e1, e2); + if (e == EXP_CANT_INTERPRET) + e = this; + return e; +} + + +Expression *SliceExp::optimize(int result) +{ Expression *e; + + //printf("SliceExp::optimize(result = %d) %s\n", result, toChars()); + e = this; + e1 = e1->optimize(WANTvalue | (result & (WANTinterpret|WANTexpand))); + if (!lwr) + { if (e1->op == TOKstring) + { // Convert slice of string literal into dynamic array + Type *t = e1->type->toBasetype(); + if (t->nextOf()) + e = e1->castTo(NULL, t->nextOf()->arrayOf()); + } + return e; + } + e1 = fromConstInitializer(result, e1); + // We might know $ now + setLengthVarIfKnown(lengthVar, e1); + lwr = lwr->optimize(WANTvalue | (result & WANTinterpret)); + upr = upr->optimize(WANTvalue | (result & WANTinterpret)); + e = Slice(type, e1, lwr, upr); + if (e == EXP_CANT_INTERPRET) + e = this; + //printf("-SliceExp::optimize() %s\n", e->toChars()); + return e; +} + +Expression *AndAndExp::optimize(int result) +{ Expression *e; + + //printf("AndAndExp::optimize(%d) %s\n", result, toChars()); + e1 = e1->optimize(WANTflags | (result & WANTinterpret)); + e = this; + if (e1->isBool(FALSE)) + { + if (type->toBasetype()->ty == Tvoid) + e = e2; + else + { e = new CommaExp(loc, e1, new IntegerExp(loc, 0, type)); + e->type = type; + } + e = e->optimize(result); + } + else + { + e2 = e2->optimize(WANTflags | (result & WANTinterpret)); + if (result && e2->type->toBasetype()->ty == Tvoid && !global.errors) + error("void has no value"); + if (e1->isConst()) + { + if (e2->isConst()) + { int n1 = e1->isBool(1); + int n2 = e2->isBool(1); + + e = new IntegerExp(loc, n1 && n2, type); + } + else if (e1->isBool(TRUE)) + { + if (type->toBasetype()->ty == Tvoid) + e = e2; + else e = new BoolExp(loc, e2, type); + } + } + } + return e; +} + +Expression *OrOrExp::optimize(int result) +{ Expression *e; + + e1 = e1->optimize(WANTflags | (result & WANTinterpret)); + e = this; + if (e1->isBool(TRUE)) + { // Replace with (e1, 1) + e = new CommaExp(loc, e1, new IntegerExp(loc, 1, type)); + e->type = type; + e = e->optimize(result); + } + else + { + e2 = e2->optimize(WANTflags | (result & WANTinterpret)); + if (result && e2->type->toBasetype()->ty == Tvoid && !global.errors) + error("void has no value"); + if (e1->isConst()) + { + if (e2->isConst()) + { int n1 = e1->isBool(1); + int n2 = e2->isBool(1); + + e = new IntegerExp(loc, n1 || n2, type); + } + else if (e1->isBool(FALSE)) + { + if (type->toBasetype()->ty == Tvoid) + e = e2; + else + e = new BoolExp(loc, e2, type); + } + } + } + return e; +} + +Expression *CmpExp::optimize(int result) +{ Expression *e; + + //printf("CmpExp::optimize() %s\n", toChars()); + e1 = e1->optimize(WANTvalue | (result & WANTinterpret)); + e2 = e2->optimize(WANTvalue | (result & WANTinterpret)); + + Expression *e1 = fromConstInitializer(result, this->e1); + Expression *e2 = fromConstInitializer(result, this->e2); + + e = Cmp(op, type, e1, e2); + if (e == EXP_CANT_INTERPRET) + e = this; + return e; +} + +Expression *CatExp::optimize(int result) +{ Expression *e; + + //printf("CatExp::optimize(%d) %s\n", result, toChars()); + e1 = e1->optimize(result); + e2 = e2->optimize(result); + e = Cat(type, e1, e2); + if (e == EXP_CANT_INTERPRET) + e = this; + return e; +} + + +Expression *CondExp::optimize(int result) +{ Expression *e; + + econd = econd->optimize(WANTflags | (result & WANTinterpret)); + if (econd->isBool(TRUE)) + e = e1->optimize(result); + else if (econd->isBool(FALSE)) + e = e2->optimize(result); + else + { e1 = e1->optimize(result); + e2 = e2->optimize(result); + e = this; + } + return e; +} + + diff --git a/parse.c b/parse.c new file mode 100644 index 00000000..addefc74 --- /dev/null +++ b/parse.c @@ -0,0 +1,6706 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// This is the D parser + +#include +#include + +#include "rmem.h" +#include "lexer.h" +#include "parse.h" +#include "init.h" +#include "attrib.h" +#include "cond.h" +#include "mtype.h" +#include "template.h" +#include "staticassert.h" +#include "expression.h" +#include "statement.h" +#include "module.h" +#include "dsymbol.h" +#include "import.h" +#include "declaration.h" +#include "aggregate.h" +#include "enum.h" +#include "id.h" +#include "version.h" +#include "aliasthis.h" + +// How multiple declarations are parsed. +// If 1, treat as C. +// If 0, treat: +// int *p, i; +// as: +// int* p; +// int* i; +#define CDECLSYNTAX 0 + +// Support C cast syntax: +// (type)(expression) +#define CCASTSYNTAX 1 + +// Support postfix C array declarations, such as +// int a[3][4]; +#define CARRAYDECL 1 + +// Support D1 inout +#define D1INOUT 0 + +Parser::Parser(Module *module, unsigned char *base, unsigned length, int doDocComment) + : Lexer(module, base, 0, length, doDocComment, 0) +{ + //printf("Parser::Parser()\n"); + md = NULL; + linkage = LINKd; + endloc = 0; + inBrackets = 0; + lookingForElse = 0; + //nextToken(); // start up the scanner +} + +Dsymbols *Parser::parseModule() +{ + Dsymbols *decldefs; + + // ModuleDeclation leads off + if (token.value == TOKmodule) + { + unsigned char *comment = token.blockComment; + bool safe = FALSE; + + nextToken(); +#if 0 && DMDV2 + if (token.value == TOKlparen) + { + nextToken(); + if (token.value != TOKidentifier) + { error("module (system) identifier expected"); + goto Lerr; + } + Identifier *id = token.ident; + + if (id == Id::system) + safe = TRUE; + else + error("(safe) expected, not %s", id->toChars()); + nextToken(); + check(TOKrparen); + } +#endif + + if (token.value != TOKidentifier) + { error("Identifier expected following module"); + goto Lerr; + } + else + { + Identifiers *a = NULL; + Identifier *id; + + id = token.ident; + while (nextToken() == TOKdot) + { + if (!a) + a = new Identifiers(); + a->push(id); + nextToken(); + if (token.value != TOKidentifier) + { error("Identifier expected following package"); + goto Lerr; + } + id = token.ident; + } + + md = new ModuleDeclaration(a, id, safe); + + if (token.value != TOKsemicolon) + error("';' expected following module declaration instead of %s", token.toChars()); + nextToken(); + addComment(mod, comment); + } + } + + decldefs = parseDeclDefs(0); + if (token.value != TOKeof) + { error("unrecognized declaration"); + goto Lerr; + } + return decldefs; + +Lerr: + while (token.value != TOKsemicolon && token.value != TOKeof) + nextToken(); + nextToken(); + return new Dsymbols(); +} + +Dsymbols *Parser::parseDeclDefs(int once) +{ Dsymbol *s; + Dsymbols *decldefs; + Dsymbols *a; + Dsymbols *aelse; + enum PROT prot; + StorageClass stc; + StorageClass storageClass; + Condition *condition; + unsigned char *comment; + + //printf("Parser::parseDeclDefs()\n"); + decldefs = new Dsymbols(); + do + { + comment = token.blockComment; + storageClass = STCundefined; + switch (token.value) + { + case TOKenum: + { /* Determine if this is a manifest constant declaration, + * or a conventional enum. + */ + Token *t = peek(&token); + if (t->value == TOKlcurly || t->value == TOKcolon) + s = parseEnum(); + else if (t->value != TOKidentifier) + goto Ldeclaration; + else + { + t = peek(t); + if (t->value == TOKlcurly || t->value == TOKcolon || + t->value == TOKsemicolon) + s = parseEnum(); + else + goto Ldeclaration; + } + break; + } + + case TOKstruct: + case TOKunion: + case TOKclass: + case TOKinterface: + s = parseAggregate(); + break; + + case TOKimport: + s = parseImport(decldefs, 0); + break; + + case TOKtemplate: + s = (Dsymbol *)parseTemplateDeclaration(0); + break; + + case TOKmixin: + { Loc loc = this->loc; + switch (peekNext()) + { + case TOKlparen: + { // mixin(string) + nextToken(); + check(TOKlparen, "mixin"); + Expression *e = parseAssignExp(); + check(TOKrparen); + check(TOKsemicolon); + s = new CompileDeclaration(loc, e); + break; + } + case TOKtemplate: + // mixin template + nextToken(); + s = (Dsymbol *)parseTemplateDeclaration(1); + break; + + default: + s = parseMixin(); + break; + } + break; + } + + case BASIC_TYPES: + case TOKalias: + case TOKtypedef: + case TOKidentifier: + case TOKsuper: + case TOKtypeof: + case TOKdot: + case TOKvector: + Ldeclaration: + a = parseDeclarations(STCundefined, NULL); + decldefs->append(a); + continue; + + case TOKthis: + if (peekNext() == TOKdot) + goto Ldeclaration; + else + s = parseCtor(); + break; + +#if 0 // dead end, use this(this){} instead + case TOKassign: + s = parsePostBlit(); + break; +#endif + case TOKtilde: + s = parseDtor(); + break; + + case TOKinvariant: + { Token *t; + t = peek(&token); + if (t->value == TOKlparen) + { + if (peek(t)->value == TOKrparen) + // invariant() forms start of class invariant + s = parseInvariant(); + else + // invariant(type) + goto Ldeclaration; + } + else + { + if (!global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + stc = STCimmutable; + goto Lstc; + } + break; + } + + case TOKunittest: + s = parseUnitTest(); + break; + + case TOKnew: + s = parseNew(); + break; + + case TOKdelete: + s = parseDelete(); + break; + + case TOKeof: + case TOKrcurly: + return decldefs; + + case TOKstatic: + nextToken(); + if (token.value == TOKthis) + s = parseStaticCtor(); + else if (token.value == TOKtilde) + s = parseStaticDtor(); + else if (token.value == TOKassert) + s = parseStaticAssert(); + else if (token.value == TOKif) + { condition = parseStaticIfCondition(); + Loc lookingForElseSave = lookingForElse; + lookingForElse = loc; + a = parseBlock(); + lookingForElse = lookingForElseSave; + aelse = NULL; + if (token.value == TOKelse) + { + Loc elseloc = this->loc; + nextToken(); + aelse = parseBlock(); + checkDanglingElse(elseloc); + } + s = new StaticIfDeclaration(condition, a, aelse); + break; + } + else if (token.value == TOKimport) + { + s = parseImport(decldefs, 1); + } + else + { stc = STCstatic; + goto Lstc2; + } + break; + + case TOKconst: + if (peekNext() == TOKlparen) + goto Ldeclaration; + stc = STCconst; + goto Lstc; + + case TOKimmutable: + if (peekNext() == TOKlparen) + goto Ldeclaration; + stc = STCimmutable; + goto Lstc; + + case TOKshared: + { TOK next = peekNext(); + if (next == TOKlparen) + goto Ldeclaration; + if (next == TOKstatic) + { TOK next2 = peekNext2(); + if (next2 == TOKthis) + { s = parseSharedStaticCtor(); + break; + } + if (next2 == TOKtilde) + { s = parseSharedStaticDtor(); + break; + } + } + stc = STCshared; + goto Lstc; + } + + case TOKwild: + if (peekNext() == TOKlparen) + goto Ldeclaration; + stc = STCwild; + goto Lstc; + + case TOKfinal: stc = STCfinal; goto Lstc; + case TOKauto: stc = STCauto; goto Lstc; + case TOKscope: stc = STCscope; goto Lstc; + case TOKoverride: stc = STCoverride; goto Lstc; + case TOKabstract: stc = STCabstract; goto Lstc; + case TOKsynchronized: stc = STCsynchronized; goto Lstc; + case TOKdeprecated: stc = STCdeprecated; goto Lstc; +#if DMDV2 + case TOKnothrow: stc = STCnothrow; goto Lstc; + case TOKpure: stc = STCpure; goto Lstc; + case TOKref: stc = STCref; goto Lstc; + case TOKtls: stc = STCtls; goto Lstc; + case TOKgshared: stc = STCgshared; goto Lstc; + //case TOKmanifest: stc = STCmanifest; goto Lstc; + case TOKat: stc = parseAttribute(); goto Lstc; +#endif + + Lstc: + if (storageClass & stc) + error("redundant storage class %s", Token::toChars(token.value)); + composeStorageClass(storageClass | stc); + nextToken(); + Lstc2: + storageClass |= stc; + switch (token.value) + { + case TOKshared: + // Look for "shared static this" or "shared static ~this" + if (peekNext() == TOKstatic) + { TOK next2 = peekNext2(); + if (next2 == TOKthis || next2 == TOKtilde) + break; + } + case TOKconst: + case TOKinvariant: + case TOKimmutable: + case TOKwild: + // If followed by a (, it is not a storage class + if (peek(&token)->value == TOKlparen) + break; + if (token.value == TOKconst) + stc = STCconst; + else if (token.value == TOKshared) + stc = STCshared; + else if (token.value == TOKwild) + stc = STCwild; + else + { + if (token.value == TOKinvariant && !global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + stc = STCimmutable; + } + goto Lstc; + case TOKfinal: stc = STCfinal; goto Lstc; + case TOKauto: stc = STCauto; goto Lstc; + case TOKscope: stc = STCscope; goto Lstc; + case TOKoverride: stc = STCoverride; goto Lstc; + case TOKabstract: stc = STCabstract; goto Lstc; + case TOKsynchronized: stc = STCsynchronized; goto Lstc; + case TOKdeprecated: stc = STCdeprecated; goto Lstc; + case TOKnothrow: stc = STCnothrow; goto Lstc; + case TOKpure: stc = STCpure; goto Lstc; + case TOKref: stc = STCref; goto Lstc; + case TOKtls: stc = STCtls; goto Lstc; + case TOKgshared: stc = STCgshared; goto Lstc; + //case TOKmanifest: stc = STCmanifest; goto Lstc; + case TOKat: stc = parseAttribute(); goto Lstc; + default: + break; + } + + /* Look for auto initializers: + * storage_class identifier = initializer; + */ + if (token.value == TOKidentifier && + peek(&token)->value == TOKassign) + { + a = parseAutoDeclarations(storageClass, comment); + decldefs->append(a); + continue; + } + + /* Look for return type inference for template functions. + */ + Token *tk; + if (token.value == TOKidentifier && + (tk = peek(&token))->value == TOKlparen && + skipParens(tk, &tk) && + ((tk = peek(tk)), 1) && + skipAttributes(tk, &tk) && + (tk->value == TOKlparen || + tk->value == TOKlcurly) + ) + { + a = parseDeclarations(storageClass, comment); + decldefs->append(a); + continue; + } + a = parseBlock(); + s = new StorageClassDeclaration(storageClass, a); + break; + + case TOKextern: + if (peek(&token)->value != TOKlparen) + { stc = STCextern; + goto Lstc; + } + { + enum LINK linksave = linkage; + linkage = parseLinkage(); + a = parseBlock(); + s = new LinkDeclaration(linkage, a); + linkage = linksave; + break; + } + case TOKprivate: prot = PROTprivate; goto Lprot; + case TOKpackage: prot = PROTpackage; goto Lprot; + case TOKprotected: prot = PROTprotected; goto Lprot; + case TOKpublic: prot = PROTpublic; goto Lprot; + case TOKexport: prot = PROTexport; goto Lprot; + + Lprot: + nextToken(); + switch (token.value) + { + case TOKprivate: + case TOKpackage: + case TOKprotected: + case TOKpublic: + case TOKexport: + error("redundant protection attribute"); + break; + } + a = parseBlock(); + s = new ProtDeclaration(prot, a); + break; + + case TOKalign: + { unsigned n; + + s = NULL; + nextToken(); + if (token.value == TOKlparen) + { + nextToken(); + if (token.value == TOKint32v && token.uns64value > 0) + n = (unsigned)token.uns64value; + else + { error("positive integer expected, not %s", token.toChars()); + n = 1; + } + nextToken(); + check(TOKrparen); + } + else + n = global.structalign; // default + + a = parseBlock(); + s = new AlignDeclaration(n, a); + break; + } + + case TOKpragma: + { Identifier *ident; + Expressions *args = NULL; + + nextToken(); + check(TOKlparen); + if (token.value != TOKidentifier) + { error("pragma(identifier expected"); + goto Lerror; + } + ident = token.ident; + nextToken(); + if (token.value == TOKcomma && peekNext() != TOKrparen) + args = parseArguments(); // pragma(identifier, args...) + else + check(TOKrparen); // pragma(identifier) + + if (token.value == TOKsemicolon) + a = NULL; + else + a = parseBlock(); + s = new PragmaDeclaration(loc, ident, args, a); + break; + } + + case TOKdebug: + nextToken(); + if (token.value == TOKassign) + { + nextToken(); + if (token.value == TOKidentifier) + s = new DebugSymbol(loc, token.ident); + else if (token.value == TOKint32v || token.value == TOKint64v) + s = new DebugSymbol(loc, (unsigned)token.uns64value); + else + { error("identifier or integer expected, not %s", token.toChars()); + s = NULL; + } + nextToken(); + if (token.value != TOKsemicolon) + error("semicolon expected"); + nextToken(); + break; + } + + condition = parseDebugCondition(); + goto Lcondition; + + case TOKversion: + nextToken(); + if (token.value == TOKassign) + { + nextToken(); + if (token.value == TOKidentifier) + s = new VersionSymbol(loc, token.ident); + else if (token.value == TOKint32v || token.value == TOKint64v) + s = new VersionSymbol(loc, (unsigned)token.uns64value); + else + { error("identifier or integer expected, not %s", token.toChars()); + s = NULL; + } + nextToken(); + if (token.value != TOKsemicolon) + error("semicolon expected"); + nextToken(); + break; + } + condition = parseVersionCondition(); + goto Lcondition; + + Lcondition: + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = loc; + a = parseBlock(); + lookingForElse = lookingForElseSave; + } + aelse = NULL; + if (token.value == TOKelse) + { + Loc elseloc = this->loc; + nextToken(); + aelse = parseBlock(); + checkDanglingElse(elseloc); + } + s = new ConditionalDeclaration(condition, a, aelse); + break; + + case TOKsemicolon: // empty declaration + //error("empty declaration"); + nextToken(); + continue; + + default: + error("Declaration expected, not '%s'",token.toChars()); + Lerror: + while (token.value != TOKsemicolon && token.value != TOKeof) + nextToken(); + nextToken(); + s = NULL; + continue; + } + if (s) + { decldefs->push(s); + addComment(s, comment); + } + } while (!once); + return decldefs; +} + +/********************************************* + * Give error on conflicting storage classes. + */ + +#if DMDV2 +void Parser::composeStorageClass(StorageClass stc) +{ + StorageClass u = stc; + u &= STCconst | STCimmutable | STCmanifest; + if (u & (u - 1)) + error("conflicting storage class %s", Token::toChars(token.value)); + u = stc; + u &= STCgshared | STCshared | STCtls; + if (u & (u - 1)) + error("conflicting storage class %s", Token::toChars(token.value)); + u = stc; + u &= STCsafe | STCsystem | STCtrusted; + if (u & (u - 1)) + error("conflicting attribute @%s", token.toChars()); +} +#endif + +/*********************************************** + * Parse storage class, lexer is on '@' + */ + +#if DMDV2 +StorageClass Parser::parseAttribute() +{ + nextToken(); + StorageClass stc = 0; + if (token.value != TOKidentifier) + { + error("identifier expected after @, not %s", token.toChars()); + } + else if (token.ident == Id::property) + stc = STCproperty; + else if (token.ident == Id::safe) + stc = STCsafe; + else if (token.ident == Id::trusted) + stc = STCtrusted; + else if (token.ident == Id::system) + stc = STCsystem; + else if (token.ident == Id::disable) + stc = STCdisable; + else + error("valid attribute identifiers are @property, @safe, @trusted, @system, @disable not @%s", token.toChars()); + return stc; +} +#endif + +/*********************************************** + * Parse const/immutable/shared/inout/nothrow/pure postfix + */ + +StorageClass Parser::parsePostfix() +{ + StorageClass stc = 0; + + while (1) + { + switch (token.value) + { + case TOKconst: stc |= STCconst; break; + case TOKinvariant: + if (!global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + case TOKimmutable: stc |= STCimmutable; break; + case TOKshared: stc |= STCshared; break; + case TOKwild: stc |= STCwild; break; + case TOKnothrow: stc |= STCnothrow; break; + case TOKpure: stc |= STCpure; break; + case TOKat: stc |= parseAttribute(); break; + + default: return stc; + } + composeStorageClass(stc); + nextToken(); + } +} + +/******************************************** + * Parse declarations after an align, protection, or extern decl. + */ + +Dsymbols *Parser::parseBlock() +{ + Dsymbols *a = NULL; + + //printf("parseBlock()\n"); + switch (token.value) + { + case TOKsemicolon: + error("declaration expected following attribute, not ';'"); + nextToken(); + break; + + case TOKeof: + error("declaration expected following attribute, not EOF"); + break; + + case TOKlcurly: + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = 0; + + nextToken(); + a = parseDeclDefs(0); + if (token.value != TOKrcurly) + { /* { */ + error("matching '}' expected, not %s", token.toChars()); + } + else + nextToken(); + lookingForElse = lookingForElseSave; + break; + } + + case TOKcolon: + nextToken(); +#if 0 + a = NULL; +#else + a = parseDeclDefs(0); // grab declarations up to closing curly bracket +#endif + break; + + default: + a = parseDeclDefs(1); + break; + } + return a; +} + +/********************************** + * Parse a static assertion. + */ + +StaticAssert *Parser::parseStaticAssert() +{ + Loc loc = this->loc; + Expression *exp; + Expression *msg = NULL; + + //printf("parseStaticAssert()\n"); + nextToken(); + check(TOKlparen); + exp = parseAssignExp(); + if (token.value == TOKcomma) + { nextToken(); + msg = parseAssignExp(); + } + check(TOKrparen); + check(TOKsemicolon); + return new StaticAssert(loc, exp, msg); +} + +/*********************************** + * Parse typeof(expression). + * Current token is on the 'typeof'. + */ + +#if DMDV2 +TypeQualified *Parser::parseTypeof() +{ TypeQualified *t; + Loc loc = this->loc; + + nextToken(); + check(TOKlparen); + if (token.value == TOKreturn) // typeof(return) + { + nextToken(); + t = new TypeReturn(loc); + } + else + { Expression *exp = parseExpression(); // typeof(expression) + t = new TypeTypeof(loc, exp); + } + check(TOKrparen); + return t; +} +#endif + +/*********************************** + * Parse __vector(type). + * Current token is on the '__vector'. + */ + +#if DMDV2 +Type *Parser::parseVector() +{ + Loc loc = this->loc; + nextToken(); + check(TOKlparen); + Type *tb = parseType(); + check(TOKrparen); + return new TypeVector(loc, tb); +} +#endif + +/*********************************** + * Parse extern (linkage) + * The parser is on the 'extern' token. + */ + +enum LINK Parser::parseLinkage() +{ + enum LINK link = LINKdefault; + nextToken(); + assert(token.value == TOKlparen); + nextToken(); + if (token.value == TOKidentifier) + { Identifier *id = token.ident; + + nextToken(); + if (id == Id::Windows) + link = LINKwindows; + else if (id == Id::Pascal) + link = LINKpascal; + else if (id == Id::D) + link = LINKd; + else if (id == Id::C) + { + link = LINKc; + if (token.value == TOKplusplus) + { link = LINKcpp; + nextToken(); + } + } + else if (id == Id::System) + { +#if _WIN32 + link = LINKwindows; +#else + link = LINKc; +#endif + } + else + { + error("valid linkage identifiers are D, C, C++, Pascal, Windows, System"); + link = LINKd; + } + } + else + { + link = LINKd; // default + } + check(TOKrparen); + return link; +} + +/************************************** + * Parse a debug conditional + */ + +Condition *Parser::parseDebugCondition() +{ + Condition *c; + + if (token.value == TOKlparen) + { + nextToken(); + unsigned level = 1; + Identifier *id = NULL; + + if (token.value == TOKidentifier) + id = token.ident; + else if (token.value == TOKint32v || token.value == TOKint64v) + level = (unsigned)token.uns64value; + else + error("identifier or integer expected, not %s", token.toChars()); + nextToken(); + check(TOKrparen); + c = new DebugCondition(mod, level, id); + } + else + c = new DebugCondition(mod, 1, NULL); + return c; + +} + +/************************************** + * Parse a version conditional + */ + +Condition *Parser::parseVersionCondition() +{ + Condition *c; + unsigned level = 1; + Identifier *id = NULL; + + if (token.value == TOKlparen) + { + nextToken(); + if (token.value == TOKidentifier) + id = token.ident; + else if (token.value == TOKint32v || token.value == TOKint64v) + level = (unsigned)token.uns64value; +#if DMDV2 + /* Allow: + * version (unittest) + * even though unittest is a keyword + */ + else if (token.value == TOKunittest) + id = Lexer::idPool(Token::toChars(TOKunittest)); +#endif + else + error("identifier or integer expected, not %s", token.toChars()); + nextToken(); + check(TOKrparen); + + } + else + error("(condition) expected following version"); + c = new VersionCondition(mod, level, id); + return c; + +} + +/*********************************************** + * static if (expression) + * body + * else + * body + */ + +Condition *Parser::parseStaticIfCondition() +{ Expression *exp; + Condition *condition; + Loc loc = this->loc; + + nextToken(); + if (token.value == TOKlparen) + { + nextToken(); + exp = parseAssignExp(); + check(TOKrparen); + } + else + { error("(expression) expected following static if"); + exp = NULL; + } + condition = new StaticIfCondition(loc, exp); + return condition; +} + + +/***************************************** + * Parse a constructor definition: + * this(parameters) { body } + * or postblit: + * this(this) { body } + * or constructor template: + * this(templateparameters)(parameters) { body } + * Current token is 'this'. + */ + +Dsymbol *Parser::parseCtor() +{ + Loc loc = this->loc; + + nextToken(); + if (token.value == TOKlparen && peek(&token)->value == TOKthis) + { // this(this) { ... } + nextToken(); + nextToken(); + check(TOKrparen); + StorageClass stc = parsePostfix(); + PostBlitDeclaration *f = new PostBlitDeclaration(loc, 0, stc); + parseContracts(f); + return f; + } + + /* Look ahead to see if: + * this(...)(...) + * which is a constructor template + */ + TemplateParameters *tpl = NULL; + if (token.value == TOKlparen && peekPastParen(&token)->value == TOKlparen) + { tpl = parseTemplateParameterList(); + + int varargs; + Parameters *parameters = parseParameters(&varargs); + StorageClass stc = parsePostfix(); + + Expression *constraint = tpl ? parseConstraint() : NULL; + + Type *tf = new TypeFunction(parameters, NULL, varargs, linkage, stc); // RetrunType -> auto + tf = tf->addSTC(stc); + + CtorDeclaration *f = new CtorDeclaration(loc, 0, stc, tf); + parseContracts(f); + + // Wrap a template around it + Dsymbols *decldefs = new Dsymbols(); + decldefs->push(f); + TemplateDeclaration *tempdecl = + new TemplateDeclaration(loc, f->ident, tpl, constraint, decldefs, 0); + return tempdecl; + } + + /* Just a regular constructor + */ + int varargs; + Parameters *parameters = parseParameters(&varargs); + StorageClass stc = parsePostfix(); + Type *tf = new TypeFunction(parameters, NULL, varargs, linkage, stc); // RetrunType -> auto + tf = tf->addSTC(stc); + + CtorDeclaration *f = new CtorDeclaration(loc, 0, stc, tf); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a postblit definition: + * =this() { body } + * Current token is '='. + */ + +PostBlitDeclaration *Parser::parsePostBlit() +{ + Loc loc = this->loc; + + nextToken(); + check(TOKthis); + check(TOKlparen); + check(TOKrparen); + + PostBlitDeclaration *f = new PostBlitDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a destructor definition: + * ~this() { body } + * Current token is '~'. + */ + +DtorDeclaration *Parser::parseDtor() +{ + DtorDeclaration *f; + Loc loc = this->loc; + + nextToken(); + check(TOKthis); + check(TOKlparen); + check(TOKrparen); + + f = new DtorDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a static constructor definition: + * static this() { body } + * Current token is 'this'. + */ + +StaticCtorDeclaration *Parser::parseStaticCtor() +{ + Loc loc = this->loc; + + nextToken(); + check(TOKlparen); + check(TOKrparen); + + StaticCtorDeclaration *f = new StaticCtorDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a shared static constructor definition: + * shared static this() { body } + * Current token is 'shared'. + */ + +SharedStaticCtorDeclaration *Parser::parseSharedStaticCtor() +{ + Loc loc = this->loc; + + nextToken(); + nextToken(); + nextToken(); + check(TOKlparen); + check(TOKrparen); + + SharedStaticCtorDeclaration *f = new SharedStaticCtorDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a static destructor definition: + * static ~this() { body } + * Current token is '~'. + */ + +StaticDtorDeclaration *Parser::parseStaticDtor() +{ + Loc loc = this->loc; + + nextToken(); + check(TOKthis); + check(TOKlparen); + check(TOKrparen); + + StaticDtorDeclaration *f = new StaticDtorDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a shared static destructor definition: + * shared static ~this() { body } + * Current token is 'shared'. + */ + +SharedStaticDtorDeclaration *Parser::parseSharedStaticDtor() +{ + Loc loc = this->loc; + + nextToken(); + nextToken(); + nextToken(); + check(TOKthis); + check(TOKlparen); + check(TOKrparen); + + SharedStaticDtorDeclaration *f = new SharedStaticDtorDeclaration(loc, 0); + parseContracts(f); + return f; +} + +/***************************************** + * Parse an invariant definition: + * invariant() { body } + * Current token is 'invariant'. + */ + +InvariantDeclaration *Parser::parseInvariant() +{ + InvariantDeclaration *f; + Loc loc = this->loc; + + nextToken(); + if (token.value == TOKlparen) // optional () + { + nextToken(); + check(TOKrparen); + } + + f = new InvariantDeclaration(loc, 0); + f->fbody = parseStatement(PScurly); + return f; +} + +/***************************************** + * Parse a unittest definition: + * unittest { body } + * Current token is 'unittest'. + */ + +UnitTestDeclaration *Parser::parseUnitTest() +{ + UnitTestDeclaration *f; + Statement *body; + Loc loc = this->loc; + + nextToken(); + + body = parseStatement(PScurly); + + f = new UnitTestDeclaration(loc, this->loc); + f->fbody = body; + return f; +} + +/***************************************** + * Parse a new definition: + * new(arguments) { body } + * Current token is 'new'. + */ + +NewDeclaration *Parser::parseNew() +{ + NewDeclaration *f; + Parameters *arguments; + int varargs; + Loc loc = this->loc; + + nextToken(); + arguments = parseParameters(&varargs); + f = new NewDeclaration(loc, 0, arguments, varargs); + parseContracts(f); + return f; +} + +/***************************************** + * Parse a delete definition: + * delete(arguments) { body } + * Current token is 'delete'. + */ + +DeleteDeclaration *Parser::parseDelete() +{ + DeleteDeclaration *f; + Parameters *arguments; + int varargs; + Loc loc = this->loc; + + nextToken(); + arguments = parseParameters(&varargs); + if (varargs) + error("... not allowed in delete function parameter list"); + f = new DeleteDeclaration(loc, 0, arguments); + parseContracts(f); + return f; +} + +/********************************************** + * Parse parameter list. + */ + +Parameters *Parser::parseParameters(int *pvarargs, TemplateParameters **tpl) +{ + Parameters *arguments = new Parameters(); + int varargs = 0; + int hasdefault = 0; + + check(TOKlparen); + while (1) + { + Identifier *ai = NULL; + Type *at; + Parameter *a; + StorageClass storageClass = 0; + StorageClass stc; + Expression *ae; + + for (;1; nextToken()) + { + switch (token.value) + { + case TOKrparen: + break; + + case TOKdotdotdot: + varargs = 1; + nextToken(); + break; + + case TOKconst: + if (peek(&token)->value == TOKlparen) + goto Ldefault; + stc = STCconst; + goto L2; + + case TOKinvariant: + case TOKimmutable: + if (peek(&token)->value == TOKlparen) + goto Ldefault; + if (token.value == TOKinvariant && !global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + stc = STCimmutable; + goto L2; + + case TOKshared: + if (peek(&token)->value == TOKlparen) + goto Ldefault; + stc = STCshared; + goto L2; + + case TOKwild: + if (peek(&token)->value == TOKlparen) + goto Ldefault; + stc = STCwild; + goto L2; + + case TOKin: stc = STCin; goto L2; + case TOKout: stc = STCout; goto L2; +#if D1INOUT + case TOKinout: +#endif + case TOKref: stc = STCref; goto L2; + case TOKlazy: stc = STClazy; goto L2; + case TOKscope: stc = STCscope; goto L2; + case TOKfinal: stc = STCfinal; goto L2; + case TOKauto: stc = STCauto; goto L2; + L2: + if (storageClass & stc || + (storageClass & STCin && stc & (STCconst | STCscope)) || + (stc & STCin && storageClass & (STCconst | STCscope)) + ) + error("redundant storage class %s", Token::toChars(token.value)); + storageClass |= stc; + composeStorageClass(storageClass); + continue; + +#if 0 + case TOKstatic: stc = STCstatic; goto L2; + case TOKauto: storageClass = STCauto; goto L4; + case TOKalias: storageClass = STCalias; goto L4; + L4: + nextToken(); + if (token.value == TOKidentifier) + { ai = token.ident; + nextToken(); + } + else + ai = NULL; + at = NULL; // no type + ae = NULL; // no default argument + if (token.value == TOKassign) // = defaultArg + { nextToken(); + ae = parseDefaultInitExp(); + hasdefault = 1; + } + else + { if (hasdefault) + error("default argument expected for alias %s", + ai ? ai->toChars() : ""); + } + goto L3; +#endif + + default: + Ldefault: + { stc = storageClass & (STCin | STCout | STCref | STClazy); + if (stc & (stc - 1)) // if stc is not a power of 2 + error("incompatible parameter storage classes"); + if ((storageClass & (STCconst | STCout)) == (STCconst | STCout)) + error("out cannot be const"); + if ((storageClass & (STCimmutable | STCout)) == (STCimmutable | STCout)) + error("out cannot be immutable"); + if ((storageClass & STCscope) && (storageClass & (STCref | STCout))) + error("scope cannot be ref or out"); + + Token *t; + if (tpl && !stc && token.value == TOKidentifier && + (t = peek(&token), (t->value == TOKcomma || t->value == TOKrparen))) + { Identifier *id = Lexer::uniqueId("__T"); + at = new TypeIdentifier(loc, id); + if (!*tpl) + *tpl = new TemplateParameters(); + TemplateParameter *tp = new TemplateTypeParameter(loc, id, NULL, NULL); + (*tpl)->push(tp); + + ai = token.ident; + nextToken(); + } + else + at = parseType(&ai); + + ae = NULL; + if (token.value == TOKassign) // = defaultArg + { nextToken(); + ae = parseDefaultInitExp(); + hasdefault = 1; + } + else + { if (hasdefault) + error("default argument expected for %s", + ai ? ai->toChars() : at->toChars()); + } + if (token.value == TOKdotdotdot) + { /* This is: + * at ai ... + */ + + if (storageClass & (STCout | STCref)) + error("variadic argument cannot be out or ref"); + varargs = 2; + a = new Parameter(storageClass, at, ai, ae); + arguments->push(a); + nextToken(); + break; + } + L3: + a = new Parameter(storageClass, at, ai, ae); + arguments->push(a); + if (token.value == TOKcomma) + { nextToken(); + goto L1; + } + break; + } + } + break; + } + break; + + L1: ; + } + check(TOKrparen); + *pvarargs = varargs; + return arguments; +} + + +/************************************* + */ + +EnumDeclaration *Parser::parseEnum() +{ EnumDeclaration *e; + Identifier *id; + Type *memtype; + Loc loc = this->loc; + + //printf("Parser::parseEnum()\n"); + nextToken(); + if (token.value == TOKidentifier) + { id = token.ident; + nextToken(); + } + else + id = NULL; + + if (token.value == TOKcolon) + { + nextToken(); + memtype = parseBasicType(); + memtype = parseDeclarator(memtype, NULL, NULL); + } + else + memtype = NULL; + + e = new EnumDeclaration(loc, id, memtype); + if (token.value == TOKsemicolon && id) + nextToken(); + else if (token.value == TOKlcurly) + { + //printf("enum definition\n"); + e->members = new Dsymbols(); + nextToken(); + unsigned char *comment = token.blockComment; + while (token.value != TOKrcurly) + { + /* Can take the following forms: + * 1. ident + * 2. ident = value + * 3. type ident = value + */ + + loc = this->loc; + + Type *type = NULL; + Identifier *ident; + Token *tp = peek(&token); + if (token.value == TOKidentifier && + (tp->value == TOKassign || tp->value == TOKcomma || tp->value == TOKrcurly)) + { + ident = token.ident; + type = NULL; + nextToken(); + } + else + { + type = parseType(&ident, NULL); + if (id || memtype) + error("type only allowed if anonymous enum and no enum type"); + } + + Expression *value; + if (token.value == TOKassign) + { + nextToken(); + value = parseAssignExp(); + } + else + { value = NULL; + if (type) + error("if type, there must be an initializer"); + } + + EnumMember *em = new EnumMember(loc, ident, value, type); + e->members->push(em); + + if (token.value == TOKrcurly) + ; + else + { addComment(em, comment); + comment = NULL; + check(TOKcomma); + } + addComment(em, comment); + comment = token.blockComment; + + if (token.value == TOKeof) + { error("premature end of file"); + break; + } + } + nextToken(); + } + else + error("enum declaration is invalid"); + + //printf("-parseEnum() %s\n", e->toChars()); + return e; +} + +/******************************** + * Parse struct, union, interface, class. + */ + +Dsymbol *Parser::parseAggregate() +{ AggregateDeclaration *a = NULL; + int anon = 0; + enum TOK tok; + Identifier *id; + TemplateParameters *tpl = NULL; + Expression *constraint = NULL; + + //printf("Parser::parseAggregate()\n"); + tok = token.value; + nextToken(); + if (token.value != TOKidentifier) + { id = NULL; + } + else + { id = token.ident; + nextToken(); + + if (token.value == TOKlparen) + { // Class template declaration. + + // Gather template parameter list + tpl = parseTemplateParameterList(); + constraint = parseConstraint(); + } + } + + Loc loc = this->loc; + switch (tok) + { case TOKclass: + case TOKinterface: + { + if (!id) + error("anonymous classes not allowed"); + + // Collect base class(es) + BaseClasses *baseclasses = NULL; + if (token.value == TOKcolon) + { + nextToken(); + baseclasses = parseBaseClasses(); + + if (token.value != TOKlcurly) + error("members expected"); + } + + if (tok == TOKclass) + a = new ClassDeclaration(loc, id, baseclasses); + else + a = new InterfaceDeclaration(loc, id, baseclasses); + break; + } + + case TOKstruct: + if (id) + a = new StructDeclaration(loc, id); + else + anon = 1; + break; + + case TOKunion: + if (id) + a = new UnionDeclaration(loc, id); + else + anon = 2; + break; + + default: + assert(0); + break; + } + if (a && token.value == TOKsemicolon) + { nextToken(); + } + else if (token.value == TOKlcurly) + { + //printf("aggregate definition\n"); + nextToken(); + Dsymbols *decl = parseDeclDefs(0); + if (token.value != TOKrcurly) + error("} expected following member declarations in aggregate"); + nextToken(); + if (anon) + { + /* Anonymous structs/unions are more like attributes. + */ + return new AnonDeclaration(loc, anon - 1, decl); + } + else + a->members = decl; + } + else + { + error("{ } expected following aggregate declaration"); + a = new StructDeclaration(loc, NULL); + } + + if (tpl) + { // Wrap a template around the aggregate declaration + + Dsymbols *decldefs = new Dsymbols(); + decldefs->push(a); + TemplateDeclaration *tempdecl = + new TemplateDeclaration(loc, id, tpl, constraint, decldefs, 0); + return tempdecl; + } + + return a; +} + +/******************************************* + */ + +BaseClasses *Parser::parseBaseClasses() +{ + BaseClasses *baseclasses = new BaseClasses(); + + for (; 1; nextToken()) + { + bool prot = false; + enum PROT protection = PROTpublic; + switch (token.value) + { + case TOKprivate: + prot = true; + protection = PROTprivate; + nextToken(); + break; + case TOKpackage: + prot = true; + protection = PROTpackage; + nextToken(); + break; + case TOKprotected: + prot = true; + protection = PROTprotected; + nextToken(); + break; + case TOKpublic: + prot = true; + protection = PROTpublic; + nextToken(); + break; + } + if (prot && !global.params.useDeprecated) + error("use of base class protection is deprecated"); + if (token.value == TOKidentifier) + { + BaseClass *b = new BaseClass(parseBasicType(), protection); + baseclasses->push(b); + if (token.value != TOKcomma) + break; + } + else + { + error("base classes expected instead of %s", token.toChars()); + return NULL; + } + } + return baseclasses; +} + +/************************************** + * Parse constraint. + * Constraint is of the form: + * if ( ConstraintExpression ) + */ + +#if DMDV2 +Expression *Parser::parseConstraint() +{ Expression *e = NULL; + + if (token.value == TOKif) + { + nextToken(); // skip over 'if' + check(TOKlparen); + e = parseExpression(); + check(TOKrparen); + } + return e; +} +#endif + +/************************************** + * Parse a TemplateDeclaration. + */ + +TemplateDeclaration *Parser::parseTemplateDeclaration(int ismixin) +{ + TemplateDeclaration *tempdecl; + Identifier *id; + TemplateParameters *tpl; + Dsymbols *decldefs; + Expression *constraint = NULL; + Loc loc = this->loc; + + nextToken(); + if (token.value != TOKidentifier) + { error("TemplateIdentifier expected following template"); + goto Lerr; + } + id = token.ident; + nextToken(); + tpl = parseTemplateParameterList(); + if (!tpl) + goto Lerr; + + constraint = parseConstraint(); + + if (token.value != TOKlcurly) + { error("members of template declaration expected"); + goto Lerr; + } + else + { + nextToken(); + decldefs = parseDeclDefs(0); + if (token.value != TOKrcurly) + { error("template member expected"); + goto Lerr; + } + nextToken(); + } + + tempdecl = new TemplateDeclaration(loc, id, tpl, constraint, decldefs, ismixin); + return tempdecl; + +Lerr: + return NULL; +} + +/****************************************** + * Parse template parameter list. + * Input: + * flag 0: parsing "( list )" + * 1: parsing non-empty "list )" + */ + +TemplateParameters *Parser::parseTemplateParameterList(int flag) +{ + TemplateParameters *tpl = new TemplateParameters(); + + if (!flag && token.value != TOKlparen) + { error("parenthesized TemplateParameterList expected following TemplateIdentifier"); + goto Lerr; + } + nextToken(); + + // Get array of TemplateParameters + if (flag || token.value != TOKrparen) + { int isvariadic = 0; + + while (token.value != TOKrparen) + { TemplateParameter *tp; + Identifier *tp_ident = NULL; + Type *tp_spectype = NULL; + Type *tp_valtype = NULL; + Type *tp_defaulttype = NULL; + Expression *tp_specvalue = NULL; + Expression *tp_defaultvalue = NULL; + Token *t; + + // Get TemplateParameter + + // First, look ahead to see if it is a TypeParameter or a ValueParameter + t = peek(&token); + if (token.value == TOKalias) + { // AliasParameter + nextToken(); + Type *spectype = NULL; + if (isDeclaration(&token, 2, TOKreserved, NULL)) + { + spectype = parseType(&tp_ident); + } + else + { + if (token.value != TOKidentifier) + { error("identifier expected for template alias parameter"); + goto Lerr; + } + tp_ident = token.ident; + nextToken(); + } + Object *spec = NULL; + if (token.value == TOKcolon) // : Type + { + nextToken(); + if (isDeclaration(&token, 0, TOKreserved, NULL)) + spec = parseType(); + else + spec = parseCondExp(); + } + Object *def = NULL; + if (token.value == TOKassign) // = Type + { + nextToken(); + if (isDeclaration(&token, 0, TOKreserved, NULL)) + def = parseType(); + else + def = parseCondExp(); + } + tp = new TemplateAliasParameter(loc, tp_ident, spectype, spec, def); + } + else if (t->value == TOKcolon || t->value == TOKassign || + t->value == TOKcomma || t->value == TOKrparen) + { // TypeParameter + if (token.value != TOKidentifier) + { error("identifier expected for template type parameter"); + goto Lerr; + } + tp_ident = token.ident; + nextToken(); + if (token.value == TOKcolon) // : Type + { + nextToken(); + tp_spectype = parseType(); + } + if (token.value == TOKassign) // = Type + { + nextToken(); + tp_defaulttype = parseType(); + } + tp = new TemplateTypeParameter(loc, tp_ident, tp_spectype, tp_defaulttype); + } + else if (token.value == TOKidentifier && t->value == TOKdotdotdot) + { // ident... + if (isvariadic) + error("variadic template parameter must be last"); + isvariadic = 1; + tp_ident = token.ident; + nextToken(); + nextToken(); + tp = new TemplateTupleParameter(loc, tp_ident); + } +#if DMDV2 + else if (token.value == TOKthis) + { // ThisParameter + nextToken(); + if (token.value != TOKidentifier) + { error("identifier expected for template this parameter"); + goto Lerr; + } + tp_ident = token.ident; + nextToken(); + if (token.value == TOKcolon) // : Type + { + nextToken(); + tp_spectype = parseType(); + } + if (token.value == TOKassign) // = Type + { + nextToken(); + tp_defaulttype = parseType(); + } + tp = new TemplateThisParameter(loc, tp_ident, tp_spectype, tp_defaulttype); + } +#endif + else + { // ValueParameter + tp_valtype = parseType(&tp_ident); + if (!tp_ident) + { + error("identifier expected for template value parameter"); + tp_ident = new Identifier("error", TOKidentifier); + } + if (token.value == TOKcolon) // : CondExpression + { + nextToken(); + tp_specvalue = parseCondExp(); + } + if (token.value == TOKassign) // = CondExpression + { + nextToken(); + tp_defaultvalue = parseDefaultInitExp(); + } + tp = new TemplateValueParameter(loc, tp_ident, tp_valtype, tp_specvalue, tp_defaultvalue); + } + tpl->push(tp); + if (token.value != TOKcomma) + break; + nextToken(); + } + } + check(TOKrparen); +Lerr: + return tpl; +} + +/****************************************** + * Parse template mixin. + * mixin Foo; + * mixin Foo!(args); + * mixin a.b.c!(args).Foo!(args); + * mixin Foo!(args) identifier; + * mixin typeof(expr).identifier!(args); + */ + +Dsymbol *Parser::parseMixin() +{ + TemplateMixin *tm; + Identifier *id; + Type *tqual; + Objects *tiargs; + Identifiers *idents; + + //printf("parseMixin()\n"); + nextToken(); + tqual = NULL; + if (token.value == TOKdot) + { + id = Id::empty; + } + else + { + if (token.value == TOKtypeof) + { + tqual = parseTypeof(); + check(TOKdot); + } + else if (token.value == TOKvector) + { + tqual = parseVector(); + check(TOKdot); + } + if (token.value != TOKidentifier) + { + error("identifier expected, not %s", token.toChars()); + id = Id::empty; + } + else + id = token.ident; + nextToken(); + } + + idents = new Identifiers(); + while (1) + { + tiargs = NULL; + if (token.value == TOKnot) + { + nextToken(); + if (token.value == TOKlparen) + tiargs = parseTemplateArgumentList(); + else + tiargs = parseTemplateArgument(); + } + + if (token.value != TOKdot) + break; + + if (tiargs) + { TemplateInstance *tempinst = new TemplateInstance(loc, id); + tempinst->tiargs = tiargs; + id = (Identifier *)tempinst; + tiargs = NULL; + } + idents->push(id); + + nextToken(); + if (token.value != TOKidentifier) + { error("identifier expected following '.' instead of '%s'", token.toChars()); + break; + } + id = token.ident; + nextToken(); + } + idents->push(id); + + if (token.value == TOKidentifier) + { + id = token.ident; + nextToken(); + } + else + id = NULL; + + tm = new TemplateMixin(loc, id, tqual, idents, tiargs); + if (token.value != TOKsemicolon) + error("';' expected after mixin"); + nextToken(); + + return tm; +} + +/****************************************** + * Parse template argument list. + * Input: + * current token is opening '(' + * Output: + * current token is one after closing ')' + */ + +Objects *Parser::parseTemplateArgumentList() +{ + //printf("Parser::parseTemplateArgumentList()\n"); + if (token.value != TOKlparen && token.value != TOKlcurly) + { error("!(TemplateArgumentList) expected following TemplateIdentifier"); + return new Objects(); + } + return parseTemplateArgumentList2(); +} + +Objects *Parser::parseTemplateArgumentList2() +{ + //printf("Parser::parseTemplateArgumentList2()\n"); + Objects *tiargs = new Objects(); + enum TOK endtok = TOKrparen; + nextToken(); + + // Get TemplateArgumentList + while (token.value != endtok) + { + // See if it is an Expression or a Type + if (isDeclaration(&token, 0, TOKreserved, NULL)) + { // Template argument is a type + Type *ta = parseType(); + tiargs->push(ta); + } + else + { // Template argument is an expression + Expression *ea = parseAssignExp(); + + if (ea->op == TOKfunction && ((FuncExp *)ea)->td) + tiargs->push(((FuncExp *)ea)->td); + else + tiargs->push(ea); + } + if (token.value != TOKcomma) + break; + nextToken(); + } + check(endtok, "template argument list"); + return tiargs; +} + +/***************************** + * Parse single template argument, to support the syntax: + * foo!arg + * Input: + * current token is the arg + */ + +Objects *Parser::parseTemplateArgument() +{ + //printf("parseTemplateArgument()\n"); + Objects *tiargs = new Objects(); + Type *ta; + switch (token.value) + { + case TOKidentifier: + ta = new TypeIdentifier(loc, token.ident); + goto LabelX; + + case TOKvector: + ta = parseVector(); + goto LabelX; + + case BASIC_TYPES_X(ta): + tiargs->push(ta); + nextToken(); + break; + + case TOKint32v: + case TOKuns32v: + case TOKint64v: + case TOKuns64v: + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + case TOKnull: + case TOKtrue: + case TOKfalse: + case TOKcharv: + case TOKwcharv: + case TOKdcharv: + case TOKstring: + case TOKfile: + case TOKline: + case TOKthis: + { // Template argument is an expression + Expression *ea = parsePrimaryExp(); + tiargs->push(ea); + break; + } + + default: + error("template argument expected following !"); + break; + } + if (token.value == TOKnot) + error("multiple ! arguments are not allowed"); + return tiargs; +} + +Import *Parser::parseImport(Dsymbols *decldefs, int isstatic) +{ Import *s; + Identifier *id; + Identifier *aliasid = NULL; + Identifiers *a; + Loc loc; + + //printf("Parser::parseImport()\n"); + do + { + L1: + nextToken(); + if (token.value != TOKidentifier) + { error("Identifier expected following import"); + break; + } + + loc = this->loc; + a = NULL; + id = token.ident; + nextToken(); + if (!aliasid && token.value == TOKassign) + { + aliasid = id; + goto L1; + } + while (token.value == TOKdot) + { + if (!a) + a = new Identifiers(); + a->push(id); + nextToken(); + if (token.value != TOKidentifier) + { error("identifier expected following package"); + break; + } + id = token.ident; + nextToken(); + } + + s = new Import(loc, a, id, aliasid, isstatic); + decldefs->push(s); + + /* Look for + * : alias=name, alias=name; + * syntax. + */ + if (token.value == TOKcolon) + { + do + { Identifier *name; + + nextToken(); + if (token.value != TOKidentifier) + { error("Identifier expected following :"); + break; + } + Identifier *alias = token.ident; + nextToken(); + if (token.value == TOKassign) + { + nextToken(); + if (token.value != TOKidentifier) + { error("Identifier expected following %s=", alias->toChars()); + break; + } + name = token.ident; + nextToken(); + } + else + { name = alias; + alias = NULL; + } + s->addAlias(name, alias); + } while (token.value == TOKcomma); + break; // no comma-separated imports of this form + } + + aliasid = NULL; + } while (token.value == TOKcomma); + + if (token.value == TOKsemicolon) + nextToken(); + else + { + error("';' expected"); + nextToken(); + } + + return NULL; +} + +#if DMDV2 +Type *Parser::parseType(Identifier **pident, TemplateParameters **tpl) +{ Type *t; + + /* Take care of the storage class prefixes that + * serve as type attributes: + * const shared, shared const, const, invariant, shared + */ + if (token.value == TOKconst && peekNext() == TOKshared && peekNext2() != TOKlparen || + token.value == TOKshared && peekNext() == TOKconst && peekNext2() != TOKlparen) + { + nextToken(); + nextToken(); + /* shared const type + */ + t = parseType(pident, tpl); + t = t->makeSharedConst(); + return t; + } + else if (token.value == TOKwild && peekNext() == TOKshared && peekNext2() != TOKlparen || + token.value == TOKshared && peekNext() == TOKwild && peekNext2() != TOKlparen) + { + nextToken(); + nextToken(); + /* shared wild type + */ + t = parseType(pident, tpl); + t = t->makeSharedWild(); + return t; + } + else if (token.value == TOKconst && peekNext() != TOKlparen) + { + nextToken(); + /* const type + */ + t = parseType(pident, tpl); + t = t->makeConst(); + return t; + } + else if ((token.value == TOKinvariant || token.value == TOKimmutable) && + peekNext() != TOKlparen) + { + nextToken(); + /* invariant type + */ + t = parseType(pident, tpl); + t = t->makeInvariant(); + return t; + } + else if (token.value == TOKshared && peekNext() != TOKlparen) + { + nextToken(); + /* shared type + */ + t = parseType(pident, tpl); + t = t->makeShared(); + return t; + } + else if (token.value == TOKwild && peekNext() != TOKlparen) + { + nextToken(); + /* wild type + */ + t = parseType(pident, tpl); + t = t->makeWild(); + return t; + } + else + t = parseBasicType(); + t = parseDeclarator(t, pident, tpl); + return t; +} +#endif + +Type *Parser::parseBasicType() +{ Type *t; + Identifier *id; + TypeQualified *tid; + + //printf("parseBasicType()\n"); + switch (token.value) + { + case BASIC_TYPES_X(t): + nextToken(); + break; + + case TOKthis: + case TOKsuper: + case TOKidentifier: + id = token.ident; + nextToken(); + if (token.value == TOKnot) + { // ident!(template_arguments) + TemplateInstance *tempinst = new TemplateInstance(loc, id); + nextToken(); + if (token.value == TOKlparen) + // ident!(template_arguments) + tempinst->tiargs = parseTemplateArgumentList(); + else + // ident!template_argument + tempinst->tiargs = parseTemplateArgument(); + tid = new TypeInstance(loc, tempinst); + goto Lident2; + } + Lident: + tid = new TypeIdentifier(loc, id); + Lident2: + while (token.value == TOKdot) + { nextToken(); + if (token.value != TOKidentifier) + { error("identifier expected following '.' instead of '%s'", token.toChars()); + break; + } + id = token.ident; + nextToken(); + if (token.value == TOKnot) + { + TemplateInstance *tempinst = new TemplateInstance(loc, id); + nextToken(); + if (token.value == TOKlparen) + // ident!(template_arguments) + tempinst->tiargs = parseTemplateArgumentList(); + else + // ident!template_argument + tempinst->tiargs = parseTemplateArgument(); + tid->addIdent((Identifier *)tempinst); + } + else + tid->addIdent(id); + } + t = tid; + break; + + case TOKdot: + // Leading . as in .foo + id = Id::empty; + goto Lident; + + case TOKtypeof: + // typeof(expression) + tid = parseTypeof(); + goto Lident2; + + case TOKvector: + t = parseVector(); + break; + + case TOKconst: + // const(type) + nextToken(); + check(TOKlparen); + t = parseType(); + check(TOKrparen); + if (t->isImmutable()) + ; + else if (t->isShared()) + t = t->makeSharedConst(); + else + t = t->makeConst(); + break; + + case TOKinvariant: + if (!global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + case TOKimmutable: + // invariant(type) + nextToken(); + check(TOKlparen); + t = parseType(); + check(TOKrparen); + t = t->makeInvariant(); + break; + + case TOKshared: + // shared(type) + nextToken(); + check(TOKlparen); + t = parseType(); + check(TOKrparen); + if (t->isImmutable()) + ; + else if (t->isConst()) + t = t->makeSharedConst(); + else if (t->isWild()) + t = t->makeSharedWild(); + else + t = t->makeShared(); + break; + + case TOKwild: + // wild(type) + nextToken(); + check(TOKlparen); + t = parseType(); + check(TOKrparen); + if (t->isImmutable()/* || t->isConst()*/) + ; + else if (t->isShared()) + t = t->makeSharedWild(); + else + t = t->makeWild(); + break; + + default: + error("basic type expected, not %s", token.toChars()); + t = Type::tint32; + break; + } + return t; +} + +/****************************************** + * Parse things that follow the initial type t. + * t * + * t [] + * t [type] + * t [expression] + * t [expression .. expression] + * t function + * t delegate + */ + +Type *Parser::parseBasicType2(Type *t) +{ + //printf("parseBasicType2()\n"); + while (1) + { + switch (token.value) + { + case TOKmul: + t = new TypePointer(t); + nextToken(); + continue; + + case TOKlbracket: + // Handle []. Make sure things like + // int[3][1] a; + // is (array[1] of array[3] of int) + nextToken(); + if (token.value == TOKrbracket) + { + t = new TypeDArray(t); // [] + nextToken(); + } + else if (isDeclaration(&token, 0, TOKrbracket, NULL)) + { // It's an associative array declaration + + //printf("it's an associative array\n"); + Type *index = parseType(); // [ type ] + t = new TypeAArray(t, index); + check(TOKrbracket); + } + else + { + //printf("it's type[expression]\n"); + inBrackets++; + Expression *e = parseAssignExp(); // [ expression ] + if (token.value == TOKslice) + { + nextToken(); + Expression *e2 = parseAssignExp(); // [ exp .. exp ] + t = new TypeSlice(t, e, e2); + } + else + t = new TypeSArray(t,e); + inBrackets--; + check(TOKrbracket); + } + continue; + + case TOKdelegate: + case TOKfunction: + { // Handle delegate declaration: + // t delegate(parameter list) nothrow pure + // t function(parameter list) nothrow pure + Parameters *arguments; + int varargs; + enum TOK save = token.value; + + nextToken(); + arguments = parseParameters(&varargs); + + StorageClass stc = parsePostfix(); + if (stc & (STCconst | STCimmutable | STCshared | STCwild)) + error("const/immutable/shared/inout attributes are only valid for non-static member functions"); + + TypeFunction *tf = new TypeFunction(arguments, t, varargs, linkage, stc); + + if (save == TOKdelegate) + t = new TypeDelegate(tf); + else + t = new TypePointer(tf); // pointer to function + continue; + } + + default: + return t; + } + assert(0); + } + assert(0); + return NULL; +} + +Type *Parser::parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl, StorageClass storage_class, int* pdisable) +{ Type *ts; + + //printf("parseDeclarator(tpl = %p)\n", tpl); + t = parseBasicType2(t); + + switch (token.value) + { + + case TOKidentifier: + if (pident) + *pident = token.ident; + else + error("unexpected identifer '%s' in declarator", token.ident->toChars()); + ts = t; + nextToken(); + break; + + case TOKlparen: + if (peekNext() == TOKmul || // like: T (*fp)(); + peekNext() == TOKlparen // like: T ((*fp))(); + /* || peekNext() == TOKlbracket*/) // like: T ([] a) + { + /* Parse things with parentheses around the identifier, like: + * int (*ident[3])[] + * although the D style would be: + * int[]*[3] ident + */ + if (!global.params.useDeprecated) + { + error("C-style function pointer and pointer to array syntax is deprecated. Use 'function' to declare function pointers"); + } + nextToken(); + ts = parseDeclarator(t, pident); + check(TOKrparen); + break; + } + ts = t; + { + Token *peekt = &token; + /* Completely disallow C-style things like: + * T (a); + * Improve error messages for the common bug of a missing return type + * by looking to see if (a) looks like a parameter list. + */ + if (isParameters(&peekt)) { + error("function declaration without return type. " + "(Note that constructors are always named 'this')"); + } + else + error("unexpected ( in declarator"); + } + break; + + default: + ts = t; + break; + } + + // parse DeclaratorSuffixes + while (1) + { + switch (token.value) + { +#if CARRAYDECL + /* Support C style array syntax: + * int ident[] + * as opposed to D-style: + * int[] ident + */ + case TOKlbracket: + { // This is the old C-style post [] syntax. + TypeNext *ta; + nextToken(); + if (token.value == TOKrbracket) + { // It's a dynamic array + ta = new TypeDArray(t); // [] + nextToken(); + } + else if (isDeclaration(&token, 0, TOKrbracket, NULL)) + { // It's an associative array + + //printf("it's an associative array\n"); + Type *index = parseType(); // [ type ] + check(TOKrbracket); + ta = new TypeAArray(t, index); + } + else + { + //printf("It's a static array\n"); + Expression *e = parseAssignExp(); // [ expression ] + ta = new TypeSArray(t, e); + check(TOKrbracket); + } + + /* Insert ta into + * ts -> ... -> t + * so that + * ts -> ... -> ta -> t + */ + Type **pt; + for (pt = &ts; *pt != t; pt = &((TypeNext*)*pt)->next) + ; + *pt = ta; + continue; + } +#endif + case TOKlparen: + { + if (tpl) + { + /* Look ahead to see if this is (...)(...), + * i.e. a function template declaration + */ + if (peekPastParen(&token)->value == TOKlparen) + { + //printf("function template declaration\n"); + + // Gather template parameter list + *tpl = parseTemplateParameterList(); + } + } + + int varargs; + Parameters *arguments = parseParameters(&varargs); + + /* Parse const/immutable/shared/inout/nothrow/pure postfix + */ + StorageClass stc = parsePostfix(); + stc |= storage_class; // merge prefix storage classes + Type *tf = new TypeFunction(arguments, t, varargs, linkage, stc); + tf = tf->addSTC(stc); + if (pdisable) + *pdisable = stc & STCdisable ? 1 : 0; + + /* Insert tf into + * ts -> ... -> t + * so that + * ts -> ... -> tf -> t + */ + Type **pt; + for (pt = &ts; *pt != t; pt = &((TypeNext*)*pt)->next) + ; + *pt = tf; + break; + } + } + break; + } + + return ts; +} + +/********************************** + * Parse Declarations. + * These can be: + * 1. declarations at global/class level + * 2. declarations at statement level + * Return array of Declaration *'s. + */ + +Dsymbols *Parser::parseDeclarations(StorageClass storage_class, unsigned char *comment) +{ + StorageClass stc; + int disable; + Type *ts; + Type *t; + Type *tfirst; + Identifier *ident; + Dsymbols *a; + enum TOK tok = TOKreserved; + enum LINK link = linkage; + + //printf("parseDeclarations() %s\n", token.toChars()); + if (!comment) + comment = token.blockComment; + + if (storage_class) + { ts = NULL; // infer type + goto L2; + } + + switch (token.value) + { + case TOKalias: + /* Look for: + * alias identifier this; + */ + tok = token.value; + nextToken(); + if (token.value == TOKidentifier && peek(&token)->value == TOKthis) + { + AliasThis *s = new AliasThis(this->loc, token.ident); + nextToken(); + check(TOKthis); + check(TOKsemicolon); + a = new Dsymbols(); + a->push(s); + addComment(s, comment); + return a; + } + break; + case TOKtypedef: + if (!global.params.useDeprecated) + error("use of typedef is deprecated; use alias instead"); + tok = token.value; + nextToken(); + break; + } + + storage_class = STCundefined; + while (1) + { + switch (token.value) + { + case TOKconst: + if (peek(&token)->value == TOKlparen) + break; // const as type constructor + stc = STCconst; // const as storage class + goto L1; + + case TOKinvariant: + case TOKimmutable: + if (peek(&token)->value == TOKlparen) + break; + if (token.value == TOKinvariant && !global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + stc = STCimmutable; + goto L1; + + case TOKshared: + if (peek(&token)->value == TOKlparen) + break; + stc = STCshared; + goto L1; + + case TOKwild: + if (peek(&token)->value == TOKlparen) + break; + stc = STCwild; + goto L1; + + case TOKstatic: stc = STCstatic; goto L1; + case TOKfinal: stc = STCfinal; goto L1; + case TOKauto: stc = STCauto; goto L1; + case TOKscope: stc = STCscope; goto L1; + case TOKoverride: stc = STCoverride; goto L1; + case TOKabstract: stc = STCabstract; goto L1; + case TOKsynchronized: stc = STCsynchronized; goto L1; + case TOKdeprecated: stc = STCdeprecated; goto L1; +#if DMDV2 + case TOKnothrow: stc = STCnothrow; goto L1; + case TOKpure: stc = STCpure; goto L1; + case TOKref: stc = STCref; goto L1; + case TOKtls: stc = STCtls; goto L1; + case TOKgshared: stc = STCgshared; goto L1; + case TOKenum: stc = STCmanifest; goto L1; + case TOKat: stc = parseAttribute(); goto L1; +#endif + L1: + if (storage_class & stc) + error("redundant storage class '%s'", token.toChars()); + storage_class = storage_class | stc; + composeStorageClass(storage_class); + nextToken(); + continue; + + case TOKextern: + if (peek(&token)->value != TOKlparen) + { stc = STCextern; + goto L1; + } + + link = parseLinkage(); + continue; + + default: + break; + } + break; + } + + /* Look for auto initializers: + * storage_class identifier = initializer; + */ + if (storage_class && + token.value == TOKidentifier && + peek(&token)->value == TOKassign) + { + return parseAutoDeclarations(storage_class, comment); + } + + if (token.value == TOKclass) + { + AggregateDeclaration *s = (AggregateDeclaration *)parseAggregate(); + s->storage_class |= storage_class; + Dsymbols *a = new Dsymbols(); + a->push(s); + addComment(s, comment); + return a; + } + + /* Look for return type inference for template functions. + */ + { + Token *tk; + if (storage_class && + token.value == TOKidentifier && + (tk = peek(&token))->value == TOKlparen && + skipParens(tk, &tk) && + ((tk = peek(tk)), 1) && + skipAttributes(tk, &tk) && + (tk->value == TOKlparen || + tk->value == TOKlcurly) + ) + { + ts = NULL; + } + else + { + ts = parseBasicType(); + ts = parseBasicType2(ts); + } + } + +L2: + tfirst = NULL; + a = new Dsymbols(); + + while (1) + { + Loc loc = this->loc; + TemplateParameters *tpl = NULL; + + ident = NULL; + t = parseDeclarator(ts, &ident, &tpl, storage_class, &disable); + assert(t); + if (!tfirst) + tfirst = t; + else if (t != tfirst) + error("multiple declarations must have the same type, not %s and %s", + tfirst->toChars(), t->toChars()); + if (!ident) + error("no identifier for declarator %s", t->toChars()); + + if (tok == TOKtypedef || tok == TOKalias) + { Declaration *v; + Initializer *init = NULL; + + /* Aliases can no longer have multiple declarators, storage classes, + * linkages, or auto declarations. + * These never made any sense, anyway. + * The code below needs to be fixed to reject them. + * The grammar has already been fixed to preclude them. + */ + + if (token.value == TOKassign) + { + nextToken(); + init = parseInitializer(); + } + if (tok == TOKtypedef) + { v = new TypedefDeclaration(loc, ident, t, init); + if (!global.params.useDeprecated) + error("use of typedef is deprecated; use alias instead"); + } + else + { if (init) + error("alias cannot have initializer"); + v = new AliasDeclaration(loc, ident, t); + } + v->storage_class = storage_class; + if (link == linkage) + a->push(v); + else + { + Dsymbols *ax = new Dsymbols(); + ax->push(v); + Dsymbol *s = new LinkDeclaration(link, ax); + a->push(s); + } + switch (token.value) + { case TOKsemicolon: + nextToken(); + addComment(v, comment); + break; + + case TOKcomma: + nextToken(); + addComment(v, comment); + continue; + + default: + error("semicolon expected to close %s declaration", Token::toChars(tok)); + break; + } + } + else if (t->ty == Tfunction) + { + TypeFunction *tf = (TypeFunction *)t; + Expression *constraint = NULL; +#if 0 + if (Parameter::isTPL(tf->parameters)) + { + if (!tpl) + tpl = new TemplateParameters(); + } +#endif + + //printf("%s funcdecl t = %s, storage_class = x%lx\n", loc.toChars(), t->toChars(), storage_class); + + FuncDeclaration *f = + new FuncDeclaration(loc, 0, ident, storage_class | (disable ? STCdisable : 0), t); + addComment(f, comment); + if (tpl) + constraint = parseConstraint(); + parseContracts(f); + addComment(f, NULL); + Dsymbol *s; + if (link == linkage) + { + s = f; + } + else + { + Dsymbols *ax = new Dsymbols(); + ax->push(f); + s = new LinkDeclaration(link, ax); + } + /* A template parameter list means it's a function template + */ + if (tpl) + { + // Wrap a template around the function declaration + Dsymbols *decldefs = new Dsymbols(); + decldefs->push(s); + TemplateDeclaration *tempdecl = + new TemplateDeclaration(loc, s->ident, tpl, constraint, decldefs, 0); + s = tempdecl; + } + addComment(s, comment); + a->push(s); + } + else + { + Initializer *init = NULL; + if (token.value == TOKassign) + { + nextToken(); + init = parseInitializer(); + } + + VarDeclaration *v = new VarDeclaration(loc, t, ident, init); + v->storage_class = storage_class; + if (link == linkage) + a->push(v); + else + { + Dsymbols *ax = new Dsymbols(); + ax->push(v); + Dsymbol *s = new LinkDeclaration(link, ax); + a->push(s); + } + switch (token.value) + { case TOKsemicolon: + nextToken(); + addComment(v, comment); + break; + + case TOKcomma: + nextToken(); + addComment(v, comment); + continue; + + default: + error("semicolon expected, not '%s'", token.toChars()); + break; + } + } + break; + } + return a; +} + +/***************************************** + * Parse auto declarations of the form: + * storageClass ident = init, ident = init, ... ; + * and return the array of them. + * Starts with token on the first ident. + * Ends with scanner past closing ';' + */ + +#if DMDV2 +Dsymbols *Parser::parseAutoDeclarations(StorageClass storageClass, unsigned char *comment) +{ + Dsymbols *a = new Dsymbols; + + while (1) + { + Identifier *ident = token.ident; + nextToken(); // skip over ident + assert(token.value == TOKassign); + nextToken(); // skip over '=' + Initializer *init = parseInitializer(); + VarDeclaration *v = new VarDeclaration(loc, NULL, ident, init); + v->storage_class = storageClass; + a->push(v); + if (token.value == TOKsemicolon) + { + nextToken(); + addComment(v, comment); + } + else if (token.value == TOKcomma) + { + nextToken(); + if (token.value == TOKidentifier && + peek(&token)->value == TOKassign) + { + addComment(v, comment); + continue; + } + else + error("Identifier expected following comma"); + } + else + error("semicolon expected following auto declaration, not '%s'", token.toChars()); + break; + } + return a; +} +#endif + +/***************************************** + * Parse contracts following function declaration. + */ + +void Parser::parseContracts(FuncDeclaration *f) +{ + enum LINK linksave = linkage; + + // The following is irrelevant, as it is overridden by sc->linkage in + // TypeFunction::semantic + linkage = LINKd; // nested functions have D linkage +L1: + switch (token.value) + { + case TOKlcurly: + if (f->frequire || f->fensure) + error("missing body { ... } after in or out"); + f->fbody = parseStatement(PSsemi); + f->endloc = endloc; + break; + + case TOKbody: + nextToken(); + f->fbody = parseStatement(PScurly); + f->endloc = endloc; + break; + + case TOKsemicolon: + if (f->frequire || f->fensure) + error("missing body { ... } after in or out"); + nextToken(); + break; + +#if 0 // Do we want this for function declarations, so we can do: + // int x, y, foo(), z; + case TOKcomma: + nextToken(); + continue; +#endif + +#if 0 // Dumped feature + case TOKthrow: + if (!f->fthrows) + f->fthrows = new Types(); + nextToken(); + check(TOKlparen); + while (1) + { + Type *tb = parseBasicType(); + f->fthrows->push(tb); + if (token.value == TOKcomma) + { nextToken(); + continue; + } + break; + } + check(TOKrparen); + goto L1; +#endif + + case TOKin: + nextToken(); + if (f->frequire) + error("redundant 'in' statement"); + f->frequire = parseStatement(PScurly | PSscope); + goto L1; + + case TOKout: + // parse: out (identifier) { statement } + nextToken(); + if (token.value != TOKlcurly) + { + check(TOKlparen); + if (token.value != TOKidentifier) + error("(identifier) following 'out' expected, not %s", token.toChars()); + f->outId = token.ident; + nextToken(); + check(TOKrparen); + } + if (f->fensure) + error("redundant 'out' statement"); + f->fensure = parseStatement(PScurly | PSscope); + goto L1; + + default: + if (!f->frequire && !f->fensure) // allow these even with no body + error("semicolon expected following function declaration"); + break; + } + linkage = linksave; +} + +/***************************************** + * Parse initializer for variable declaration. + */ + +Initializer *Parser::parseInitializer() +{ + StructInitializer *is; + ArrayInitializer *ia; + ExpInitializer *ie; + Expression *e; + Identifier *id; + Initializer *value; + int comma; + Loc loc = this->loc; + Token *t; + int braces; + int brackets; + + switch (token.value) + { + case TOKlcurly: + /* Scan ahead to see if it is a struct initializer or + * a function literal. + * If it contains a ';', it is a function literal. + * Treat { } as a struct initializer. + */ + braces = 1; + for (t = peek(&token); 1; t = peek(t)) + { + switch (t->value) + { + case TOKsemicolon: + case TOKreturn: + goto Lexpression; + + case TOKlcurly: + braces++; + continue; + + case TOKrcurly: + if (--braces == 0) + break; + continue; + + case TOKeof: + break; + + default: + continue; + } + break; + } + + is = new StructInitializer(loc); + nextToken(); + comma = 2; + while (1) + { + switch (token.value) + { + case TOKidentifier: + if (comma == 1) + error("comma expected separating field initializers"); + t = peek(&token); + if (t->value == TOKcolon) + { + id = token.ident; + nextToken(); + nextToken(); // skip over ':' + } + else + { id = NULL; + } + value = parseInitializer(); + is->addInit(id, value); + comma = 1; + continue; + + case TOKcomma: + if (comma == 2) + error("expression expected, not ','"); + nextToken(); + comma = 2; + continue; + + case TOKrcurly: // allow trailing comma's + nextToken(); + break; + + case TOKeof: + error("found EOF instead of initializer"); + break; + + default: + if (comma == 1) + error("comma expected separating field initializers"); + value = parseInitializer(); + is->addInit(NULL, value); + comma = 1; + continue; + //error("found '%s' instead of field initializer", token.toChars()); + //break; + } + break; + } + return is; + + case TOKlbracket: + /* Scan ahead to see if it is an array initializer or + * an expression. + * If it ends with a ';' ',' or '}', it is an array initializer. + */ + brackets = 1; + for (t = peek(&token); 1; t = peek(t)) + { + switch (t->value) + { + case TOKlbracket: + brackets++; + continue; + + case TOKrbracket: + if (--brackets == 0) + { t = peek(t); + if (t->value != TOKsemicolon && + t->value != TOKcomma && + t->value != TOKrbracket && + t->value != TOKrcurly) + goto Lexpression; + break; + } + continue; + + case TOKeof: + break; + + default: + continue; + } + break; + } + + ia = new ArrayInitializer(loc); + nextToken(); + comma = 2; + while (1) + { + switch (token.value) + { + default: + if (comma == 1) + { error("comma expected separating array initializers, not %s", token.toChars()); + nextToken(); + break; + } + e = parseAssignExp(); + if (!e) + break; + if (token.value == TOKcolon) + { + nextToken(); + value = parseInitializer(); + } + else + { value = new ExpInitializer(e->loc, e); + e = NULL; + } + ia->addInit(e, value); + comma = 1; + continue; + + case TOKlcurly: + case TOKlbracket: + if (comma == 1) + error("comma expected separating array initializers, not %s", token.toChars()); + value = parseInitializer(); + ia->addInit(NULL, value); + comma = 1; + continue; + + case TOKcomma: + if (comma == 2) + error("expression expected, not ','"); + nextToken(); + comma = 2; + continue; + + case TOKrbracket: // allow trailing comma's + nextToken(); + break; + + case TOKeof: + error("found '%s' instead of array initializer", token.toChars()); + break; + } + break; + } + return ia; + + case TOKvoid: + t = peek(&token); + if (t->value == TOKsemicolon || t->value == TOKcomma) + { + nextToken(); + return new VoidInitializer(loc); + } + goto Lexpression; + + default: + Lexpression: + e = parseAssignExp(); + ie = new ExpInitializer(loc, e); + return ie; + } +} + +/***************************************** + * Parses default argument initializer expression that is an assign expression, + * with special handling for __FILE__ and __LINE__. + */ + +#if DMDV2 +Expression *Parser::parseDefaultInitExp() +{ + if (token.value == TOKfile || + token.value == TOKline) + { + Token *t = peek(&token); + if (t->value == TOKcomma || t->value == TOKrparen) + { Expression *e; + + if (token.value == TOKfile) + e = new FileInitExp(loc); + else + e = new LineInitExp(loc); + nextToken(); + return e; + } + } + + Expression *e = parseAssignExp(); + return e; +} +#endif + +/***************************************** + */ + +void Parser::checkDanglingElse(Loc elseloc) +{ + if (token.value != TOKelse && + token.value != TOKcatch && + token.value != TOKfinally && + lookingForElse.linnum != 0) + { + warning(elseloc, "else is dangling, add { } after condition at %s", lookingForElse.toChars()); + } +} + +/***************************************** + * Input: + * flags PSxxxx + */ + +Statement *Parser::parseStatement(int flags) +{ Statement *s; + Token *t; + Condition *condition; + Statement *ifbody; + Statement *elsebody; + bool isfinal; + Loc loc = this->loc; + + //printf("parseStatement()\n"); + + if (flags & PScurly && token.value != TOKlcurly) + error("statement expected to be { }, not %s", token.toChars()); + + switch (token.value) + { + case TOKidentifier: + /* A leading identifier can be a declaration, label, or expression. + * The easiest case to check first is label: + */ + t = peek(&token); + if (t->value == TOKcolon) + { // It's a label + + Identifier *ident = token.ident; + nextToken(); + nextToken(); + s = parseStatement(PSsemi_ok); + s = new LabelStatement(loc, ident, s); + break; + } + // fallthrough to TOKdot + case TOKdot: + case TOKtypeof: + case TOKvector: + if (isDeclaration(&token, 2, TOKreserved, NULL)) + goto Ldeclaration; + else + goto Lexp; + break; + + case TOKassert: + case TOKthis: + case TOKsuper: + case TOKint32v: + case TOKuns32v: + case TOKint64v: + case TOKuns64v: + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + case TOKcharv: + case TOKwcharv: + case TOKdcharv: + case TOKnull: + case TOKtrue: + case TOKfalse: + case TOKstring: + case TOKlparen: + case TOKcast: + case TOKmul: + case TOKmin: + case TOKadd: + case TOKtilde: + case TOKnot: + case TOKplusplus: + case TOKminusminus: + case TOKnew: + case TOKdelete: + case TOKdelegate: + case TOKfunction: + case TOKtypeid: + case TOKis: + case TOKlbracket: +#if DMDV2 + case TOKtraits: + case TOKfile: + case TOKline: +#endif + Lexp: + { + Expression *exp = parseExpression(); + check(TOKsemicolon, "statement"); + s = new ExpStatement(loc, exp); + break; + } + + case TOKstatic: + { // Look ahead to see if it's static assert() or static if() + + Token *t = peek(&token); + if (t->value == TOKassert) + { + nextToken(); + s = new StaticAssertStatement(parseStaticAssert()); + break; + } + if (t->value == TOKif) + { + nextToken(); + condition = parseStaticIfCondition(); + goto Lcondition; + } + if (t->value == TOKstruct || t->value == TOKunion || t->value == TOKclass) + { + nextToken(); + Dsymbols *a = parseBlock(); + Dsymbol *d = new StorageClassDeclaration(STCstatic, a); + s = new ExpStatement(loc, d); + if (flags & PSscope) + s = new ScopeStatement(loc, s); + break; + } + if (t->value == TOKimport) + { nextToken(); + Dsymbols *imports = new Dsymbols(); + parseImport(imports, 1); // static import ... + s = new ImportStatement(loc, imports); + break; + } + goto Ldeclaration; + } + + case TOKfinal: + if (peekNext() == TOKswitch) + { + nextToken(); + isfinal = TRUE; + goto Lswitch; + } + goto Ldeclaration; + + case BASIC_TYPES: + case TOKtypedef: + case TOKalias: + case TOKconst: + case TOKauto: + case TOKextern: + case TOKinvariant: +#if DMDV2 + case TOKimmutable: + case TOKshared: + case TOKwild: + case TOKnothrow: + case TOKpure: + case TOKref: + case TOKtls: + case TOKgshared: + case TOKat: +#endif + Ldeclaration: + { Dsymbols *a; + + a = parseDeclarations(STCundefined, NULL); + if (a->dim > 1) + { + Statements *as = new Statements(); + as->reserve(a->dim); + for (size_t i = 0; i < a->dim; i++) + { + Dsymbol *d = a->tdata()[i]; + s = new ExpStatement(loc, d); + as->push(s); + } + s = new CompoundDeclarationStatement(loc, as); + } + else if (a->dim == 1) + { + Dsymbol *d = a->tdata()[0]; + s = new ExpStatement(loc, d); + } + else + assert(0); + if (flags & PSscope) + s = new ScopeStatement(loc, s); + break; + } + + case TOKstruct: + case TOKunion: + case TOKclass: + case TOKinterface: + { Dsymbol *d; + + d = parseAggregate(); + s = new ExpStatement(loc, d); + break; + } + + case TOKenum: + { /* Determine if this is a manifest constant declaration, + * or a conventional enum. + */ + Dsymbol *d; + Token *t = peek(&token); + if (t->value == TOKlcurly || t->value == TOKcolon) + d = parseEnum(); + else if (t->value != TOKidentifier) + goto Ldeclaration; + else + { + t = peek(t); + if (t->value == TOKlcurly || t->value == TOKcolon || + t->value == TOKsemicolon) + d = parseEnum(); + else + goto Ldeclaration; + } + s = new ExpStatement(loc, d); + break; + } + + case TOKmixin: + { t = peek(&token); + if (t->value == TOKlparen) + { // mixin(string) + Expression *e = parseAssignExp(); + check(TOKsemicolon); + if (e->op == TOKmixin) + { + CompileExp *cpe = (CompileExp *)e; + s = new CompileStatement(loc, cpe->e1); + } + else + { + s = new ExpStatement(loc, e); + } + break; + } + Dsymbol *d = parseMixin(); + s = new ExpStatement(loc, d); + break; + } + + case TOKlcurly: + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = 0; + + nextToken(); + //if (token.value == TOKsemicolon) + //error("use '{ }' for an empty statement, not a ';'"); + Statements *statements = new Statements(); + while (token.value != TOKrcurly && token.value != TOKeof) + { + statements->push(parseStatement(PSsemi | PScurlyscope)); + } + endloc = this->loc; + s = new CompoundStatement(loc, statements); + if (flags & (PSscope | PScurlyscope)) + s = new ScopeStatement(loc, s); + check(TOKrcurly, "compound statement"); + lookingForElse = lookingForElseSave; + break; + } + + case TOKwhile: + { Expression *condition; + Statement *body; + + nextToken(); + check(TOKlparen); + condition = parseExpression(); + check(TOKrparen); + body = parseStatement(PSscope); + s = new WhileStatement(loc, condition, body); + break; + } + + case TOKsemicolon: + if (!(flags & PSsemi_ok)) + { + if (flags & PSsemi) + { if (global.params.warnings) + warning(loc, "use '{ }' for an empty statement, not a ';'"); + } + else + error("use '{ }' for an empty statement, not a ';'"); + } + nextToken(); + s = new ExpStatement(loc, (Expression *)NULL); + break; + + case TOKdo: + { Statement *body; + Expression *condition; + + nextToken(); + Loc lookingForElseSave = lookingForElse; + lookingForElse = 0; + body = parseStatement(PSscope); + lookingForElse = lookingForElseSave; + check(TOKwhile); + check(TOKlparen); + condition = parseExpression(); + check(TOKrparen); + if (token.value == TOKsemicolon) + nextToken(); + else if (!global.params.useDeprecated) + error("do-while statement requires terminating ;"); + s = new DoStatement(loc, body, condition); + break; + } + + case TOKfor: + { + Statement *init; + Expression *condition; + Expression *increment; + Statement *body; + + nextToken(); + check(TOKlparen); + if (token.value == TOKsemicolon) + { init = NULL; + nextToken(); + } + else + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = 0; + init = parseStatement(0); + lookingForElse = lookingForElseSave; + } + if (token.value == TOKsemicolon) + { + condition = NULL; + nextToken(); + } + else + { + condition = parseExpression(); + check(TOKsemicolon, "for condition"); + } + if (token.value == TOKrparen) + { increment = NULL; + nextToken(); + } + else + { increment = parseExpression(); + check(TOKrparen); + } + body = parseStatement(PSscope); + s = new ForStatement(loc, init, condition, increment, body); + if (init) + s = new ScopeStatement(loc, s); + break; + } + + case TOKforeach: + case TOKforeach_reverse: + { + enum TOK op = token.value; + + nextToken(); + check(TOKlparen); + + Parameters *arguments = new Parameters(); + + while (1) + { + Identifier *ai = NULL; + Type *at; + + StorageClass storageClass = 0; + if (token.value == TOKref +#if D1INOUT + || token.value == TOKinout +#endif + ) + { storageClass = STCref; + nextToken(); + } + if (token.value == TOKidentifier) + { + Token *t = peek(&token); + if (t->value == TOKcomma || t->value == TOKsemicolon) + { ai = token.ident; + at = NULL; // infer argument type + nextToken(); + goto Larg; + } + } + at = parseType(&ai); + if (!ai) + error("no identifier for declarator %s", at->toChars()); + Larg: + Parameter *a = new Parameter(storageClass, at, ai, NULL); + arguments->push(a); + if (token.value == TOKcomma) + { nextToken(); + continue; + } + break; + } + check(TOKsemicolon); + + Expression *aggr = parseExpression(); + if (token.value == TOKslice && arguments->dim == 1) + { + Parameter *a = arguments->tdata()[0]; + delete arguments; + nextToken(); + Expression *upr = parseExpression(); + check(TOKrparen); + Statement *body = parseStatement(0); + s = new ForeachRangeStatement(loc, op, a, aggr, upr, body); + } + else + { + check(TOKrparen); + Statement *body = parseStatement(0); + s = new ForeachStatement(loc, op, arguments, aggr, body); + } + break; + } + + case TOKif: + { Parameter *arg = NULL; + Expression *condition; + Statement *ifbody; + Statement *elsebody; + + nextToken(); + check(TOKlparen); + + if (token.value == TOKauto) + { + nextToken(); + if (token.value == TOKidentifier) + { + Token *t = peek(&token); + if (t->value == TOKassign) + { + arg = new Parameter(0, NULL, token.ident, NULL); + nextToken(); + nextToken(); + } + else + { error("= expected following auto identifier"); + goto Lerror; + } + } + else + { error("identifier expected following auto"); + goto Lerror; + } + } + else if (isDeclaration(&token, 2, TOKassign, NULL)) + { + Type *at; + Identifier *ai; + + at = parseType(&ai); + check(TOKassign); + arg = new Parameter(0, at, ai, NULL); + } + + // Check for " ident;" + else if (token.value == TOKidentifier) + { + Token *t = peek(&token); + if (t->value == TOKsemicolon) + { + arg = new Parameter(0, NULL, token.ident, NULL); + nextToken(); + nextToken(); + if (!global.params.useDeprecated) + error("if (v%s e) is deprecated, use if (auto v = e)", t->toChars()); + } + } + + condition = parseExpression(); + check(TOKrparen); + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = loc; + ifbody = parseStatement(PSscope); + lookingForElse = lookingForElseSave; + } + if (token.value == TOKelse) + { + Loc elseloc = this->loc; + nextToken(); + elsebody = parseStatement(PSscope); + checkDanglingElse(elseloc); + } + else + elsebody = NULL; + if (condition && ifbody) + s = new IfStatement(loc, arg, condition, ifbody, elsebody); + else + s = NULL; // don't propagate parsing errors + break; + } + + case TOKscope: + if (peek(&token)->value != TOKlparen) + goto Ldeclaration; // scope used as storage class + nextToken(); + check(TOKlparen); + if (token.value != TOKidentifier) + { error("scope identifier expected"); + goto Lerror; + } + else + { TOK t = TOKon_scope_exit; + Identifier *id = token.ident; + + if (id == Id::exit) + t = TOKon_scope_exit; + else if (id == Id::failure) + t = TOKon_scope_failure; + else if (id == Id::success) + t = TOKon_scope_success; + else + error("valid scope identifiers are exit, failure, or success, not %s", id->toChars()); + nextToken(); + check(TOKrparen); + Statement *st = parseStatement(PScurlyscope); + s = new OnScopeStatement(loc, t, st); + break; + } + + case TOKdebug: + nextToken(); + condition = parseDebugCondition(); + goto Lcondition; + + case TOKversion: + nextToken(); + condition = parseVersionCondition(); + goto Lcondition; + + Lcondition: + { + Loc lookingForElseSave = lookingForElse; + lookingForElse = loc; + ifbody = parseStatement(0 /*PSsemi*/); + lookingForElse = lookingForElseSave; + } + elsebody = NULL; + if (token.value == TOKelse) + { + Loc elseloc = this->loc; + nextToken(); + elsebody = parseStatement(0 /*PSsemi*/); + checkDanglingElse(elseloc); + } + s = new ConditionalStatement(loc, condition, ifbody, elsebody); + break; + + case TOKpragma: + { Identifier *ident; + Expressions *args = NULL; + Statement *body; + + nextToken(); + check(TOKlparen); + if (token.value != TOKidentifier) + { error("pragma(identifier expected"); + goto Lerror; + } + ident = token.ident; + nextToken(); + if (token.value == TOKcomma && peekNext() != TOKrparen) + args = parseArguments(); // pragma(identifier, args...); + else + check(TOKrparen); // pragma(identifier); + if (token.value == TOKsemicolon) + { nextToken(); + body = NULL; + } + else + body = parseStatement(PSsemi); + s = new PragmaStatement(loc, ident, args, body); + break; + } + + case TOKswitch: + isfinal = FALSE; + goto Lswitch; + + Lswitch: + { + nextToken(); + check(TOKlparen); + Expression *condition = parseExpression(); + check(TOKrparen); + Statement *body = parseStatement(PSscope); + s = new SwitchStatement(loc, condition, body, isfinal); + break; + } + + case TOKcase: + { Expression *exp; + Statements *statements; + Expressions cases; // array of Expression's + Expression *last = NULL; + + while (1) + { + nextToken(); + exp = parseAssignExp(); + cases.push(exp); + if (token.value != TOKcomma) + break; + } + check(TOKcolon); + +#if DMDV2 + /* case exp: .. case last: + */ + if (token.value == TOKslice) + { + if (cases.dim > 1) + error("only one case allowed for start of case range"); + nextToken(); + check(TOKcase); + last = parseAssignExp(); + check(TOKcolon); + } +#endif + + statements = new Statements(); + while (token.value != TOKcase && + token.value != TOKdefault && + token.value != TOKeof && + token.value != TOKrcurly) + { + statements->push(parseStatement(PSsemi | PScurlyscope)); + } + s = new CompoundStatement(loc, statements); + s = new ScopeStatement(loc, s); + +#if DMDV2 + if (last) + { + s = new CaseRangeStatement(loc, exp, last, s); + } + else +#endif + { + // Keep cases in order by building the case statements backwards + for (size_t i = cases.dim; i; i--) + { + exp = cases.tdata()[i - 1]; + s = new CaseStatement(loc, exp, s); + } + } + break; + } + + case TOKdefault: + { + Statements *statements; + + nextToken(); + check(TOKcolon); + + statements = new Statements(); + while (token.value != TOKcase && + token.value != TOKdefault && + token.value != TOKeof && + token.value != TOKrcurly) + { + statements->push(parseStatement(PSsemi | PScurlyscope)); + } + s = new CompoundStatement(loc, statements); + s = new ScopeStatement(loc, s); + s = new DefaultStatement(loc, s); + break; + } + + case TOKreturn: + { Expression *exp; + + nextToken(); + if (token.value == TOKsemicolon) + exp = NULL; + else + exp = parseExpression(); + check(TOKsemicolon, "return statement"); + s = new ReturnStatement(loc, exp); + break; + } + + case TOKbreak: + { Identifier *ident; + + nextToken(); + if (token.value == TOKidentifier) + { ident = token.ident; + nextToken(); + } + else + ident = NULL; + check(TOKsemicolon, "break statement"); + s = new BreakStatement(loc, ident); + break; + } + + case TOKcontinue: + { Identifier *ident; + + nextToken(); + if (token.value == TOKidentifier) + { ident = token.ident; + nextToken(); + } + else + ident = NULL; + check(TOKsemicolon, "continue statement"); + s = new ContinueStatement(loc, ident); + break; + } + + case TOKgoto: + { Identifier *ident; + + nextToken(); + if (token.value == TOKdefault) + { + nextToken(); + s = new GotoDefaultStatement(loc); + } + else if (token.value == TOKcase) + { + Expression *exp = NULL; + + nextToken(); + if (token.value != TOKsemicolon) + exp = parseExpression(); + s = new GotoCaseStatement(loc, exp); + } + else + { + if (token.value != TOKidentifier) + { error("Identifier expected following goto"); + ident = NULL; + } + else + { ident = token.ident; + nextToken(); + } + s = new GotoStatement(loc, ident); + } + check(TOKsemicolon, "goto statement"); + break; + } + + case TOKsynchronized: + { Expression *exp; + Statement *body; + + nextToken(); + if (token.value == TOKlparen) + { + nextToken(); + exp = parseExpression(); + check(TOKrparen); + } + else + exp = NULL; + body = parseStatement(PSscope); + s = new SynchronizedStatement(loc, exp, body); + break; + } + + case TOKwith: + { Expression *exp; + Statement *body; + + nextToken(); + check(TOKlparen); + exp = parseExpression(); + check(TOKrparen); + body = parseStatement(PSscope); + s = new WithStatement(loc, exp, body); + break; + } + + case TOKtry: + { Statement *body; + Catches *catches = NULL; + Statement *finalbody = NULL; + + nextToken(); + Loc lookingForElseSave = lookingForElse; + lookingForElse = 0; + body = parseStatement(PSscope); + lookingForElse = lookingForElseSave; + while (token.value == TOKcatch) + { + Statement *handler; + Catch *c; + Type *t; + Identifier *id; + Loc loc = this->loc; + + nextToken(); + if (token.value == TOKlcurly) + { + t = NULL; + id = NULL; + } + else + { + check(TOKlparen); + id = NULL; + t = parseType(&id); + check(TOKrparen); + } + handler = parseStatement(0); + c = new Catch(loc, t, id, handler); + if (!catches) + catches = new Catches(); + catches->push(c); + } + + if (token.value == TOKfinally) + { nextToken(); + finalbody = parseStatement(0); + } + + s = body; + if (!catches && !finalbody) + error("catch or finally expected following try"); + else + { if (catches) + s = new TryCatchStatement(loc, body, catches); + if (finalbody) + s = new TryFinallyStatement(loc, s, finalbody); + } + break; + } + + case TOKthrow: + { Expression *exp; + + nextToken(); + exp = parseExpression(); + check(TOKsemicolon, "throw statement"); + s = new ThrowStatement(loc, exp); + break; + } + + case TOKvolatile: + nextToken(); + s = parseStatement(PSsemi | PScurlyscope); +#if DMDV2 + if (!global.params.useDeprecated) + error("volatile statements deprecated; use synchronized statements instead"); +#endif + s = new VolatileStatement(loc, s); + break; + + case TOKasm: + { Statements *statements; + Identifier *label; + Loc labelloc; + Token *toklist; + Token **ptoklist; + + // Parse the asm block into a sequence of AsmStatements, + // each AsmStatement is one instruction. + // Separate out labels. + // Defer parsing of AsmStatements until semantic processing. + + nextToken(); + check(TOKlcurly); + toklist = NULL; + ptoklist = &toklist; + label = NULL; + statements = new Statements(); + while (1) + { + switch (token.value) + { + case TOKidentifier: + if (!toklist) + { + // Look ahead to see if it is a label + t = peek(&token); + if (t->value == TOKcolon) + { // It's a label + label = token.ident; + labelloc = this->loc; + nextToken(); + nextToken(); + continue; + } + } + goto Ldefault; + + case TOKrcurly: + if (toklist || label) + { + error("asm statements must end in ';'"); + } + break; + + case TOKsemicolon: + s = NULL; + if (toklist || label) + { // Create AsmStatement from list of tokens we've saved + s = new AsmStatement(this->loc, toklist); + toklist = NULL; + ptoklist = &toklist; + if (label) + { s = new LabelStatement(labelloc, label, s); + label = NULL; + } + statements->push(s); + } + nextToken(); + continue; + + case TOKeof: + /* { */ + error("matching '}' expected, not end of file"); + break; + + default: + Ldefault: + *ptoklist = new Token(); + memcpy(*ptoklist, &token, sizeof(Token)); + ptoklist = &(*ptoklist)->next; + *ptoklist = NULL; + + nextToken(); + continue; + } + break; + } + s = new CompoundStatement(loc, statements); + nextToken(); + break; + } + + case TOKimport: + { Dsymbols *imports = new Dsymbols(); + parseImport(imports, 0); + s = new ImportStatement(loc, imports); + break; + } + + default: + error("found '%s' instead of statement", token.toChars()); + goto Lerror; + + Lerror: + while (token.value != TOKrcurly && + token.value != TOKsemicolon && + token.value != TOKeof) + nextToken(); + if (token.value == TOKsemicolon) + nextToken(); + s = NULL; + break; + } + + return s; +} + +void Parser::check(enum TOK value) +{ + check(loc, value); +} + +void Parser::check(Loc loc, enum TOK value) +{ + if (token.value != value) + error(loc, "found '%s' when expecting '%s'", token.toChars(), Token::toChars(value)); + nextToken(); +} + +void Parser::check(enum TOK value, const char *string) +{ + if (token.value != value) + error("found '%s' when expecting '%s' following %s", + token.toChars(), Token::toChars(value), string); + nextToken(); +} + +void Parser::checkParens(enum TOK value, Expression *e) +{ + if (precedence[e->op] == PREC_rel && !e->parens) + error(loc, "%s must be parenthesized when next to operator %s", e->toChars(), Token::toChars(value)); +} + +/************************************ + * Determine if the scanner is sitting on the start of a declaration. + * Input: + * needId 0 no identifier + * 1 identifier optional + * 2 must have identifier + * Output: + * if *pt is not NULL, it is set to the ending token, which would be endtok + */ + +int Parser::isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt) +{ + //printf("isDeclaration(needId = %d)\n", needId); + int haveId = 0; + +#if DMDV2 + if ((t->value == TOKconst || + t->value == TOKinvariant || + t->value == TOKimmutable || + t->value == TOKwild || + t->value == TOKshared) && + peek(t)->value != TOKlparen) + { /* const type + * immutable type + * shared type + * wild type + */ + t = peek(t); + } +#endif + + if (!isBasicType(&t)) + { + goto Lisnot; + } + if (!isDeclarator(&t, &haveId, endtok)) + goto Lisnot; + if ( needId == 1 || + (needId == 0 && !haveId) || + (needId == 2 && haveId)) + { if (pt) + *pt = t; + goto Lis; + } + else + goto Lisnot; + +Lis: + //printf("\tis declaration, t = %s\n", t->toChars()); + return TRUE; + +Lisnot: + //printf("\tis not declaration\n"); + return FALSE; +} + +int Parser::isBasicType(Token **pt) +{ + // This code parallels parseBasicType() + Token *t = *pt; + int haveId = 0; + + switch (t->value) + { + case BASIC_TYPES: + t = peek(t); + break; + + case TOKidentifier: + L5: + t = peek(t); + if (t->value == TOKnot) + { + goto L4; + } + goto L3; + while (1) + { + L2: + t = peek(t); + L3: + if (t->value == TOKdot) + { + Ldot: + t = peek(t); + if (t->value != TOKidentifier) + goto Lfalse; + t = peek(t); + if (t->value != TOKnot) + goto L3; + L4: + /* Seen a ! + * Look for: + * !( args ), !identifier, etc. + */ + t = peek(t); + switch (t->value) + { case TOKidentifier: + goto L5; + case TOKlparen: + if (!skipParens(t, &t)) + goto Lfalse; + break; + case BASIC_TYPES: + case TOKint32v: + case TOKuns32v: + case TOKint64v: + case TOKuns64v: + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + case TOKnull: + case TOKtrue: + case TOKfalse: + case TOKcharv: + case TOKwcharv: + case TOKdcharv: + case TOKstring: + case TOKfile: + case TOKline: + goto L2; + default: + goto Lfalse; + } + } + else + break; + } + break; + + case TOKdot: + goto Ldot; + + case TOKtypeof: + case TOKvector: + /* typeof(exp).identifier... + */ + t = peek(t); + if (t->value != TOKlparen) + goto Lfalse; + if (!skipParens(t, &t)) + goto Lfalse; + goto L2; + + case TOKconst: + case TOKinvariant: + case TOKimmutable: + case TOKshared: + case TOKwild: + // const(type) or immutable(type) or shared(type) or wild(type) + t = peek(t); + if (t->value != TOKlparen) + goto Lfalse; + t = peek(t); + if (!isDeclaration(t, 0, TOKrparen, &t)) + { + goto Lfalse; + } + t = peek(t); + break; + + default: + goto Lfalse; + } + *pt = t; + //printf("is\n"); + return TRUE; + +Lfalse: + //printf("is not\n"); + return FALSE; +} + +int Parser::isDeclarator(Token **pt, int *haveId, enum TOK endtok) +{ // This code parallels parseDeclarator() + Token *t = *pt; + int parens; + + //printf("Parser::isDeclarator()\n"); + //t->print(); + if (t->value == TOKassign) + return FALSE; + + while (1) + { + parens = FALSE; + switch (t->value) + { + case TOKmul: + //case TOKand: + t = peek(t); + continue; + + case TOKlbracket: + t = peek(t); + if (t->value == TOKrbracket) + { + t = peek(t); + } + else if (isDeclaration(t, 0, TOKrbracket, &t)) + { // It's an associative array declaration + t = peek(t); + } + else + { + // [ expression ] + // [ expression .. expression ] + if (!isExpression(&t)) + return FALSE; + if (t->value == TOKslice) + { t = peek(t); + if (!isExpression(&t)) + return FALSE; + } + if (t->value != TOKrbracket) + return FALSE; + t = peek(t); + } + continue; + + case TOKidentifier: + if (*haveId) + return FALSE; + *haveId = TRUE; + t = peek(t); + break; + + case TOKlparen: + t = peek(t); + + if (t->value == TOKrparen) + return FALSE; // () is not a declarator + + /* Regard ( identifier ) as not a declarator + * BUG: what about ( *identifier ) in + * f(*p)(x); + * where f is a class instance with overloaded () ? + * Should we just disallow C-style function pointer declarations? + */ + if (t->value == TOKidentifier) + { Token *t2 = peek(t); + if (t2->value == TOKrparen) + return FALSE; + } + + + if (!isDeclarator(&t, haveId, TOKrparen)) + return FALSE; + t = peek(t); + parens = TRUE; + break; + + case TOKdelegate: + case TOKfunction: + t = peek(t); + if (!isParameters(&t)) + return FALSE; + continue; + } + break; + } + + while (1) + { + switch (t->value) + { +#if CARRAYDECL + case TOKlbracket: + parens = FALSE; + t = peek(t); + if (t->value == TOKrbracket) + { + t = peek(t); + } + else if (isDeclaration(t, 0, TOKrbracket, &t)) + { // It's an associative array declaration + t = peek(t); + } + else + { + // [ expression ] + if (!isExpression(&t)) + return FALSE; + if (t->value != TOKrbracket) + return FALSE; + t = peek(t); + } + continue; +#endif + + case TOKlparen: + parens = FALSE; + if (!isParameters(&t)) + return FALSE; +#if DMDV2 + while (1) + { + switch (t->value) + { + case TOKconst: + case TOKinvariant: + case TOKimmutable: + case TOKshared: + case TOKwild: + case TOKpure: + case TOKnothrow: + t = peek(t); + continue; + case TOKat: + t = peek(t); // skip '@' + t = peek(t); // skip identifier + continue; + default: + break; + } + break; + } +#endif + continue; + + // Valid tokens that follow a declaration + case TOKrparen: + case TOKrbracket: + case TOKassign: + case TOKcomma: + case TOKdotdotdot: + case TOKsemicolon: + case TOKlcurly: + case TOKin: + case TOKout: + case TOKbody: + // The !parens is to disallow unnecessary parentheses + if (!parens && (endtok == TOKreserved || endtok == t->value)) + { *pt = t; + return TRUE; + } + return FALSE; + + default: + return FALSE; + } + } +} + + +int Parser::isParameters(Token **pt) +{ // This code parallels parseParameters() + Token *t = *pt; + + //printf("isParameters()\n"); + if (t->value != TOKlparen) + return FALSE; + + t = peek(t); + for (;1; t = peek(t)) + { + L1: + switch (t->value) + { + case TOKrparen: + break; + + case TOKdotdotdot: + t = peek(t); + break; + +#if D1INOUT + case TOKinout: +#endif + case TOKin: + case TOKout: + case TOKref: + case TOKlazy: + case TOKfinal: + case TOKauto: + continue; + + case TOKconst: + case TOKinvariant: + case TOKimmutable: + case TOKshared: + case TOKwild: + t = peek(t); + if (t->value == TOKlparen) + { + t = peek(t); + if (!isDeclaration(t, 0, TOKrparen, &t)) + return FALSE; + t = peek(t); // skip past closing ')' + goto L2; + } + goto L1; + +#if 0 + case TOKstatic: + continue; + case TOKauto: + case TOKalias: + t = peek(t); + if (t->value == TOKidentifier) + t = peek(t); + if (t->value == TOKassign) + { t = peek(t); + if (!isExpression(&t)) + return FALSE; + } + goto L3; +#endif + + default: + { if (!isBasicType(&t)) + return FALSE; + L2: + int tmp = FALSE; + if (t->value != TOKdotdotdot && + !isDeclarator(&t, &tmp, TOKreserved)) + return FALSE; + if (t->value == TOKassign) + { t = peek(t); + if (!isExpression(&t)) + return FALSE; + } + if (t->value == TOKdotdotdot) + { + t = peek(t); + break; + } + } + if (t->value == TOKcomma) + { + continue; + } + break; + } + break; + } + if (t->value != TOKrparen) + return FALSE; + t = peek(t); + *pt = t; + return TRUE; +} + +int Parser::isExpression(Token **pt) +{ + // This is supposed to determine if something is an expression. + // What it actually does is scan until a closing right bracket + // is found. + + Token *t = *pt; + int brnest = 0; + int panest = 0; + int curlynest = 0; + + for (;; t = peek(t)) + { + switch (t->value) + { + case TOKlbracket: + brnest++; + continue; + + case TOKrbracket: + if (--brnest >= 0) + continue; + break; + + case TOKlparen: + panest++; + continue; + + case TOKcomma: + if (brnest || panest) + continue; + break; + + case TOKrparen: + if (--panest >= 0) + continue; + break; + + case TOKlcurly: + curlynest++; + continue; + + case TOKrcurly: + if (--curlynest >= 0) + continue; + return FALSE; + + case TOKslice: + if (brnest) + continue; + break; + + case TOKsemicolon: + if (curlynest) + continue; + return FALSE; + + case TOKeof: + return FALSE; + + default: + continue; + } + break; + } + + *pt = t; + return TRUE; +} + +/********************************************** + * Skip over + * instance foo.bar(parameters...) + * Output: + * if (pt), *pt is set to the token following the closing ) + * Returns: + * 1 it's valid instance syntax + * 0 invalid instance syntax + */ + +int Parser::isTemplateInstance(Token *t, Token **pt) +{ + t = peek(t); + if (t->value != TOKdot) + { + if (t->value != TOKidentifier) + goto Lfalse; + t = peek(t); + } + while (t->value == TOKdot) + { + t = peek(t); + if (t->value != TOKidentifier) + goto Lfalse; + t = peek(t); + } + if (t->value != TOKlparen) + goto Lfalse; + + // Skip over the template arguments + while (1) + { + while (1) + { + t = peek(t); + switch (t->value) + { + case TOKlparen: + if (!skipParens(t, &t)) + goto Lfalse; + continue; + case TOKrparen: + break; + case TOKcomma: + break; + case TOKeof: + case TOKsemicolon: + goto Lfalse; + default: + continue; + } + break; + } + + if (t->value != TOKcomma) + break; + } + if (t->value != TOKrparen) + goto Lfalse; + t = peek(t); + if (pt) + *pt = t; + return 1; + +Lfalse: + return 0; +} + +/******************************************* + * Skip parens, brackets. + * Input: + * t is on opening ( + * Output: + * *pt is set to closing token, which is ')' on success + * Returns: + * !=0 successful + * 0 some parsing error + */ + +int Parser::skipParens(Token *t, Token **pt) +{ + int parens = 0; + + while (1) + { + switch (t->value) + { + case TOKlparen: + parens++; + break; + + case TOKrparen: + parens--; + if (parens < 0) + goto Lfalse; + if (parens == 0) + goto Ldone; + break; + + case TOKeof: + goto Lfalse; + + default: + break; + } + t = peek(t); + } + + Ldone: + if (*pt) + *pt = t; + return 1; + + Lfalse: + return 0; +} + +/******************************************* + * Skip attributes. + * Input: + * t is on a candidate attribute + * Output: + * *pt is set to first non-attribute token on success + * Returns: + * !=0 successful + * 0 some parsing error + */ + +int Parser::skipAttributes(Token *t, Token **pt) +{ + while (1) + { + switch (t->value) + { + case TOKconst: + case TOKinvariant: + case TOKimmutable: + case TOKshared: + case TOKwild: + case TOKfinal: + case TOKauto: + case TOKscope: + case TOKoverride: + case TOKabstract: + case TOKsynchronized: + case TOKdeprecated: + case TOKnothrow: + case TOKpure: + case TOKref: + case TOKtls: + case TOKgshared: + //case TOKmanifest: + break; + case TOKat: + t = peek(t); + if (t->value == TOKidentifier) + break; + goto Lerror; + default: + goto Ldone; + } + t = peek(t); + } + + Ldone: + if (*pt) + *pt = t; + return 1; + + Lerror: + return 0; +} + +/********************************* Expression Parser ***************************/ + +Expression *Parser::parsePrimaryExp() +{ Expression *e; + Type *t; + Identifier *id; + enum TOK save; + Loc loc = this->loc; + + //printf("parsePrimaryExp(): loc = %d\n", loc.linnum); + switch (token.value) + { + case TOKidentifier: + if (peekNext() == TOKgoesto) + goto case_delegate; + + id = token.ident; + nextToken(); + if (token.value == TOKnot && (save = peekNext()) != TOKis && save != TOKin) + { // identifier!(template-argument-list) + TemplateInstance *tempinst; + + tempinst = new TemplateInstance(loc, id); + nextToken(); + if (token.value == TOKlparen) + // ident!(template_arguments) + tempinst->tiargs = parseTemplateArgumentList(); + else + // ident!template_argument + tempinst->tiargs = parseTemplateArgument(); + e = new ScopeExp(loc, tempinst); + } + else + e = new IdentifierExp(loc, id); + break; + + case TOKdollar: + if (!inBrackets) + error("'$' is valid only inside [] of index or slice"); + e = new DollarExp(loc); + nextToken(); + break; + + case TOKdot: + // Signal global scope '.' operator with "" identifier + e = new IdentifierExp(loc, Id::empty); + break; + + case TOKthis: + e = new ThisExp(loc); + nextToken(); + break; + + case TOKsuper: + e = new SuperExp(loc); + nextToken(); + break; + + case TOKint32v: + e = new IntegerExp(loc, token.int32value, Type::tint32); + nextToken(); + break; + + case TOKuns32v: + e = new IntegerExp(loc, token.uns32value, Type::tuns32); + nextToken(); + break; + + case TOKint64v: + e = new IntegerExp(loc, token.int64value, Type::tint64); + nextToken(); + break; + + case TOKuns64v: + e = new IntegerExp(loc, token.uns64value, Type::tuns64); + nextToken(); + break; + + case TOKfloat32v: + e = new RealExp(loc, token.float80value, Type::tfloat32); + nextToken(); + break; + + case TOKfloat64v: + e = new RealExp(loc, token.float80value, Type::tfloat64); + nextToken(); + break; + + case TOKfloat80v: + e = new RealExp(loc, token.float80value, Type::tfloat80); + nextToken(); + break; + + case TOKimaginary32v: + e = new RealExp(loc, token.float80value, Type::timaginary32); + nextToken(); + break; + + case TOKimaginary64v: + e = new RealExp(loc, token.float80value, Type::timaginary64); + nextToken(); + break; + + case TOKimaginary80v: + e = new RealExp(loc, token.float80value, Type::timaginary80); + nextToken(); + break; + + case TOKnull: + e = new NullExp(loc); + nextToken(); + break; + +#if DMDV2 + case TOKfile: + { const char *s = loc.filename ? loc.filename : mod->ident->toChars(); + e = new StringExp(loc, (char *)s, strlen(s), 0); + nextToken(); + break; + } + + case TOKline: + e = new IntegerExp(loc, loc.linnum, Type::tint32); + nextToken(); + break; +#endif + + case TOKtrue: + e = new IntegerExp(loc, 1, Type::tbool); + nextToken(); + break; + + case TOKfalse: + e = new IntegerExp(loc, 0, Type::tbool); + nextToken(); + break; + + case TOKcharv: + e = new IntegerExp(loc, token.uns32value, Type::tchar); + nextToken(); + break; + + case TOKwcharv: + e = new IntegerExp(loc, token.uns32value, Type::twchar); + nextToken(); + break; + + case TOKdcharv: + e = new IntegerExp(loc, token.uns32value, Type::tdchar); + nextToken(); + break; + + case TOKstring: + { unsigned char *s; + unsigned len; + unsigned char postfix; + + // cat adjacent strings + s = token.ustring; + len = token.len; + postfix = token.postfix; + while (1) + { + nextToken(); + if (token.value == TOKstring) + { unsigned len1; + unsigned len2; + unsigned char *s2; + + if (token.postfix) + { if (token.postfix != postfix) + error("mismatched string literal postfixes '%c' and '%c'", postfix, token.postfix); + postfix = token.postfix; + } + + len1 = len; + len2 = token.len; + len = len1 + len2; + s2 = (unsigned char *)mem.malloc((len + 1) * sizeof(unsigned char)); + memcpy(s2, s, len1 * sizeof(unsigned char)); + memcpy(s2 + len1, token.ustring, (len2 + 1) * sizeof(unsigned char)); + s = s2; + } + else + break; + } + e = new StringExp(loc, s, len, postfix); + break; + } + + case BASIC_TYPES_X(t): + nextToken(); + check(TOKdot, t->toChars()); + if (token.value != TOKidentifier) + { error("found '%s' when expecting identifier following '%s.'", token.toChars(), t->toChars()); + goto Lerr; + } + e = typeDotIdExp(loc, t, token.ident); + nextToken(); + break; + + case TOKtypeof: + { + t = parseTypeof(); + e = new TypeExp(loc, t); + break; + } + + case TOKvector: + { + t = parseVector(); + e = new TypeExp(loc, t); + break; + } + + case TOKtypeid: + { + nextToken(); + check(TOKlparen, "typeid"); + Object *o; + if (isDeclaration(&token, 0, TOKreserved, NULL)) + { // argument is a type + o = parseType(); + } + else + { // argument is an expression + o = parseAssignExp(); + } + check(TOKrparen); + e = new TypeidExp(loc, o); + break; + } + +#if DMDV2 + case TOKtraits: + { /* __traits(identifier, args...) + */ + Identifier *ident; + Objects *args = NULL; + + nextToken(); + check(TOKlparen); + if (token.value != TOKidentifier) + { error("__traits(identifier, args...) expected"); + goto Lerr; + } + ident = token.ident; + nextToken(); + if (token.value == TOKcomma) + args = parseTemplateArgumentList2(); // __traits(identifier, args...) + else + check(TOKrparen); // __traits(identifier) + + e = new TraitsExp(loc, ident, args); + break; + } +#endif + + case TOKis: + { Type *targ; + Identifier *ident = NULL; + Type *tspec = NULL; + enum TOK tok = TOKreserved; + enum TOK tok2 = TOKreserved; + TemplateParameters *tpl = NULL; + Loc loc = this->loc; + + nextToken(); + if (token.value == TOKlparen) + { + nextToken(); + targ = parseType(&ident); + if (token.value == TOKcolon || token.value == TOKequal) + { + tok = token.value; + nextToken(); + if (tok == TOKequal && + (token.value == TOKtypedef || + token.value == TOKstruct || + token.value == TOKunion || + token.value == TOKclass || + token.value == TOKsuper || + token.value == TOKenum || + token.value == TOKinterface || + token.value == TOKargTypes || +#if DMDV2 + token.value == TOKconst && peek(&token)->value == TOKrparen || + token.value == TOKinvariant && peek(&token)->value == TOKrparen || + token.value == TOKimmutable && peek(&token)->value == TOKrparen || + token.value == TOKshared && peek(&token)->value == TOKrparen || + token.value == TOKwild && peek(&token)->value == TOKrparen || +#endif + token.value == TOKfunction || + token.value == TOKdelegate || + token.value == TOKreturn)) + { + if (token.value == TOKinvariant && !global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + tok2 = token.value; + nextToken(); + } + else + { + tspec = parseType(); + } + } + if (ident && tspec) + { + if (token.value == TOKcomma) + tpl = parseTemplateParameterList(1); + else + { tpl = new TemplateParameters(); + check(TOKrparen); + } + TemplateParameter *tp = new TemplateTypeParameter(loc, ident, NULL, NULL); + tpl->insert(0, tp); + } + else + check(TOKrparen); + } + else + { error("(type identifier : specialization) expected following is"); + goto Lerr; + } + e = new IsExp(loc, targ, ident, tok, tspec, tok2, tpl); + break; + } + + case TOKassert: + { Expression *msg = NULL; + + nextToken(); + check(TOKlparen, "assert"); + e = parseAssignExp(); + if (token.value == TOKcomma) + { nextToken(); + msg = parseAssignExp(); + } + check(TOKrparen); + e = new AssertExp(loc, e, msg); + break; + } + + case TOKmixin: + { + nextToken(); + check(TOKlparen, "mixin"); + e = parseAssignExp(); + check(TOKrparen); + e = new CompileExp(loc, e); + break; + } + + case TOKimport: + { + nextToken(); + check(TOKlparen, "import"); + e = parseAssignExp(); + check(TOKrparen); + e = new FileExp(loc, e); + break; + } + + case TOKlparen: + { enum TOK past = peekPastParen(&token)->value; + + if (past == TOKgoesto) + { // (arguments) => expression + goto case_delegate; + } + else if (past == TOKlcurly) + { // (arguments) { statements... } + goto case_delegate; + } + // ( expression ) + nextToken(); + e = parseExpression(); + e->parens = 1; + check(loc, TOKrparen); + break; + } + + case TOKlbracket: + { /* Parse array literals and associative array literals: + * [ value, value, value ... ] + * [ key:value, key:value, key:value ... ] + */ + Expressions *values = new Expressions(); + Expressions *keys = NULL; + + nextToken(); + while (token.value != TOKrbracket && token.value != TOKeof) + { + Expression *e = parseAssignExp(); + if (token.value == TOKcolon && (keys || values->dim == 0)) + { nextToken(); + if (!keys) + keys = new Expressions(); + keys->push(e); + e = parseAssignExp(); + } + else if (keys) + { error("'key:value' expected for associative array literal"); + delete keys; + keys = NULL; + } + values->push(e); + if (token.value == TOKrbracket) + break; + check(TOKcomma); + } + check(loc, TOKrbracket); + + if (keys) + e = new AssocArrayLiteralExp(loc, keys, values); + else + e = new ArrayLiteralExp(loc, values); + break; + } + + case TOKlcurly: + case TOKfunction: + case TOKdelegate: + case_delegate: + { + TemplateParameters *tpl = NULL; + Parameters *parameters = NULL; + int varargs = 0; + Type *tret = NULL; + StorageClass stc = 0; + enum TOK save = TOKreserved; + Loc loc = this->loc; + + switch (token.value) + { + case TOKfunction: + case TOKdelegate: + save = token.value; + nextToken(); + if (token.value != TOKlparen && token.value != TOKlcurly) + { // function type (parameters) { statements... } + // delegate type (parameters) { statements... } + tret = parseBasicType(); + tret = parseBasicType2(tret); // function return type + } + + if (token.value == TOKlparen) + { // function (parameters) { statements... } + // delegate (parameters) { statements... } + } + else + { // function { statements... } + // delegate { statements... } + break; + } + /* fall through to TOKlparen */ + + case TOKlparen: + Lparen: + { // (parameters) => expression + // (parameters) { statements... } + parameters = parseParameters(&varargs, &tpl); + stc = parsePostfix(); + if (stc & (STCconst | STCimmutable | STCshared | STCwild)) + error("const/immutable/shared/inout attributes are only valid for non-static member functions"); + break; + } + case TOKlcurly: + // { statements... } + break; + + case TOKidentifier: + { // identifier => expression + parameters = new Parameters(); + Identifier *id = Lexer::uniqueId("__T"); + Type *t = new TypeIdentifier(loc, id); + parameters->push(new Parameter(0, t, token.ident, NULL)); + + tpl = new TemplateParameters(); + TemplateParameter *tp = new TemplateTypeParameter(loc, id, NULL, NULL); + tpl->push(tp); + + nextToken(); + break; + } + default: + assert(0); + } + + if (!parameters) + parameters = new Parameters(); + TypeFunction *tf = new TypeFunction(parameters, tret, varargs, linkage, stc); + FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(loc, 0, tf, save, NULL); + + if (token.value == TOKgoesto) + { + check(TOKgoesto); + Loc loc = this->loc; + Expression *ae = parseAssignExp(); + fd->fbody = new ReturnStatement(loc, ae); + fd->endloc = this->loc; + } + else + { + parseContracts(fd); + } + + TemplateDeclaration *td = NULL; + if (tpl) + { // Wrap a template around function fd + Dsymbols *decldefs = new Dsymbols(); + decldefs->push(fd); + td = new TemplateDeclaration(fd->loc, fd->ident, tpl, NULL, decldefs, 0); + td->literal = 1; // it's a template 'literal' + } + + e = new FuncExp(loc, fd, td); + break; + } + + default: + error("expression expected, not '%s'", token.toChars()); + Lerr: + // Anything for e, as long as it's not NULL + e = new IntegerExp(loc, 0, Type::tint32); + nextToken(); + break; + } + return e; +} + +Expression *Parser::parsePostExp(Expression *e) +{ + Loc loc; + + while (1) + { + loc = this->loc; + switch (token.value) + { + case TOKdot: + nextToken(); + if (token.value == TOKidentifier) + { Identifier *id = token.ident; + + nextToken(); + if (token.value == TOKnot && peekNext() != TOKis && peekNext() != TOKin) + { // identifier!(template-argument-list) + TemplateInstance *tempinst = new TemplateInstance(loc, id); + Objects *tiargs; + nextToken(); + if (token.value == TOKlparen) + // ident!(template_arguments) + tiargs = parseTemplateArgumentList(); + else + // ident!template_argument + tiargs = parseTemplateArgument(); + e = new DotTemplateInstanceExp(loc, e, id, tiargs); + } + else + e = new DotIdExp(loc, e, id); + continue; + } + else if (token.value == TOKnew) + { + e = parseNewExp(e); + continue; + } + else + error("identifier expected following '.', not '%s'", token.toChars()); + break; + + case TOKplusplus: + e = new PostExp(TOKplusplus, loc, e); + break; + + case TOKminusminus: + e = new PostExp(TOKminusminus, loc, e); + break; + + case TOKlparen: + e = new CallExp(loc, e, parseArguments()); + continue; + + case TOKlbracket: + { // array dereferences: + // array[index] + // array[] + // array[lwr .. upr] + Expression *index; + Expression *upr; + + inBrackets++; + nextToken(); + if (token.value == TOKrbracket) + { // array[] + inBrackets--; + e = new SliceExp(loc, e, NULL, NULL); + nextToken(); + } + else + { + index = parseAssignExp(); + if (token.value == TOKslice) + { // array[lwr .. upr] + nextToken(); + upr = parseAssignExp(); + e = new SliceExp(loc, e, index, upr); + } + else + { // array[index, i2, i3, i4, ...] + Expressions *arguments = new Expressions(); + arguments->push(index); + if (token.value == TOKcomma) + { + nextToken(); + while (token.value != TOKrbracket && token.value != TOKeof) + { + Expression *arg = parseAssignExp(); + arguments->push(arg); + if (token.value == TOKrbracket) + break; + check(TOKcomma); + } + } + e = new ArrayExp(loc, e, arguments); + } + check(TOKrbracket); + inBrackets--; + } + continue; + } + + default: + return e; + } + nextToken(); + } +} + +Expression *Parser::parseUnaryExp() +{ Expression *e; + Loc loc = this->loc; + + switch (token.value) + { + case TOKand: + nextToken(); + e = parseUnaryExp(); + e = new AddrExp(loc, e); + break; + + case TOKplusplus: + nextToken(); + e = parseUnaryExp(); + //e = new AddAssignExp(loc, e, new IntegerExp(loc, 1, Type::tint32)); + e = new PreExp(TOKpreplusplus, loc, e); + break; + + case TOKminusminus: + nextToken(); + e = parseUnaryExp(); + //e = new MinAssignExp(loc, e, new IntegerExp(loc, 1, Type::tint32)); + e = new PreExp(TOKpreminusminus, loc, e); + break; + + case TOKmul: + nextToken(); + e = parseUnaryExp(); + e = new PtrExp(loc, e); + break; + + case TOKmin: + nextToken(); + e = parseUnaryExp(); + e = new NegExp(loc, e); + break; + + case TOKadd: + nextToken(); + e = parseUnaryExp(); + e = new UAddExp(loc, e); + break; + + case TOKnot: + nextToken(); + e = parseUnaryExp(); + e = new NotExp(loc, e); + break; + + case TOKtilde: + nextToken(); + e = parseUnaryExp(); + e = new ComExp(loc, e); + break; + + case TOKdelete: + nextToken(); + e = parseUnaryExp(); + e = new DeleteExp(loc, e); + break; + + case TOKnew: + e = parseNewExp(NULL); + break; + + case TOKcast: // cast(type) expression + { + nextToken(); + check(TOKlparen); + /* Look for cast(), cast(const), cast(immutable), + * cast(shared), cast(shared const), cast(wild), cast(shared wild) + */ + unsigned m; + if (token.value == TOKrparen) + { + m = 0; + goto Lmod1; + } + else if (token.value == TOKconst && peekNext() == TOKrparen) + { + m = MODconst; + goto Lmod2; + } + else if ((token.value == TOKimmutable || token.value == TOKinvariant) && peekNext() == TOKrparen) + { + if (token.value == TOKinvariant && !global.params.useDeprecated) + error("use of 'invariant' rather than 'immutable' is deprecated"); + m = MODimmutable; + goto Lmod2; + } + else if (token.value == TOKshared && peekNext() == TOKrparen) + { + m = MODshared; + goto Lmod2; + } + else if (token.value == TOKwild && peekNext() == TOKrparen) + { + m = MODwild; + goto Lmod2; + } + else if (token.value == TOKwild && peekNext() == TOKshared && peekNext2() == TOKrparen || + token.value == TOKshared && peekNext() == TOKwild && peekNext2() == TOKrparen) + { + m = MODshared | MODwild; + goto Lmod3; + } + else if (token.value == TOKconst && peekNext() == TOKshared && peekNext2() == TOKrparen || + token.value == TOKshared && peekNext() == TOKconst && peekNext2() == TOKrparen) + { + m = MODshared | MODconst; + Lmod3: + nextToken(); + Lmod2: + nextToken(); + Lmod1: + nextToken(); + e = parseUnaryExp(); + e = new CastExp(loc, e, m); + } + else + { + Type *t = parseType(); // ( type ) + check(TOKrparen); + e = parseUnaryExp(); + e = new CastExp(loc, e, t); + } + break; + } + + case TOKwild: + case TOKshared: + case TOKconst: + case TOKinvariant: + case TOKimmutable: // immutable(type)(arguments) + { + Type *t = parseBasicType(); + e = new TypeExp(loc, t); + if (token.value != TOKlparen) + { + error("(arguments) expected following %s", t->toChars()); + return e; + } + e = new CallExp(loc, e, parseArguments()); + break; + } + + + case TOKlparen: + { Token *tk; + + tk = peek(&token); +#if CCASTSYNTAX + // If cast + if (isDeclaration(tk, 0, TOKrparen, &tk)) + { + tk = peek(tk); // skip over right parenthesis + switch (tk->value) + { + case TOKnot: + tk = peek(tk); + if (tk->value == TOKis || tk->value == TOKin) // !is or !in + break; + case TOKdot: + case TOKplusplus: + case TOKminusminus: + case TOKdelete: + case TOKnew: + case TOKlparen: + case TOKidentifier: + case TOKthis: + case TOKsuper: + case TOKint32v: + case TOKuns32v: + case TOKint64v: + case TOKuns64v: + case TOKfloat32v: + case TOKfloat64v: + case TOKfloat80v: + case TOKimaginary32v: + case TOKimaginary64v: + case TOKimaginary80v: + case TOKnull: + case TOKtrue: + case TOKfalse: + case TOKcharv: + case TOKwcharv: + case TOKdcharv: + case TOKstring: +#if 0 + case TOKtilde: + case TOKand: + case TOKmul: + case TOKmin: + case TOKadd: +#endif + case TOKfunction: + case TOKdelegate: + case TOKtypeof: + case TOKvector: +#if DMDV2 + case TOKfile: + case TOKline: +#endif + case BASIC_TYPES: // (type)int.size + { // (type) una_exp + Type *t; + + nextToken(); + t = parseType(); + check(TOKrparen); + + // if .identifier + if (token.value == TOKdot) + { + nextToken(); + if (token.value != TOKidentifier) + { error("Identifier expected following (type)."); + return NULL; + } + e = typeDotIdExp(loc, t, token.ident); + nextToken(); + e = parsePostExp(e); + } + else + { + e = parseUnaryExp(); + e = new CastExp(loc, e, t); + error("C style cast illegal, use %s", e->toChars()); + } + return e; + } + } + } +#endif + e = parsePrimaryExp(); + e = parsePostExp(e); + break; + } + default: + e = parsePrimaryExp(); + e = parsePostExp(e); + break; + } + assert(e); + + // ^^ is right associative and has higher precedence than the unary operators + while (token.value == TOKpow) + { + nextToken(); + Expression *e2 = parseUnaryExp(); + e = new PowExp(loc, e, e2); + } + + return e; +} + +Expression *Parser::parseMulExp() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + e = parseUnaryExp(); + while (1) + { + switch (token.value) + { + case TOKmul: nextToken(); e2 = parseUnaryExp(); e = new MulExp(loc,e,e2); continue; + case TOKdiv: nextToken(); e2 = parseUnaryExp(); e = new DivExp(loc,e,e2); continue; + case TOKmod: nextToken(); e2 = parseUnaryExp(); e = new ModExp(loc,e,e2); continue; + + default: + break; + } + break; + } + return e; +} + +Expression *Parser::parseAddExp() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + e = parseMulExp(); + while (1) + { + switch (token.value) + { + case TOKadd: nextToken(); e2 = parseMulExp(); e = new AddExp(loc,e,e2); continue; + case TOKmin: nextToken(); e2 = parseMulExp(); e = new MinExp(loc,e,e2); continue; + case TOKtilde: nextToken(); e2 = parseMulExp(); e = new CatExp(loc,e,e2); continue; + + default: + break; + } + break; + } + return e; +} + +Expression *Parser::parseShiftExp() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + e = parseAddExp(); + while (1) + { + switch (token.value) + { + case TOKshl: nextToken(); e2 = parseAddExp(); e = new ShlExp(loc,e,e2); continue; + case TOKshr: nextToken(); e2 = parseAddExp(); e = new ShrExp(loc,e,e2); continue; + case TOKushr: nextToken(); e2 = parseAddExp(); e = new UshrExp(loc,e,e2); continue; + + default: + break; + } + break; + } + return e; +} + +#if DMDV1 +Expression *Parser::parseRelExp() +{ Expression *e; + Expression *e2; + enum TOK op; + Loc loc = this->loc; + + e = parseShiftExp(); + while (1) + { + switch (token.value) + { + case TOKlt: + case TOKle: + case TOKgt: + case TOKge: + case TOKunord: + case TOKlg: + case TOKleg: + case TOKule: + case TOKul: + case TOKuge: + case TOKug: + case TOKue: + op = token.value; + nextToken(); + e2 = parseShiftExp(); + e = new CmpExp(op, loc, e, e2); + continue; + + case TOKnot: // could be !in + if (peekNext() == TOKin) + { + nextToken(); + nextToken(); + e2 = parseShiftExp(); + e = new InExp(loc, e, e2); + e = new NotExp(loc, e); + continue; + } + break; + + case TOKin: + nextToken(); + e2 = parseShiftExp(); + e = new InExp(loc, e, e2); + continue; + + default: + break; + } + break; + } + return e; +} +#endif + +#if DMDV1 +Expression *Parser::parseEqualExp() +{ Expression *e; + Expression *e2; + Token *t; + Loc loc = this->loc; + + e = parseRelExp(); + while (1) + { enum TOK value = token.value; + + switch (value) + { + case TOKequal: + case TOKnotequal: + nextToken(); + e2 = parseRelExp(); + e = new EqualExp(value, loc, e, e2); + continue; + + case TOKidentity: + error("'===' is no longer legal, use 'is' instead"); + goto L1; + + case TOKnotidentity: + error("'!==' is no longer legal, use '!is' instead"); + goto L1; + + case TOKis: + value = TOKidentity; + goto L1; + + case TOKnot: + // Attempt to identify '!is' + t = peek(&token); + if (t->value != TOKis) + break; + nextToken(); + value = TOKnotidentity; + goto L1; + + L1: + nextToken(); + e2 = parseRelExp(); + e = new IdentityExp(value, loc, e, e2); + continue; + + default: + break; + } + break; + } + return e; +} +#endif + +Expression *Parser::parseCmpExp() +{ Expression *e; + Expression *e2; + Token *t; + Loc loc = this->loc; + + e = parseShiftExp(); + enum TOK op = token.value; + + switch (op) + { + case TOKequal: + case TOKnotequal: + nextToken(); + e2 = parseShiftExp(); + e = new EqualExp(op, loc, e, e2); + break; + + case TOKis: + op = TOKidentity; + goto L1; + + case TOKnot: + // Attempt to identify '!is' + t = peek(&token); + if (t->value == TOKin) + { + nextToken(); + nextToken(); + e2 = parseShiftExp(); + e = new InExp(loc, e, e2); + e = new NotExp(loc, e); + break; + } + if (t->value != TOKis) + break; + nextToken(); + op = TOKnotidentity; + goto L1; + + L1: + nextToken(); + e2 = parseShiftExp(); + e = new IdentityExp(op, loc, e, e2); + break; + + case TOKlt: + case TOKle: + case TOKgt: + case TOKge: + case TOKunord: + case TOKlg: + case TOKleg: + case TOKule: + case TOKul: + case TOKuge: + case TOKug: + case TOKue: + nextToken(); + e2 = parseShiftExp(); + e = new CmpExp(op, loc, e, e2); + break; + + case TOKin: + nextToken(); + e2 = parseShiftExp(); + e = new InExp(loc, e, e2); + break; + + default: + break; + } + return e; +} + +Expression *Parser::parseAndExp() +{ + Loc loc = this->loc; + + Expression *e = parseCmpExp(); + while (token.value == TOKand) + { + checkParens(TOKand, e); + nextToken(); + Expression *e2 = parseCmpExp(); + checkParens(TOKand, e2); + e = new AndExp(loc,e,e2); + loc = this->loc; + } + return e; +} + +Expression *Parser::parseXorExp() +{ + Loc loc = this->loc; + + Expression *e = parseAndExp(); + while (token.value == TOKxor) + { + checkParens(TOKxor, e); + nextToken(); + Expression *e2 = parseAndExp(); + checkParens(TOKxor, e2); + e = new XorExp(loc, e, e2); + } + return e; +} + +Expression *Parser::parseOrExp() +{ + Loc loc = this->loc; + + Expression *e = parseXorExp(); + while (token.value == TOKor) + { + checkParens(TOKor, e); + nextToken(); + Expression *e2 = parseXorExp(); + checkParens(TOKor, e2); + e = new OrExp(loc, e, e2); + } + return e; +} + +Expression *Parser::parseAndAndExp() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + e = parseOrExp(); + while (token.value == TOKandand) + { + nextToken(); + e2 = parseOrExp(); + e = new AndAndExp(loc, e, e2); + } + return e; +} + +Expression *Parser::parseOrOrExp() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + e = parseAndAndExp(); + while (token.value == TOKoror) + { + nextToken(); + e2 = parseAndAndExp(); + e = new OrOrExp(loc, e, e2); + } + return e; +} + +Expression *Parser::parseCondExp() +{ Expression *e; + Expression *e1; + Expression *e2; + Loc loc = this->loc; + + e = parseOrOrExp(); + if (token.value == TOKquestion) + { + nextToken(); + e1 = parseExpression(); + check(TOKcolon); + e2 = parseCondExp(); + e = new CondExp(loc, e, e1, e2); + } + return e; +} + +Expression *Parser::parseAssignExp() +{ Expression *e; + Expression *e2; + Loc loc; + + e = parseCondExp(); + while (1) + { + loc = this->loc; + switch (token.value) + { +#define X(tok,ector) \ + case tok: nextToken(); e2 = parseAssignExp(); e = new ector(loc,e,e2); continue; + + X(TOKassign, AssignExp); + X(TOKaddass, AddAssignExp); + X(TOKminass, MinAssignExp); + X(TOKmulass, MulAssignExp); + X(TOKdivass, DivAssignExp); + X(TOKmodass, ModAssignExp); + X(TOKpowass, PowAssignExp); + X(TOKandass, AndAssignExp); + X(TOKorass, OrAssignExp); + X(TOKxorass, XorAssignExp); + X(TOKshlass, ShlAssignExp); + X(TOKshrass, ShrAssignExp); + X(TOKushrass, UshrAssignExp); + X(TOKcatass, CatAssignExp); + +#undef X + default: + break; + } + break; + } + return e; +} + +Expression *Parser::parseExpression() +{ Expression *e; + Expression *e2; + Loc loc = this->loc; + + //printf("Parser::parseExpression() loc = %d\n", loc.linnum); + e = parseAssignExp(); + while (token.value == TOKcomma) + { + nextToken(); + e2 = parseAssignExp(); + e = new CommaExp(loc, e, e2); + loc = this->loc; + } + return e; +} + + +/************************* + * Collect argument list. + * Assume current token is ',', '(' or '['. + */ + +Expressions *Parser::parseArguments() +{ // function call + Expressions *arguments; + Expression *arg; + enum TOK endtok; + + arguments = new Expressions(); + if (token.value == TOKlbracket) + endtok = TOKrbracket; + else + endtok = TOKrparen; + + { + nextToken(); + while (token.value != endtok && token.value != TOKeof) + { + arg = parseAssignExp(); + arguments->push(arg); + if (token.value == endtok) + break; + check(TOKcomma); + } + check(endtok); + } + return arguments; +} + +/******************************************* + */ + +Expression *Parser::parseNewExp(Expression *thisexp) +{ Type *t; + Expressions *newargs; + Expressions *arguments = NULL; + Expression *e; + Loc loc = this->loc; + + nextToken(); + newargs = NULL; + if (token.value == TOKlparen) + { + newargs = parseArguments(); + } + + // An anonymous nested class starts with "class" + if (token.value == TOKclass) + { + nextToken(); + if (token.value == TOKlparen) + arguments = parseArguments(); + + BaseClasses *baseclasses = NULL; + if (token.value != TOKlcurly) + baseclasses = parseBaseClasses(); + + Identifier *id = NULL; + ClassDeclaration *cd = new ClassDeclaration(loc, id, baseclasses); + + if (token.value != TOKlcurly) + { error("{ members } expected for anonymous class"); + cd->members = NULL; + } + else + { + nextToken(); + Dsymbols *decl = parseDeclDefs(0); + if (token.value != TOKrcurly) + error("class member expected"); + nextToken(); + cd->members = decl; + } + + e = new NewAnonClassExp(loc, thisexp, newargs, cd, arguments); + + return e; + } + + t = parseBasicType(); + t = parseBasicType2(t); + if (t->ty == Taarray) + { TypeAArray *taa = (TypeAArray *)t; + Type *index = taa->index; + + Expression *e = index->toExpression(); + if (e) + { arguments = new Expressions(); + arguments->push(e); + t = new TypeDArray(taa->next); + } + else + { + error("need size of rightmost array, not type %s", index->toChars()); + return new NullExp(loc); + } + } + else if (t->ty == Tsarray) + { + TypeSArray *tsa = (TypeSArray *)t; + Expression *e = tsa->dim; + + arguments = new Expressions(); + arguments->push(e); + t = new TypeDArray(tsa->next); + } + else if (token.value == TOKlparen) + { + arguments = parseArguments(); + } + e = new NewExp(loc, thisexp, newargs, t, arguments); + return e; +} + +/********************************************** + */ + +void Parser::addComment(Dsymbol *s, unsigned char *blockComment) +{ + s->addComment(combineComments(blockComment, token.lineComment)); + token.lineComment = NULL; +} + + +/********************************** + * Set operator precedence for each operator. + */ + +enum PREC precedence[TOKMAX]; + +void initPrecedence() +{ + for (size_t i = 0; i < TOKMAX; i++) + precedence[i] = PREC_zero; + + precedence[TOKtype] = PREC_expr; + precedence[TOKerror] = PREC_expr; + + precedence[TOKtypeof] = PREC_primary; + precedence[TOKmixin] = PREC_primary; + + precedence[TOKdotvar] = PREC_primary; + precedence[TOKimport] = PREC_primary; + precedence[TOKidentifier] = PREC_primary; + precedence[TOKthis] = PREC_primary; + precedence[TOKsuper] = PREC_primary; + precedence[TOKint64] = PREC_primary; + precedence[TOKfloat64] = PREC_primary; + precedence[TOKcomplex80] = PREC_primary; + precedence[TOKnull] = PREC_primary; + precedence[TOKstring] = PREC_primary; + precedence[TOKarrayliteral] = PREC_primary; + precedence[TOKassocarrayliteral] = PREC_primary; +#if DMDV2 + precedence[TOKfile] = PREC_primary; + precedence[TOKline] = PREC_primary; +#endif + precedence[TOKtypeid] = PREC_primary; + precedence[TOKis] = PREC_primary; + precedence[TOKassert] = PREC_primary; + precedence[TOKhalt] = PREC_primary; + precedence[TOKtemplate] = PREC_primary; + precedence[TOKdsymbol] = PREC_primary; + precedence[TOKfunction] = PREC_primary; + precedence[TOKvar] = PREC_primary; + precedence[TOKsymoff] = PREC_primary; + precedence[TOKstructliteral] = PREC_primary; + precedence[TOKarraylength] = PREC_primary; + precedence[TOKremove] = PREC_primary; + precedence[TOKtuple] = PREC_primary; +#if DMDV2 + precedence[TOKtraits] = PREC_primary; + precedence[TOKdefault] = PREC_primary; + precedence[TOKoverloadset] = PREC_primary; +#endif + + // post + precedence[TOKdotti] = PREC_primary; + precedence[TOKdot] = PREC_primary; + precedence[TOKdottd] = PREC_primary; + precedence[TOKdotexp] = PREC_primary; + precedence[TOKdottype] = PREC_primary; +// precedence[TOKarrow] = PREC_primary; + precedence[TOKplusplus] = PREC_primary; + precedence[TOKminusminus] = PREC_primary; +#if DMDV2 + precedence[TOKpreplusplus] = PREC_primary; + precedence[TOKpreminusminus] = PREC_primary; +#endif + precedence[TOKcall] = PREC_primary; + precedence[TOKslice] = PREC_primary; + precedence[TOKarray] = PREC_primary; + precedence[TOKindex] = PREC_primary; + + precedence[TOKdelegate] = PREC_unary; + precedence[TOKaddress] = PREC_unary; + precedence[TOKstar] = PREC_unary; + precedence[TOKneg] = PREC_unary; + precedence[TOKuadd] = PREC_unary; + precedence[TOKnot] = PREC_unary; + precedence[TOKtobool] = PREC_add; + precedence[TOKtilde] = PREC_unary; + precedence[TOKdelete] = PREC_unary; + precedence[TOKnew] = PREC_unary; + precedence[TOKnewanonclass] = PREC_unary; + precedence[TOKcast] = PREC_unary; + +#if DMDV2 + precedence[TOKvector] = PREC_unary; + precedence[TOKpow] = PREC_pow; +#endif + + precedence[TOKmul] = PREC_mul; + precedence[TOKdiv] = PREC_mul; + precedence[TOKmod] = PREC_mul; + + precedence[TOKadd] = PREC_add; + precedence[TOKmin] = PREC_add; + precedence[TOKcat] = PREC_add; + + precedence[TOKshl] = PREC_shift; + precedence[TOKshr] = PREC_shift; + precedence[TOKushr] = PREC_shift; + + precedence[TOKlt] = PREC_rel; + precedence[TOKle] = PREC_rel; + precedence[TOKgt] = PREC_rel; + precedence[TOKge] = PREC_rel; + precedence[TOKunord] = PREC_rel; + precedence[TOKlg] = PREC_rel; + precedence[TOKleg] = PREC_rel; + precedence[TOKule] = PREC_rel; + precedence[TOKul] = PREC_rel; + precedence[TOKuge] = PREC_rel; + precedence[TOKug] = PREC_rel; + precedence[TOKue] = PREC_rel; + precedence[TOKin] = PREC_rel; + +#if 0 + precedence[TOKequal] = PREC_equal; + precedence[TOKnotequal] = PREC_equal; + precedence[TOKidentity] = PREC_equal; + precedence[TOKnotidentity] = PREC_equal; +#else + /* Note that we changed precedence, so that < and != have the same + * precedence. This change is in the parser, too. + */ + precedence[TOKequal] = PREC_rel; + precedence[TOKnotequal] = PREC_rel; + precedence[TOKidentity] = PREC_rel; + precedence[TOKnotidentity] = PREC_rel; +#endif + + precedence[TOKand] = PREC_and; + + precedence[TOKxor] = PREC_xor; + + precedence[TOKor] = PREC_or; + + precedence[TOKandand] = PREC_andand; + + precedence[TOKoror] = PREC_oror; + + precedence[TOKquestion] = PREC_cond; + + precedence[TOKassign] = PREC_assign; + precedence[TOKconstruct] = PREC_assign; + precedence[TOKblit] = PREC_assign; + precedence[TOKaddass] = PREC_assign; + precedence[TOKminass] = PREC_assign; + precedence[TOKcatass] = PREC_assign; + precedence[TOKmulass] = PREC_assign; + precedence[TOKdivass] = PREC_assign; + precedence[TOKmodass] = PREC_assign; +#if DMDV2 + precedence[TOKpowass] = PREC_assign; +#endif + precedence[TOKshlass] = PREC_assign; + precedence[TOKshrass] = PREC_assign; + precedence[TOKushrass] = PREC_assign; + precedence[TOKandass] = PREC_assign; + precedence[TOKorass] = PREC_assign; + precedence[TOKxorass] = PREC_assign; + + precedence[TOKcomma] = PREC_expr; + precedence[TOKdeclaration] = PREC_expr; +} + + diff --git a/parse.h b/parse.h new file mode 100644 index 00000000..716e775a --- /dev/null +++ b/parse.h @@ -0,0 +1,187 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_PARSE_H +#define DMD_PARSE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "arraytypes.h" +#include "lexer.h" +#include "enum.h" + +struct Type; +struct TypeQualified; +struct Expression; +struct Declaration; +struct Statement; +struct Import; +struct Initializer; +struct FuncDeclaration; +struct CtorDeclaration; +struct PostBlitDeclaration; +struct DtorDeclaration; +struct StaticCtorDeclaration; +struct StaticDtorDeclaration; +struct SharedStaticCtorDeclaration; +struct SharedStaticDtorDeclaration; +struct ConditionalDeclaration; +struct InvariantDeclaration; +struct UnitTestDeclaration; +struct NewDeclaration; +struct DeleteDeclaration; +struct Condition; +struct Module; +struct ModuleDeclaration; +struct TemplateDeclaration; +struct TemplateInstance; +struct StaticAssert; + +/************************************ + * These control how parseStatement() works. + */ + +enum ParseStatementFlags +{ + PSsemi = 1, // empty ';' statements are allowed, but deprecated + PSscope = 2, // start a new scope + PScurly = 4, // { } statement is required + PScurlyscope = 8, // { } starts a new scope + PSsemi_ok = 0x10, // empty ';' are really ok +}; + + +struct Parser : Lexer +{ + ModuleDeclaration *md; + enum LINK linkage; + Loc endloc; // set to location of last right curly + int inBrackets; // inside [] of array index or slice + Loc lookingForElse; // location of lonely if looking for an else + + Parser(Module *module, unsigned char *base, unsigned length, int doDocComment); + + Dsymbols *parseModule(); + Dsymbols *parseDeclDefs(int once); + Dsymbols *parseAutoDeclarations(StorageClass storageClass, unsigned char *comment); + Dsymbols *parseBlock(); + void composeStorageClass(StorageClass stc); + StorageClass parseAttribute(); + StorageClass parsePostfix(); + Expression *parseConstraint(); + TemplateDeclaration *parseTemplateDeclaration(int ismixin); + TemplateParameters *parseTemplateParameterList(int flag = 0); + Dsymbol *parseMixin(); + Objects *parseTemplateArgumentList(); + Objects *parseTemplateArgumentList2(); + Objects *parseTemplateArgument(); + StaticAssert *parseStaticAssert(); + TypeQualified *parseTypeof(); + Type *parseVector(); + enum LINK parseLinkage(); + Condition *parseDebugCondition(); + Condition *parseVersionCondition(); + Condition *parseStaticIfCondition(); + Dsymbol *parseCtor(); + PostBlitDeclaration *parsePostBlit(); + DtorDeclaration *parseDtor(); + StaticCtorDeclaration *parseStaticCtor(); + StaticDtorDeclaration *parseStaticDtor(); + SharedStaticCtorDeclaration *parseSharedStaticCtor(); + SharedStaticDtorDeclaration *parseSharedStaticDtor(); + InvariantDeclaration *parseInvariant(); + UnitTestDeclaration *parseUnitTest(); + NewDeclaration *parseNew(); + DeleteDeclaration *parseDelete(); + Parameters *parseParameters(int *pvarargs, TemplateParameters **tpl = NULL); + EnumDeclaration *parseEnum(); + Dsymbol *parseAggregate(); + BaseClasses *parseBaseClasses(); + Import *parseImport(Dsymbols *decldefs, int isstatic); + Type *parseType(Identifier **pident = NULL, TemplateParameters **tpl = NULL); + Type *parseBasicType(); + Type *parseBasicType2(Type *t); + Type *parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl = NULL, StorageClass storage_class = 0, int* pdisable = NULL); + Dsymbols *parseDeclarations(StorageClass storage_class, unsigned char *comment); + void parseContracts(FuncDeclaration *f); + void checkDanglingElse(Loc elseloc); + Statement *parseStatement(int flags); + Initializer *parseInitializer(); + Expression *parseDefaultInitExp(); + void check(Loc loc, enum TOK value); + void check(enum TOK value); + void check(enum TOK value, const char *string); + void checkParens(enum TOK value, Expression *e); + int isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt); + int isBasicType(Token **pt); + int isDeclarator(Token **pt, int *haveId, enum TOK endtok); + int isParameters(Token **pt); + int isExpression(Token **pt); + int isTemplateInstance(Token *t, Token **pt); + int skipParens(Token *t, Token **pt); + int skipAttributes(Token *t, Token **pt); + + Expression *parseExpression(); + Expression *parsePrimaryExp(); + Expression *parseUnaryExp(); + Expression *parsePostExp(Expression *e); + Expression *parseMulExp(); + Expression *parseAddExp(); + Expression *parseShiftExp(); +#if DMDV1 + Expression *parseRelExp(); + Expression *parseEqualExp(); +#endif + Expression *parseCmpExp(); + Expression *parseAndExp(); + Expression *parseXorExp(); + Expression *parseOrExp(); + Expression *parseAndAndExp(); + Expression *parseOrOrExp(); + Expression *parseCondExp(); + Expression *parseAssignExp(); + + Expressions *parseArguments(); + + Expression *parseNewExp(Expression *thisexp); + + void addComment(Dsymbol *s, unsigned char *blockComment); +}; + +// Operator precedence - greater values are higher precedence + +enum PREC +{ + PREC_zero, + PREC_expr, + PREC_assign, + PREC_cond, + PREC_oror, + PREC_andand, + PREC_or, + PREC_xor, + PREC_and, + PREC_equal, + PREC_rel, + PREC_shift, + PREC_add, + PREC_mul, + PREC_pow, + PREC_unary, + PREC_primary, +}; + +extern enum PREC precedence[TOKMAX]; + +void initPrecedence(); + +#endif /* DMD_PARSE_H */ diff --git a/ph.c b/ph.c new file mode 100644 index 00000000..2cfb8fef --- /dev/null +++ b/ph.c @@ -0,0 +1,346 @@ + + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if __DMC__ +#include +#else +#include +#endif + +#include "cc.h" +#include "global.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/********************************************** + * Do our own storage allocator, a replacement + * for malloc/free. + */ + +struct Heap +{ + Heap *prev; // previous heap + unsigned char *buf; // buffer + unsigned char *p; // high water mark + unsigned nleft; // number of bytes left +}; + +Heap *heap=NULL; + +void ph_init() +{ + if (!heap) { + heap = (Heap *)calloc(1,sizeof(Heap)); + } + assert(heap); +} + + + +void ph_term() +{ + //printf("ph_term()\n"); +#if _WINDLL || DEBUG + Heap *h; + Heap *hprev; + + for (h = heap; h; h = hprev) + { + hprev = h->prev; + free(h->buf); + free(h); + } +#endif +} + +void ph_newheap(size_t nbytes) +{ unsigned newsize; + Heap *h; + + h = (Heap *) malloc(sizeof(Heap)); + if (!h) + err_nomem(); + + newsize = (nbytes > 0xFF00) ? nbytes : 0xFF00; + h->buf = (unsigned char *) malloc(newsize); + if (!h->buf) + { + free(h); + err_nomem(); + } + h->nleft = newsize; + h->p = h->buf; + h->prev = heap; + heap = h; +} + +void *ph_malloc(size_t nbytes) +{ unsigned char *p; + +#ifdef DEBUG + util_progress(); +#endif + nbytes += sizeof(unsigned) * 2; + nbytes &= ~(sizeof(unsigned) - 1); + + if (nbytes >= heap->nleft) + ph_newheap(nbytes); + p = heap->p; + heap->p += nbytes; + heap->nleft -= nbytes; + *(unsigned *)p = nbytes - sizeof(unsigned); + p += sizeof(unsigned); + return p; +} + +#if ASM86 +__declspec(naked) void *ph_calloc(size_t nbytes) +{ + _asm + { + push dword ptr 4[ESP] + call ph_malloc + test EAX,EAX + je L25 + push dword ptr 4[ESP] + push 0 + push EAX + call memset + add ESP,0Ch +L25: ret 4 + } +} +#else +void *ph_calloc(size_t nbytes) +{ void *p; + + p = ph_malloc(nbytes); + return p ? memset(p,0,nbytes) : p; +} +#endif + +void ph_free(void *p) +{ +} + +void *ph_realloc(void *p,size_t nbytes) +{ + //dbg_printf("ph_realloc(%p,%d)\n",p,nbytes); + if (!p) + return ph_malloc(nbytes); + if (!nbytes) + { ph_free(p); + return NULL; + } + void *newp = ph_malloc(nbytes); + if (newp) + { unsigned oldsize = ((unsigned *)p)[-1]; + memcpy(newp,p,oldsize); + ph_free(p); + } + return newp; +} + +void err_nomem() +{ + printf("Error: out of memory\n"); + err_exit(); +} + +#if !MEM_DEBUG + + +/*********************** + * Replacement for the standard C++ library operator delete(). + */ + +#if 0 +#undef delete +void __cdecl operator delete(void *p) +{ +} +#endif + +#if 0 + +/***************************************** + * Using this for array allocations gives + * us an easy way to get at the array dimension. + * Overloading operator new[]() doesn't work because that + * gives us the array allocated size, but we need the dimension. + */ + +#ifdef DEBUG +#define ARRAY_PROLOG 'prol' +#define ARRAY_EPILOG 'epil' +#define ARRAY_FILL 'f' +static int array_max_dim; + +/********************************* + * Run "reasonableness" checks on array. + */ + +void array_debug(void *a) +{ size_t *p = (size_t *)a; + + assert(p); + assert(p[-2] == ARRAY_PROLOG); + int length = p[-1]; + assert(length >= 0 && length <= array_max_dim); + assert(p[length] == ARRAY_EPILOG); + + // Since array contents are aligned pointers or NULL... + for (int i = 0; i < length; i++) + assert((p[i] & 3) == 0); +} + +#endif + +#undef array_new +void *array_new(int sizelem, int dim) +{ size_t *p; + size_t sz; + +#ifdef DEBUG + assert(sizelem == sizeof(void *)); // must be array of pointers + if (!(dim >= 0 && dim < 10000)) + printf("dim = %d\n",dim); + assert(dim >= 0 && dim < 10000); + if (dim > array_max_dim) + array_max_dim = dim; + + sz = sizeof(size_t) * (3 + dim); + p = ph_calloc(sz); + if (p) + { p[0] = ARRAY_PROLOG; // leading sentinel + p[1] = dim; + p[2 + dim] = ARRAY_EPILOG; // trailing sentinel + p += 2; + array_debug(p); + } +#else + + sz = sizeof(size_t) * (1 + dim); + p = ph_calloc(sz); + if (p) + *p++ = dim; +#endif + return (void *)p; +} + +#undef array_delete +void array_delete(void *a, int sizelem) +{ + size_t *p = (size_t *)a; +#ifdef DEBUG + + array_debug(p); + assert(sizelem == sizeof(size_t)); + memset(p - 2,ARRAY_FILL,sizeof(size_t *) * (3 + p[-1])); + ph_free(p - 2); +#else + ((size_t *)p)--; + ph_free(p); +#endif +} + +size_t array_length(void *p) +{ + array_debug(p); + return ((size_t *)p)[-1]; +} + +/******************************** + * Same as System.arraycopy() + */ + +void array_copy(void *f,int fi,void *t,int ti,int length) +{ +#ifdef DEBUG + assert(length >= 0 && length <= array_max_dim); + int f_length = array_length(f); + int t_length = array_length(t); + assert(fi >= 0 && fi + length <= f_length); + assert(ti >= 0 && ti + length <= t_length); +#endif + memcpy(&((void **)t)[ti],&((void **)f)[fi],length * sizeof(void *)); +} + +/************************************ + * Reallocate. + */ + +#undef array_renew +void **array_renew(void *a,int newlength) +{ int sz = sizeof(void *); + int hsz = sizeof(void *); + + if (!a) + a = array_new(sz,newlength); + else + { + int oldlength = array_length(a); +#ifdef DEBUG + void *b = array_new(sizeof(void *),newlength); + int len = (oldlength < newlength) ? oldlength : newlength; + array_copy(a,0,b,0,len); + array_delete(a,sizeof(void *)); + a = b; +#else + if (oldlength < newlength) + { + (char *)a -= hsz; + a = ph_realloc(a,hsz + newlength * sz); + if (!a) + goto Lret; + (char *)a += hsz; + memset(&((void **)a)[oldlength],0,(newlength - oldlength) * sz); + } + else if (oldlength > newlength) + { + ; + } + ((size_t *)a)[-1] = newlength; +#endif + } +Lret: + return a; +} + +/****************************************** + * Sort an array. + */ + +#if MACINTOSH +extern "C" int acompare(const void *e1,const void *e2) +#else +int __cdecl acompare(const void *e1,const void *e2) +#endif +{ + Object *o1 = *(Object **)e1; + Object *o2 = *(Object **)e2; + + return o1->compare(o2); +} + +void array_sort(void *a) +{ + qsort(a,array_length(a),sizeof(void *),acompare); +} + +#endif +#endif diff --git a/posix.mak b/posix.mak new file mode 100644 index 00000000..b35596eb --- /dev/null +++ b/posix.mak @@ -0,0 +1,674 @@ +# NOTE: need to validate solaris behavior +ifeq (,$(TARGET)) + OS:=$(shell uname) + OSVER:=$(shell uname -r) + ifeq (Darwin,$(OS)) + TARGET=OSX + else + ifeq (Linux,$(OS)) + TARGET=LINUX + else + ifeq (FreeBSD,$(OS)) + TARGET=FREEBSD + else + ifeq (OpenBSD,$(OS)) + TARGET=OPENBSD + else + ifeq (Solaris,$(OS)) + TARGET=SOLARIS + else + $(error Unrecognized or unsupported OS for uname: $(OS)) + endif + endif + endif + endif + endif +endif + +C=backend +TK=tk +ROOT=root + +MODEL=32 + +ifeq (OSX,$(TARGET)) + ## See: http://developer.apple.com/documentation/developertools/conceptual/cross_development/Using/chapter_3_section_2.html#//apple_ref/doc/uid/20002000-1114311-BABGCAAB + ENVP= MACOSX_DEPLOYMENT_TARGET=10.3 + #SDK=/Developer/SDKs/MacOSX10.4u.sdk #doesn't work because can't find + #SDK=/Developer/SDKs/MacOSX10.5.sdk + #SDK=/Developer/SDKs/MacOSX10.6.sdk + SDK:=$(if $(filter 11.%, $(OSVER)), /Developer/SDKs/MacOSX10.6.sdk, /Developer/SDKs/MacOSX10.5.sdk) + TARGET_CFLAGS=-isysroot ${SDK} + #-syslibroot is only passed to libtool, not ld. + #if gcc sees -isysroot it should pass -syslibroot to the linker when needed + #LDFLAGS=-lstdc++ -isysroot ${SDK} -Wl,-syslibroot,${SDK} -framework CoreServices + LDFLAGS=-lstdc++ -isysroot ${SDK} -Wl -framework CoreServices +else + LDFLAGS=-lm -lstdc++ -lpthread +endif + +HOST_CC=g++ +CC=$(HOST_CC) -m$(MODEL) $(TARGET_CFLAGS) + +#OPT=-g -g3 +#OPT=-O2 + +#COV=-fprofile-arcs -ftest-coverage + +WARNINGS=-Wno-deprecated -Wstrict-aliasing + +#GFLAGS = $(WARNINGS) -D__near= -D__pascal= -fno-exceptions -g -DDEBUG=1 -DUNITTEST $(COV) +GFLAGS = $(WARNINGS) -D__near= -D__pascal= -fno-exceptions -O2 + +CFLAGS = $(GFLAGS) -I$(ROOT) -DMARS=1 -DTARGET_$(TARGET)=1 +MFLAGS = $(GFLAGS) -I$C -I$(TK) -DMARS=1 -DTARGET_$(TARGET)=1 + +CH= $C/cc.h $C/global.h $C/oper.h $C/code.h $C/type.h \ + $C/dt.h $C/cgcv.h $C/el.h $C/iasm.h + +DMD_OBJS = \ + access.o array.o attrib.o bcomplex.o blockopt.o \ + cast.o code.o cg.o cg87.o cgxmm.o cgcod.o cgcs.o cgelem.o cgen.o \ + cgreg.o cgsched.o class.o cod1.o cod2.o cod3.o cod4.o cod5.o \ + constfold.o irstate.o dchar.o cond.o debug.o \ + declaration.o dsymbol.o dt.o dump.o e2ir.o ee.o eh.o el.o \ + dwarf.o enum.o evalu8.o expression.o func.o gdag.o gflow.o \ + glocal.o gloop.o glue.o gnuc.o go.o gother.o html.o iasm.o id.o \ + identifier.o impcnvtab.o import.o inifile.o init.o inline.o \ + lexer.o link.o lstring.o mangle.o mars.o rmem.o module.o msc.o mtype.o \ + nteh.o cppmangle.o opover.o optimize.o os.o out.o outbuf.o \ + parse.o ph.o ptrntab.o root.o rtlsym.o s2ir.o scope.o statement.o \ + stringtable.o struct.o csymbol.o template.o tk.o tocsym.o todt.o \ + type.o typinf.o util.o var.o version.o strtold.o utf.o staticassert.o \ + unialpha.o toobj.o toctype.o toelfdebug.o entity.o doc.o macro.o \ + hdrgen.o delegatize.o aa.o ti_achar.o toir.o interpret.o traits.o \ + builtin.o clone.o aliasthis.o intrange.o \ + man.o arrayop.o port.o response.o async.o json.o speller.o aav.o unittests.o \ + imphint.o argtypes.o ti_pvoid.o apply.o canthrow.o sideeffect.o + +ifeq (OSX,$(TARGET)) + DMD_OBJS += libmach.o machobj.o +else + DMD_OBJS += libelf.o elfobj.o +endif + +SRC = win32.mak posix.mak \ + mars.c enum.c struct.c dsymbol.c import.c idgen.c impcnvgen.c \ + identifier.c mtype.c expression.c optimize.c template.h \ + template.c lexer.c declaration.c cast.c cond.h cond.c link.c \ + aggregate.h parse.c statement.c constfold.c version.h version.c \ + inifile.c iasm.c module.c scope.c dump.c init.h init.c attrib.h \ + attrib.c opover.c class.c mangle.c tocsym.c func.c inline.c \ + access.c complex_t.h irstate.h irstate.c glue.c msc.c ph.c tk.c \ + s2ir.c todt.c e2ir.c util.c identifier.h parse.h intrange.h \ + scope.h enum.h import.h mars.h module.h mtype.h dsymbol.h \ + declaration.h lexer.h expression.h irstate.h statement.h eh.c \ + utf.h utf.c staticassert.h staticassert.c unialpha.c \ + typinf.c toobj.c toctype.c tocvdebug.c toelfdebug.c entity.c \ + doc.h doc.c macro.h macro.c hdrgen.h hdrgen.c arraytypes.h \ + delegatize.c toir.h toir.c interpret.c traits.c cppmangle.c \ + builtin.c clone.c lib.h libomf.c libelf.c libmach.c arrayop.c \ + aliasthis.h aliasthis.c json.h json.c unittests.c imphint.c \ + argtypes.c intrange.c apply.c canthrow.c sideeffect.c \ + $C/cdef.h $C/cc.h $C/oper.h $C/ty.h $C/optabgen.c \ + $C/global.h $C/code.h $C/type.h $C/dt.h $C/cgcv.h \ + $C/el.h $C/iasm.h $C/rtlsym.h $C/html.h \ + $C/bcomplex.c $C/blockopt.c $C/cg.c $C/cg87.c $C/cgxmm.c \ + $C/cgcod.c $C/cgcs.c $C/cgcv.c $C/cgelem.c $C/cgen.c $C/cgobj.c \ + $C/cgreg.c $C/var.c $C/strtold.c \ + $C/cgsched.c $C/cod1.c $C/cod2.c $C/cod3.c $C/cod4.c $C/cod5.c \ + $C/code.c $C/symbol.c $C/debug.c $C/dt.c $C/ee.c $C/el.c \ + $C/evalu8.c $C/go.c $C/gflow.c $C/gdag.c \ + $C/gother.c $C/glocal.c $C/gloop.c $C/html.c $C/newman.c \ + $C/nteh.c $C/os.c $C/out.c $C/outbuf.c $C/ptrntab.c $C/rtlsym.c \ + $C/type.c $C/melf.h $C/mach.h $C/bcomplex.h \ + $C/cdeflnx.h $C/outbuf.h $C/token.h $C/tassert.h \ + $C/elfobj.c $C/cv4.h $C/dwarf2.h $C/exh.h $C/go.h \ + $C/dwarf.c $C/dwarf.h $C/aa.h $C/aa.c $C/tinfo.h $C/ti_achar.c \ + $C/ti_pvoid.c \ + $C/machobj.c \ + $C/xmm.h \ + $(TK)/filespec.h $(TK)/mem.h $(TK)/list.h $(TK)/vec.h \ + $(TK)/filespec.c $(TK)/mem.c $(TK)/vec.c $(TK)/list.c \ + $(ROOT)/dchar.h $(ROOT)/dchar.c $(ROOT)/lstring.h \ + $(ROOT)/lstring.c $(ROOT)/root.h $(ROOT)/root.c $(ROOT)/array.c \ + $(ROOT)/rmem.h $(ROOT)/rmem.c $(ROOT)/port.h $(ROOT)/port.c \ + $(ROOT)/gnuc.h $(ROOT)/gnuc.c $(ROOT)/man.c \ + $(ROOT)/stringtable.h $(ROOT)/stringtable.c \ + $(ROOT)/response.c $(ROOT)/async.h $(ROOT)/async.c \ + $(ROOT)/aav.h $(ROOT)/aav.c \ + $(ROOT)/speller.h $(ROOT)/speller.c + + +all: dmd + +dmd: $(DMD_OBJS) + $(ENVP) $(HOST_CC) -o dmd -m$(MODEL) $(COV) $(DMD_OBJS) $(LDFLAGS) + +clean: + rm -f $(DMD_OBJS) dmd optab.o id.o impcnvgen idgen id.c id.h \ + impcnvtab.c optabgen debtab.c optab.c cdxxx.c elxxx.c fltables.c \ + tytab.c core \ + *.cov *.gcda *.gcno + +######## optabgen generates some source + +optabgen: $C/optabgen.c $C/cc.h $C/oper.h + $(ENVP) $(CC) $(MFLAGS) $< -o optabgen + ./optabgen + +optabgen_output = debtab.c optab.c cdxxx.c elxxx.c fltables.c tytab.c +$(optabgen_output) : optabgen + +######## idgen generates some source + +idgen_output = id.h id.c +$(idgen_output) : idgen + +idgen : idgen.c + $(ENVP) $(CC) idgen.c -o idgen + ./idgen + +######### impcnvgen generates some source + +impcnvtab_output = impcnvtab.c +$(impcnvtab_output) : impcnvgen + +impcnvgen : mtype.h impcnvgen.c + $(ENVP) $(CC) $(CFLAGS) impcnvgen.c -o impcnvgen + ./impcnvgen + +######### + +$(DMD_OBJS) : $(idgen_output) $(optabgen_output) $(impcnvgen_output) + +aa.o: $C/aa.c $C/aa.h $C/tinfo.h + $(CC) -c $(MFLAGS) -I. $< + +aav.o: $(ROOT)/aav.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +access.o: access.c + $(CC) -c $(CFLAGS) $< + +aliasthis.o: aliasthis.c + $(CC) -c $(CFLAGS) $< + +apply.o: apply.c + $(CC) -c $(CFLAGS) $< + +argtypes.o: argtypes.c + $(CC) -c $(CFLAGS) $< + +array.o: $(ROOT)/array.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +arrayop.o: arrayop.c + $(CC) -c $(CFLAGS) $< + +async.o: $(ROOT)/async.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +attrib.o: attrib.c + $(CC) -c $(CFLAGS) $< + +bcomplex.o: $C/bcomplex.c + $(CC) -c $(MFLAGS) $< + +blockopt.o: $C/blockopt.c + $(CC) -c $(MFLAGS) $< + +builtin.o: builtin.c + $(CC) -c $(CFLAGS) $< + +canthrow.o: canthrow.c + $(CC) -c $(CFLAGS) $< + +cast.o: cast.c + $(CC) -c $(CFLAGS) $< + +cg.o: $C/cg.c fltables.c + $(CC) -c $(MFLAGS) -I. $< + +cg87.o: $C/cg87.c + $(CC) -c $(MFLAGS) $< + +cgcod.o: $C/cgcod.c + $(CC) -c $(MFLAGS) -I. $< + +cgcs.o: $C/cgcs.c + $(CC) -c $(MFLAGS) $< + +cgcv.o: $C/cgcv.c + $(CC) -c $(MFLAGS) $< + +cgelem.o: $C/cgelem.c $C/rtlsym.h + $(CC) -c $(MFLAGS) -I. $< + +cgen.o: $C/cgen.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +cgobj.o: $C/cgobj.c + $(CC) -c $(MFLAGS) $< + +cgreg.o: $C/cgreg.c + $(CC) -c $(MFLAGS) $< + +cgsched.o: $C/cgsched.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +cgxmm.o: $C/cgxmm.c + $(CC) -c $(MFLAGS) $< + +class.o: class.c + $(CC) -c $(CFLAGS) $< + +clone.o: clone.c + $(CC) -c $(CFLAGS) $< + +cod1.o: $C/cod1.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +cod2.o: $C/cod2.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +cod3.o: $C/cod3.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +cod4.o: $C/cod4.c + $(CC) -c $(MFLAGS) $< + +cod5.o: $C/cod5.c + $(CC) -c $(MFLAGS) $< + +code.o: $C/code.c + $(CC) -c $(MFLAGS) $< + +constfold.o: constfold.c + $(CC) -c $(CFLAGS) $< + +irstate.o: irstate.c irstate.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +csymbol.o: $C/symbol.c + $(CC) -c $(MFLAGS) $< -o $@ + +dchar.o: $(ROOT)/dchar.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +cond.o: cond.c + $(CC) -c $(CFLAGS) $< + +cppmangle.o: cppmangle.c + $(CC) -c $(CFLAGS) $< + +debug.o: $C/debug.c + $(CC) -c $(MFLAGS) -I. $< + +declaration.o: declaration.c + $(CC) -c $(CFLAGS) $< + +delegatize.o: delegatize.c + $(CC) -c $(CFLAGS) $< + +doc.o: doc.c + $(CC) -c $(CFLAGS) $< + +dsymbol.o: dsymbol.c + $(CC) -c $(CFLAGS) $< + +dt.o: $C/dt.c $C/dt.h + $(CC) -c $(MFLAGS) $< + +dump.o: dump.c + $(CC) -c $(CFLAGS) $< + +dwarf.o: $C/dwarf.c $C/dwarf.h + $(CC) -c $(MFLAGS) -I. $< + +e2ir.o: e2ir.c $C/rtlsym.h expression.h toir.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +ee.o: $C/ee.c + $(CC) -c $(MFLAGS) $< + +eh.o: eh.c $C/cc.h $C/code.h $C/type.h $C/dt.h + $(CC) -c $(MFLAGS) $< + +el.o: $C/el.c $C/rtlsym.h $C/el.h + $(CC) -c $(MFLAGS) $< + +elfobj.o: $C/elfobj.c + $(CC) -c $(MFLAGS) $< + +entity.o: entity.c + $(CC) -c $(CFLAGS) $< + +enum.o: enum.c + $(CC) -c $(CFLAGS) $< + +evalu8.o: $C/evalu8.c + $(CC) -c $(MFLAGS) $< + +expression.o: expression.c expression.h + $(CC) -c $(CFLAGS) $< + +func.o: func.c + $(CC) -c $(CFLAGS) $< + +gdag.o: $C/gdag.c + $(CC) -c $(MFLAGS) $< + +gflow.o: $C/gflow.c + $(CC) -c $(MFLAGS) $< + +#globals.o: globals.c +# $(CC) -c $(CFLAGS) $< + +glocal.o: $C/glocal.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +gloop.o: $C/gloop.c + $(CC) -c $(MFLAGS) $< + +glue.o: glue.c $(CH) $C/rtlsym.h mars.h module.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +gnuc.o: $(ROOT)/gnuc.c $(ROOT)/gnuc.h + $(CC) -c $(GFLAGS) $< + +go.o: $C/go.c + $(CC) -c $(MFLAGS) $< + +gother.o: $C/gother.c + $(CC) -c $(MFLAGS) $< + +hdrgen.o: hdrgen.c + $(CC) -c $(CFLAGS) $< + +html.o: $C/html.c $(CH) $C/html.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +iasm.o: iasm.c $(CH) $C/iasm.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +id.o: id.c id.h + $(CC) -c $(CFLAGS) $< + +identifier.o: identifier.c + $(CC) -c $(CFLAGS) $< + +impcnvtab.o: impcnvtab.c mtype.h + $(CC) -c $(CFLAGS) -I$(ROOT) $< + +imphint.o: imphint.c + $(CC) -c $(CFLAGS) $< + +import.o: import.c + $(CC) -c $(CFLAGS) $< + +inifile.o: inifile.c + $(CC) -c $(CFLAGS) $< + +init.o: init.c + $(CC) -c $(CFLAGS) $< + +inline.o: inline.c + $(CC) -c $(CFLAGS) $< + +interpret.o: interpret.c + $(CC) -c $(CFLAGS) $< + +intrange.o: intrange.h intrange.c + $(CC) -c $(CFLAGS) intrange.c + +json.o: json.c + $(CC) -c $(CFLAGS) $< + +lexer.o: lexer.c + $(CC) -c $(CFLAGS) $< + +libelf.o: libelf.c $C/melf.h + $(CC) -c $(CFLAGS) -I$C $< + +libmach.o: libmach.c $C/mach.h + $(CC) -c $(CFLAGS) -I$C $< + +link.o: link.c + $(CC) -c $(CFLAGS) $< + +lstring.o: $(ROOT)/lstring.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +machobj.o: $C/machobj.c + $(CC) -c $(MFLAGS) -I. $< + +macro.o: macro.c + $(CC) -c $(CFLAGS) $< + +man.o: $(ROOT)/man.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +mangle.o: mangle.c + $(CC) -c $(CFLAGS) $< + +mars.o: mars.c + $(CC) -c $(CFLAGS) $< + +rmem.o: $(ROOT)/rmem.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +module.o: module.c $C/html.h + $(CC) -c $(CFLAGS) -I$C $< + +msc.o: msc.c $(CH) mars.h + $(CC) -c $(MFLAGS) $< + +mtype.o: mtype.c + $(CC) -c $(CFLAGS) $< + +nteh.o: $C/nteh.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +opover.o: opover.c + $(CC) -c $(CFLAGS) $< + +optimize.o: optimize.c + $(CC) -c $(CFLAGS) $< + +os.o: $C/os.c + $(CC) -c $(MFLAGS) $< + +out.o: $C/out.c + $(CC) -c $(MFLAGS) $< + +outbuf.o: $C/outbuf.c $C/outbuf.h + $(CC) -c $(MFLAGS) $< + +parse.o: parse.c + $(CC) -c $(CFLAGS) $< + +ph.o: ph.c + $(CC) -c $(MFLAGS) $< + +port.o: $(ROOT)/port.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +ptrntab.o: $C/ptrntab.c $C/iasm.h + $(CC) -c $(MFLAGS) $< + +response.o: $(ROOT)/response.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +root.o: $(ROOT)/root.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +rtlsym.o: $C/rtlsym.c $C/rtlsym.h + $(CC) -c $(MFLAGS) $< + +s2ir.o: s2ir.c $C/rtlsym.h statement.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +scope.o: scope.c + $(CC) -c $(CFLAGS) $< + +sideeffect.o: sideeffect.c + $(CC) -c $(CFLAGS) $< + +speller.o: $(ROOT)/speller.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +statement.o: statement.c + $(CC) -c $(CFLAGS) $< + +staticassert.o: staticassert.c staticassert.h + $(CC) -c $(CFLAGS) $< + +stringtable.o: $(ROOT)/stringtable.c + $(CC) -c $(GFLAGS) -I$(ROOT) $< + +strtold.o: $C/strtold.c + gcc -m$(MODEL) -c $< + +struct.o: struct.c + $(CC) -c $(CFLAGS) $< + +template.o: template.c + $(CC) -c $(CFLAGS) $< + +ti_achar.o: $C/ti_achar.c $C/tinfo.h + $(CC) -c $(MFLAGS) -I. $< + +ti_pvoid.o: $C/ti_pvoid.c $C/tinfo.h + $(CC) -c $(MFLAGS) -I. $< + +tk.o: tk.c + $(CC) -c $(MFLAGS) $< + +tocsym.o: tocsym.c $(CH) mars.h module.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +toctype.o: toctype.c $(CH) $C/rtlsym.h mars.h module.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +todt.o: todt.c mtype.h expression.h $C/dt.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +toelfdebug.o: toelfdebug.c $(CH) mars.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +toir.o: toir.c $C/rtlsym.h expression.h toir.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +toobj.o: toobj.c $(CH) mars.h module.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +traits.o: traits.c + $(CC) -c $(CFLAGS) $< + +type.o: $C/type.c + $(CC) -c $(MFLAGS) $< + +typinf.o: typinf.c $(CH) mars.h module.h mtype.h + $(CC) -c $(MFLAGS) -I$(ROOT) $< + +util.o: util.c + $(CC) -c $(MFLAGS) $< + +utf.o: utf.c utf.h + $(CC) -c $(CFLAGS) $< + +unialpha.o: unialpha.c + $(CC) -c $(CFLAGS) $< + +unittests.o: unittests.c + $(CC) -c $(CFLAGS) $< + +var.o: $C/var.c optab.c + $(CC) -c $(MFLAGS) -I. $< + +version.o: version.c + $(CC) -c $(CFLAGS) $< + +###################################################### + +gcov: + gcov access.c + gcov aliasthis.c + gcov apply.c + gcov arrayop.c + gcov attrib.c + gcov builtin.c + gcov canthrow.c + gcov cast.c + gcov class.c + gcov clone.c + gcov cond.c + gcov constfold.c + gcov declaration.c + gcov delegatize.c + gcov doc.c + gcov dsymbol.c + gcov dump.c + gcov e2ir.c + gcov eh.c + gcov entity.c + gcov enum.c + gcov expression.c + gcov func.c + gcov glue.c + gcov iasm.c + gcov identifier.c + gcov imphint.c + gcov import.c + gcov inifile.c + gcov init.c + gcov inline.c + gcov interpret.c + gcov irstate.c + gcov json.c + gcov lexer.c +ifeq (OSX,$(TARGET)) + gcov libmach.c +else + gcov libelf.c +endif + gcov link.c + gcov macro.c + gcov mangle.c + gcov mars.c + gcov module.c + gcov msc.c + gcov mtype.c + gcov opover.c + gcov optimize.c + gcov parse.c + gcov ph.c + gcov scope.c + gcov sideeffect.c + gcov statement.c + gcov staticassert.c + gcov s2ir.c + gcov struct.c + gcov template.c + gcov tk.c + gcov tocsym.c + gcov todt.c + gcov toobj.c + gcov toctype.c + gcov toelfdebug.c + gcov typinf.c + gcov unialpha.c + gcov utf.c + gcov util.c + gcov version.c + gcov intrange.c + +# gcov hdrgen.c +# gcov tocvdebug.c + +###################################################### + +zip: + -rm -f dmdsrc.zip + zip dmdsrc $(SRC) diff --git a/readme.txt b/readme.txt new file mode 100644 index 00000000..e8109070 --- /dev/null +++ b/readme.txt @@ -0,0 +1,24 @@ + + The D Programming Language + Compiler Front End Source + Copyright (c) 1999-2009, by Digital Mars + http://www.digitalmars.com + All Rights Reserved + + +This is the source code to the front end Digital Mars D compiler. +It covers the lexical analysis, parsing, and semantic analysis +of the D Programming Language defined in the documents at +http://www.digitalmars.com/d/ + +These sources are free, they are redistributable and modifiable +under the terms of the GNU General Public License (attached as gpl.txt), +or the Artistic License (attached as artistic.txt). + +The optimizer and code generator sources are +covered under a separate license, backendlicense.txt. + +It does not apply to anything else distributed by Digital Mars, +including D compiler executables. + +-Walter Bright diff --git a/root/aav.c b/root/aav.c new file mode 100644 index 00000000..ca685d42 --- /dev/null +++ b/root/aav.c @@ -0,0 +1,188 @@ +/** + * Implementation of associative arrays. + * + */ + +#include +#include +#include + +#include "aav.h" + +static const size_t prime_list[] = { + 31UL, + 97UL, 389UL, + 1543UL, 6151UL, + 24593UL, 98317UL, + 393241UL, 1572869UL, + 6291469UL, 25165843UL, + 100663319UL, 402653189UL, + 1610612741UL, 4294967291UL, +}; + +struct aaA +{ + aaA *next; + Key key; + Value value; +}; + +struct AA +{ + aaA* *b; + size_t b_length; + size_t nodes; // total number of aaA nodes + aaA* binit[4]; // initial value of b[] +}; + +static const AA bbinit = { NULL, }; + +/**************************************************** + * Determine number of entries in associative array. + */ + +size_t _aaLen(AA* aa) +{ + return aa ? aa->nodes : 0; +} + + +/************************************************* + * Get pointer to value in associative array indexed by key. + * Add entry for key if it is not already there. + */ + +Value* _aaGet(AA** paa, Key key) +{ + //printf("paa = %p\n", paa); + + if (!*paa) + { AA *a = new AA(); + *a = bbinit; + a->b = a->binit; + a->b_length = sizeof(a->binit) / sizeof(a->binit[0]); + *paa = a; + assert((*paa)->b_length == 4); + } + //printf("paa = %p, *paa = %p\n", paa, *paa); + + assert((*paa)->b_length); + size_t i = (size_t)key % (*paa)->b_length; + aaA** pe = &(*paa)->b[i]; + aaA *e; + while ((e = *pe) != NULL) + { + if (key == e->key) + return &e->value; + pe = &e->next; + } + + // Not found, create new elem + //printf("create new one\n"); + e = new aaA(); + e->next = NULL; + e->key = key; + e->value = NULL; + *pe = e; + + size_t nodes = ++(*paa)->nodes; + //printf("length = %d, nodes = %d\n", paa.a.b.length, nodes); + if (nodes > (*paa)->b_length * 4) + { + //printf("rehash\n"); + _aaRehash(paa); + } + + return &e->value; +} + + +/************************************************* + * Get value in associative array indexed by key. + * Returns NULL if it is not already there. + */ + +Value _aaGetRvalue(AA* aa, Key key) +{ + //printf("_aaGetRvalue(key = %p)\n", key); + if (!aa) + return NULL; + + size_t len = aa->b_length; + + if (len) + { + size_t i = (size_t)key % len; + aaA* e = aa->b[i]; + while (e) + { + if (key == e->key) + return e->value; + e = e->next; + } + } + return NULL; // not found +} + + +/******************************************** + * Rehash an array. + */ + +void _aaRehash(AA** paa) +{ + //printf("Rehash\n"); + if (*paa) + { + AA newb = bbinit; + AA *aa = *paa; + size_t len = _aaLen(*paa); + if (len) + { size_t i; + + for (i = 0; i < sizeof(prime_list)/sizeof(prime_list[0]) - 1; i++) + { + if (len <= prime_list[i]) + break; + } + len = prime_list[i]; + newb.b = new aaA*[len]; + memset(newb.b, 0, len * sizeof(aaA*)); + newb.b_length = len; + + for (size_t k = 0; k < aa->b_length; k++) + { aaA *e = aa->b[k]; + while (e) + { aaA* enext = e->next; + size_t j = (size_t)e->key % len; + e->next = newb.b[j]; + newb.b[j] = e; + e = enext; + } + } + if (aa->b != aa->binit) + delete[] aa->b; + + newb.nodes = aa->nodes; + } + + **paa = newb; + } +} + + +#if UNITTEST + +void unittest_aa() +{ + AA* aa = NULL; + Value v = _aaGetRvalue(aa, NULL); + assert(!v); + Value *pv = _aaGet(&aa, NULL); + assert(pv); + *pv = (void *)3; + v = _aaGetRvalue(aa, NULL); + assert(v == (void *)3); +} + +#endif diff --git a/root/aav.h b/root/aav.h new file mode 100644 index 00000000..266b5a83 --- /dev/null +++ b/root/aav.h @@ -0,0 +1,11 @@ + +typedef void* Value; +typedef void* Key; + +struct AA; + +size_t _aaLen(AA* aa); +Value* _aaGet(AA** aa, Key key); +Value _aaGetRvalue(AA* aa, Key key); +void _aaRehash(AA** paa); + diff --git a/root/array.c b/root/array.c new file mode 100644 index 00000000..f3440445 --- /dev/null +++ b/root/array.c @@ -0,0 +1,257 @@ + +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include + +#if (defined (__SVR4) && defined (__sun)) +#include +#endif + +#if _MSC_VER || __MINGW32__ +#include +#endif + +#if IN_GCC +#include "gdc_alloca.h" +#endif + +#if _WIN32 +#include +#endif + +#ifndef _WIN32 +#include +#include +#include +#include +#include +#include +#endif + +#include "port.h" +#include "root.h" +#include "dchar.h" +#include "rmem.h" + + +/********************************* Array ****************************/ + +Array::Array() +{ + data = SMALLARRAYCAP ? &smallarray[0] : NULL; + dim = 0; + allocdim = SMALLARRAYCAP; +} + +Array::~Array() +{ + if (data != &smallarray[0]) + mem.free(data); +} + +void Array::mark() +{ unsigned u; + + mem.mark(data); + for (u = 0; u < dim; u++) + mem.mark(data[u]); // BUG: what if arrays of Object's? +} + +void Array::reserve(unsigned nentries) +{ + //printf("Array::reserve: dim = %d, allocdim = %d, nentries = %d\n", dim, allocdim, nentries); + if (allocdim - dim < nentries) + { + if (allocdim == 0) + { // Not properly initialized, someone memset it to zero + if (nentries <= SMALLARRAYCAP) + { allocdim = SMALLARRAYCAP; + data = SMALLARRAYCAP ? &smallarray[0] : NULL; + } + else + { allocdim = nentries; + data = (void **)mem.malloc(allocdim * sizeof(*data)); + } + } + else if (allocdim == SMALLARRAYCAP) + { + allocdim = dim + nentries; + data = (void **)mem.malloc(allocdim * sizeof(*data)); + memcpy(data, &smallarray[0], dim * sizeof(*data)); + } + else + { allocdim = dim + nentries; + data = (void **)mem.realloc(data, allocdim * sizeof(*data)); + } + } +} + +void Array::setDim(unsigned newdim) +{ + if (dim < newdim) + { + reserve(newdim - dim); + } + dim = newdim; +} + +void Array::fixDim() +{ + if (dim != allocdim) + { + if (allocdim >= SMALLARRAYCAP) + { + if (dim <= SMALLARRAYCAP) + { + memcpy(&smallarray[0], data, dim * sizeof(*data)); + mem.free(data); + } + else + data = (void **)mem.realloc(data, dim * sizeof(*data)); + } + allocdim = dim; + } +} + +void Array::push(void *ptr) +{ + reserve(1); + data[dim++] = ptr; +} + +void *Array::pop() +{ + return data[--dim]; +} + +void Array::shift(void *ptr) +{ + reserve(1); + memmove(data + 1, data, dim * sizeof(*data)); + data[0] = ptr; + dim++; +} + +void Array::insert(unsigned index, void *ptr) +{ + reserve(1); + memmove(data + index + 1, data + index, (dim - index) * sizeof(*data)); + data[index] = ptr; + dim++; +} + + +void Array::insert(unsigned index, Array *a) +{ + if (a) + { unsigned d; + + d = a->dim; + reserve(d); + if (dim != index) + memmove(data + index + d, data + index, (dim - index) * sizeof(*data)); + memcpy(data + index, a->data, d * sizeof(*data)); + dim += d; + } +} + + +/*********************************** + * Append array a to this array. + */ + +void Array::append(Array *a) +{ + insert(dim, a); +} + +void Array::remove(unsigned i) +{ + if (dim - i - 1) + memmove(data + i, data + i + 1, (dim - i - 1) * sizeof(data[0])); + dim--; +} + +char *Array::toChars() +{ + unsigned len; + unsigned u; + char **buf; + char *str; + char *p; + + buf = (char **)malloc(dim * sizeof(char *)); + assert(buf); + len = 2; + for (u = 0; u < dim; u++) + { + buf[u] = ((Object *)data[u])->toChars(); + len += strlen(buf[u]) + 1; + } + str = (char *)mem.malloc(len); + + str[0] = '['; + p = str + 1; + for (u = 0; u < dim; u++) + { + if (u) + *p++ = ','; + len = strlen(buf[u]); + memcpy(p,buf[u],len); + p += len; + } + *p++ = ']'; + *p = 0; + free(buf); + return str; +} + +void Array::zero() +{ + memset(data,0,dim * sizeof(data[0])); +} + +void *Array::tos() +{ + return dim ? data[dim - 1] : NULL; +} + +int +#if _WIN32 + __cdecl +#endif + Array_sort_compare(const void *x, const void *y) +{ + Object *ox = *(Object **)x; + Object *oy = *(Object **)y; + + return ox->compare(oy); +} + +void Array::sort() +{ + if (dim) + { + qsort(data, dim, sizeof(Object *), Array_sort_compare); + } +} + +Array *Array::copy() +{ + Array *a = new Array(); + + a->setDim(dim); + memcpy(a->data, data, dim * sizeof(void *)); + return a; +} + diff --git a/root/async.c b/root/async.c new file mode 100644 index 00000000..78f17c68 --- /dev/null +++ b/root/async.c @@ -0,0 +1,325 @@ + +#define _MT 1 + +#include +#include +#include + +#if _WIN32 + +#include +#include +#include + +#include "root.h" + +static unsigned __stdcall startthread(void *p); + +struct FileData +{ + File *file; + int result; + HANDLE event; +}; + +struct AsyncRead +{ + static AsyncRead *create(size_t nfiles); + void addFile(File *file); + void start(); + int read(size_t i); + static void dispose(AsyncRead *); + + HANDLE hThread; + + size_t filesdim; + size_t filesmax; + FileData files[1]; +}; + + +AsyncRead *AsyncRead::create(size_t nfiles) +{ + AsyncRead *aw = (AsyncRead *)calloc(1, sizeof(AsyncRead) + + (nfiles - 1) * sizeof(FileData)); + aw->filesmax = nfiles; + return aw; +} + +void AsyncRead::addFile(File *file) +{ + //printf("addFile(file = %p)\n", file); + //printf("filesdim = %d, filesmax = %d\n", filesdim, filesmax); + assert(filesdim < filesmax); + files[filesdim].file = file; + files[filesdim].event = CreateEvent(NULL, TRUE, FALSE, NULL); + ResetEvent(files[filesdim].event); + filesdim++; +} + +void AsyncRead::start() +{ + //printf("aw->filesdim = %p %d\n", this, filesdim); + if (filesdim) + { + unsigned threadaddr; + hThread = (HANDLE) _beginthreadex(NULL, + 0, + &startthread, + this, + 0, + (unsigned *)&threadaddr); + + if (hThread) + { + SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST); + } + else + { + assert(0); + } + } +} + +int AsyncRead::read(size_t i) +{ + FileData *f = &files[i]; + WaitForSingleObject(f->event, INFINITE); + Sleep(0); // give up time slice + return f->result; +} + +void AsyncRead::dispose(AsyncRead *aw) +{ + free(aw); +} + + + +unsigned __stdcall startthread(void *p) +{ + AsyncRead *aw = (AsyncRead *)p; + + //printf("aw->filesdim = %p %d\n", aw, aw->filesdim); + for (size_t i = 0; i < aw->filesdim; i++) + { FileData *f = &aw->files[i]; + + f->result = f->file->read(); + SetEvent(f->event); + } + _endthreadex(EXIT_SUCCESS); + return EXIT_SUCCESS; // if skidding +} + +#elif linux // Posix + +#include +#include +#include + +#include "root.h" + +void *startthread(void *arg); + +void err_abort(int status, const char *msg) +{ + fprintf(stderr, "fatal error = %d, %s\n", status, msg); + exit(EXIT_FAILURE); +} + +struct FileData +{ + File *file; + int result; + + pthread_mutex_t mutex; + pthread_cond_t cond; + int value; +}; + +struct AsyncRead +{ + static AsyncRead *create(size_t nfiles); + void addFile(File *file); + void start(); + int read(size_t i); + static void dispose(AsyncRead *); + + size_t filesdim; + size_t filesmax; + FileData files[1]; +}; + + +AsyncRead *AsyncRead::create(size_t nfiles) +{ + AsyncRead *aw = (AsyncRead *)calloc(1, sizeof(AsyncRead) + + (nfiles - 1) * sizeof(FileData)); + aw->filesmax = nfiles; + return aw; +} + +void AsyncRead::addFile(File *file) +{ + //printf("addFile(file = %p)\n", file); + //printf("filesdim = %d, filesmax = %d\n", filesdim, filesmax); + assert(filesdim < filesmax); + FileData *f = &files[filesdim]; + f->file = file; + + int status = pthread_mutex_init(&f->mutex, NULL); + if (status != 0) + err_abort(status, "init mutex"); + status = pthread_cond_init(&f->cond, NULL); + if (status != 0) + err_abort(status, "init cond"); + + filesdim++; +} + +void AsyncRead::start() +{ + //printf("aw->filesdim = %p %d\n", this, filesdim); + if (filesdim) + { + pthread_t thread_id; + int status = pthread_create(&thread_id, + NULL, + &startthread, + this); + if (status != 0) + err_abort(status, "create thread"); + } +} + +int AsyncRead::read(size_t i) +{ + FileData *f = &files[i]; + + // Wait for the event + int status = pthread_mutex_lock(&f->mutex); + if (status != 0) + err_abort(status, "lock mutex"); + while (f->value == 0) + { + status = pthread_cond_wait(&f->cond, &f->mutex); + if (status != 0) + err_abort(status, "wait on condition"); + } + status = pthread_mutex_unlock(&f->mutex); + if (status != 0) + err_abort(status, "unlock mutex"); + + return f->result; +} + +void AsyncRead::dispose(AsyncRead *aw) +{ + //printf("AsyncRead::dispose()\n"); + for (int i = 0; i < aw->filesdim; i++) + { + FileData *f = &aw->files[i]; + int status = pthread_cond_destroy(&f->cond); + if (status != 0) + err_abort(status, "cond destroy"); + status = pthread_mutex_destroy(&f->mutex); + if (status != 0) + err_abort(status, "mutex destroy"); + } + free(aw); +} + + +void *startthread(void *p) +{ + AsyncRead *aw = (AsyncRead *)p; + + //printf("startthread: aw->filesdim = %p %d\n", aw, aw->filesdim); + size_t dim = aw->filesdim; + for (size_t i = 0; i < dim; i++) + { FileData *f = &aw->files[i]; + + f->result = f->file->read(); + + // Set event + int status = pthread_mutex_lock(&f->mutex); + if (status != 0) + err_abort(status, "lock mutex"); + f->value = 1; + status = pthread_cond_signal(&f->cond); + if (status != 0) + err_abort(status, "signal condition"); + status = pthread_mutex_unlock(&f->mutex); + if (status != 0) + err_abort(status, "unlock mutex"); + } + + return NULL; // end thread +} + +#else + +#include +#include + +#include "root.h" + +struct FileData +{ + File *file; + int result; + //HANDLE event; +}; + +struct AsyncRead +{ + static AsyncRead *create(size_t nfiles); + void addFile(File *file); + void start(); + int read(size_t i); + static void dispose(AsyncRead *); + + //HANDLE hThread; + + size_t filesdim; + size_t filesmax; + FileData files[1]; +}; + + +AsyncRead *AsyncRead::create(size_t nfiles) +{ + AsyncRead *aw = (AsyncRead *)calloc(1, sizeof(AsyncRead) + + (nfiles - 1) * sizeof(FileData)); + aw->filesmax = nfiles; + return aw; +} + +void AsyncRead::addFile(File *file) +{ + //printf("addFile(file = %p)\n", file); + //printf("filesdim = %d, filesmax = %d\n", filesdim, filesmax); + assert(filesdim < filesmax); + files[filesdim].file = file; + //files[filesdim].event = CreateEvent(NULL, TRUE, FALSE, NULL); + //ResetEvent(files[filesdim].event); + filesdim++; +} + +void AsyncRead::start() +{ +} + +int AsyncRead::read(size_t i) +{ + FileData *f = &files[i]; + f->result = f->file->read(); + return f->result; +} + +void AsyncRead::dispose(AsyncRead *aw) +{ + free(aw); +} + +#endif diff --git a/root/async.h b/root/async.h new file mode 100644 index 00000000..6f25f367 --- /dev/null +++ b/root/async.h @@ -0,0 +1,33 @@ + +// Copyright (c) 2009-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef ASYNC_H +#define ASYNC_H + +#if __DMC__ +#pragma once +#endif + + +/******************* + * Simple interface to read files asynchronously in another + * thread. + */ + +struct AsyncRead +{ + static AsyncRead *create(size_t nfiles); + void addFile(File *file); + void start(); + int read(size_t i); + static void dispose(AsyncRead *); +}; + + +#endif diff --git a/root/dchar.c b/root/dchar.c new file mode 100644 index 00000000..0b11a8a4 --- /dev/null +++ b/root/dchar.c @@ -0,0 +1,482 @@ + +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include +#include + +#include "dchar.h" +#include "rmem.h" + +#if M_UNICODE + +// Converts a char string to Unicode + +dchar *Dchar::dup(char *p) +{ + dchar *s; + size_t len; + + if (!p) + return NULL; + len = strlen(p); + s = (dchar *)mem.malloc((len + 1) * sizeof(dchar)); + for (unsigned i = 0; i < len; i++) + { + s[i] = (dchar)(p[i] & 0xFF); + } + s[len] = 0; + return s; +} + +dchar *Dchar::memchr(dchar *p, int c, int count) +{ + int u; + + for (u = 0; u < count; u++) + { + if (p[u] == c) + return p + u; + } + return NULL; +} + +#if _WIN32 && __DMC__ +__declspec(naked) +unsigned Dchar::calcHash(const dchar *str, unsigned len) +{ + __asm + { + mov ECX,4[ESP] + mov EDX,8[ESP] + xor EAX,EAX + test EDX,EDX + je L92 + +LC8: cmp EDX,1 + je L98 + cmp EDX,2 + je LAE + + add EAX,[ECX] +// imul EAX,EAX,025h + lea EAX,[EAX][EAX*8] + add ECX,4 + sub EDX,2 + jmp LC8 + +L98: mov DX,[ECX] + and EDX,0FFFFh + add EAX,EDX + ret + +LAE: add EAX,[ECX] +L92: ret + } +} +#else +hash_t Dchar::calcHash(const dchar *str, size_t len) +{ + unsigned hash = 0; + + for (;;) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash += *(const uint16_t *)str; + return hash; + + case 2: + hash += *(const uint32_t *)str; + return hash; + + default: + hash += *(const uint32_t *)str; + hash *= 37; + str += 2; + len -= 2; + break; + } + } +} +#endif + +hash_t Dchar::icalcHash(const dchar *str, size_t len) +{ + hash_t hash = 0; + + for (;;) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash += *(const uint16_t *)str | 0x20; + return hash; + + case 2: + hash += *(const uint32_t *)str | 0x200020; + return hash; + + default: + hash += *(const uint32_t *)str | 0x200020; + hash *= 37; + str += 2; + len -= 2; + break; + } + } +} + +#elif MCBS + +hash_t Dchar::calcHash(const dchar *str, size_t len) +{ + hash_t hash = 0; + + while (1) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(const uint8_t *)str; + return hash; + + case 2: + hash *= 37; + hash += *(const uint16_t *)str; + return hash; + + case 3: + hash *= 37; + hash += (*(const uint16_t *)str << 8) + + ((const uint8_t *)str)[2]; + return hash; + + default: + hash *= 37; + hash += *(const uint32_t *)str; + str += 4; + len -= 4; + break; + } + } +} + +#elif UTF8 + +// Specification is: http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335 + +char Dchar::mblen[256] = +{ + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1, +}; + +dchar *Dchar::dec(dchar *pstart, dchar *p) +{ + while ((p[-1] & 0xC0) == 0x80) + p--; + return p; +} + +int Dchar::get(dchar *p) +{ + unsigned c; + unsigned char *q = (unsigned char *)p; + + c = q[0]; + switch (mblen[c]) + { + case 2: + c = ((c - 0xC0) << 6) | + (q[1] - 0x80); + break; + + case 3: + c = ((c - 0xE0) << 12) | + ((q[1] - 0x80) << 6) | + (q[2] - 0x80); + break; + + case 4: + c = ((c - 0xF0) << 18) | + ((q[1] - 0x80) << 12) | + ((q[2] - 0x80) << 6) | + (q[3] - 0x80); + break; + + case 5: + c = ((c - 0xF8) << 24) | + ((q[1] - 0x80) << 18) | + ((q[2] - 0x80) << 12) | + ((q[3] - 0x80) << 6) | + (q[4] - 0x80); + break; + + case 6: + c = ((c - 0xFC) << 30) | + ((q[1] - 0x80) << 24) | + ((q[2] - 0x80) << 18) | + ((q[3] - 0x80) << 12) | + ((q[4] - 0x80) << 6) | + (q[5] - 0x80); + break; + } + return c; +} + +dchar *Dchar::put(dchar *p, unsigned c) +{ + if (c <= 0x7F) + { + *p++ = c; + } + else if (c <= 0x7FF) + { + p[0] = 0xC0 + (c >> 6); + p[1] = 0x80 + (c & 0x3F); + p += 2; + } + else if (c <= 0xFFFF) + { + p[0] = 0xE0 + (c >> 12); + p[1] = 0x80 + ((c >> 6) & 0x3F); + p[2] = 0x80 + (c & 0x3F); + p += 3; + } + else if (c <= 0x1FFFFF) + { + p[0] = 0xF0 + (c >> 18); + p[1] = 0x80 + ((c >> 12) & 0x3F); + p[2] = 0x80 + ((c >> 6) & 0x3F); + p[3] = 0x80 + (c & 0x3F); + p += 4; + } + else if (c <= 0x3FFFFFF) + { + p[0] = 0xF8 + (c >> 24); + p[1] = 0x80 + ((c >> 18) & 0x3F); + p[2] = 0x80 + ((c >> 12) & 0x3F); + p[3] = 0x80 + ((c >> 6) & 0x3F); + p[4] = 0x80 + (c & 0x3F); + p += 5; + } + else if (c <= 0x7FFFFFFF) + { + p[0] = 0xFC + (c >> 30); + p[1] = 0x80 + ((c >> 24) & 0x3F); + p[2] = 0x80 + ((c >> 18) & 0x3F); + p[3] = 0x80 + ((c >> 12) & 0x3F); + p[4] = 0x80 + ((c >> 6) & 0x3F); + p[5] = 0x80 + (c & 0x3F); + p += 6; + } + else + assert(0); // not a UCS-4 character + return p; +} + +hash_t Dchar::calcHash(const dchar *str, size_t len) +{ + hash_t hash = 0; + + while (1) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(const uint8_t *)str; + return hash; + + case 2: + hash *= 37; +#if LITTLE_ENDIAN + hash += *(const uint16_t *)str; +#else + hash += str[0] * 256 + str[1]; +#endif + return hash; + + case 3: + hash *= 37; +#if LITTLE_ENDIAN + hash += (*(const uint16_t *)str << 8) + + ((const uint8_t *)str)[2]; +#else + hash += (str[0] * 256 + str[1]) * 256 + str[2]; +#endif + return hash; + + default: + hash *= 37; +#if LITTLE_ENDIAN + hash += *(const uint32_t *)str; +#else + hash += ((str[0] * 256 + str[1]) * 256 + str[2]) * 256 + str[3]; +#endif + + str += 4; + len -= 4; + break; + } + } +} + +#else // ascii + +hash_t Dchar::calcHash(const dchar *str, size_t len) +{ + hash_t hash = 0; + + while (1) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(const uint8_t *)str; + return hash; + + case 2: + hash *= 37; +#if LITTLE_ENDIAN + hash += *(const uint16_t *)str; +#else + hash += str[0] * 256 + str[1]; +#endif + return hash; + + case 3: + hash *= 37; +#if LITTLE_ENDIAN + hash += (*(const uint16_t *)str << 8) + + ((const uint8_t *)str)[2]; +#else + hash += (str[0] * 256 + str[1]) * 256 + str[2]; +#endif + return hash; + + default: + hash *= 37; +#if LITTLE_ENDIAN + hash += *(const uint32_t *)str; +#else + hash += ((str[0] * 256 + str[1]) * 256 + str[2]) * 256 + str[3]; +#endif + str += 4; + len -= 4; + break; + } + } +} + +hash_t Dchar::icalcHash(const dchar *str, size_t len) +{ + hash_t hash = 0; + + while (1) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(const uint8_t *)str | 0x20; + return hash; + + case 2: + hash *= 37; + hash += *(const uint16_t *)str | 0x2020; + return hash; + + case 3: + hash *= 37; + hash += ((*(const uint16_t *)str << 8) + + ((const uint8_t *)str)[2]) | 0x202020; + return hash; + + default: + hash *= 37; + hash += *(const uint32_t *)str | 0x20202020; + str += 4; + len -= 4; + break; + } + } +} + +#endif + +#if 0 +#include + +void main() +{ + // Print out values to hardcode into Dchar::mblen[] + int c; + int s; + + for (c = 0; c < 256; c++) + { + s = 1; + if (c >= 0xC0 && c <= 0xDF) + s = 2; + if (c >= 0xE0 && c <= 0xEF) + s = 3; + if (c >= 0xF0 && c <= 0xF7) + s = 4; + if (c >= 0xF8 && c <= 0xFB) + s = 5; + if (c >= 0xFC && c <= 0xFD) + s = 6; + + printf("%d", s); + if ((c & 15) == 15) + printf(",\n"); + else + printf(","); + } +} +#endif diff --git a/root/dchar.h b/root/dchar.h new file mode 100644 index 00000000..2b8df523 --- /dev/null +++ b/root/dchar.h @@ -0,0 +1,194 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#ifndef DCHAR_H +#define DCHAR_H + +#if __GNUC__ && !_WIN32 +#include "gnuc.h" +#endif + +#if _MSC_VER + // Disable useless warnings about unreferenced functions + #pragma warning (disable : 4514) +#endif + +//#include "root.h" +typedef size_t hash_t; + +#undef TEXT + +// NOTE: All functions accepting pointer arguments must not be NULL + +#if M_UNICODE + +#include +#include + +typedef wchar_t dchar; +#define TEXT(x) L##x + +#define Dchar_mbmax 1 + +struct Dchar +{ + static dchar *inc(dchar *p) { return p + 1; } + static dchar *dec(dchar *pstart, dchar *p) { (void)pstart; return p - 1; } + static int len(const dchar *p) { return wcslen(p); } + static dchar get(dchar *p) { return *p; } + static dchar getprev(dchar *pstart, dchar *p) { (void)pstart; return p[-1]; } + static dchar *put(dchar *p, dchar c) { *p = c; return p + 1; } + static int cmp(dchar *s1, dchar *s2) + { +#if __DMC__ + if (!*s1 && !*s2) // wcscmp is broken + return 0; +#endif + return wcscmp(s1, s2); +#if 0 + return (*s1 == *s2) + ? wcscmp(s1, s2) + : ((int)*s1 - (int)*s2); +#endif + } + static int memcmp(const dchar *s1, const dchar *s2, int nchars) { return ::memcmp(s1, s2, nchars * sizeof(dchar)); } + static int isDigit(dchar c) { return '0' <= c && c <= '9'; } + static int isAlpha(dchar c) { return iswalpha(c); } + static int isUpper(dchar c) { return iswupper(c); } + static int isLower(dchar c) { return iswlower(c); } + static int isLocaleUpper(dchar c) { return isUpper(c); } + static int isLocaleLower(dchar c) { return isLower(c); } + static int toLower(dchar c) { return isUpper(c) ? towlower(c) : c; } + static int toLower(dchar *p) { return toLower(*p); } + static int toUpper(dchar c) { return isLower(c) ? towupper(c) : c; } + static dchar *dup(dchar *p) { return ::_wcsdup(p); } // BUG: out of memory? + static dchar *dup(char *p); + static dchar *chr(dchar *p, unsigned c) { return wcschr(p, (dchar)c); } + static dchar *rchr(dchar *p, unsigned c) { return wcsrchr(p, (dchar)c); } + static dchar *memchr(dchar *p, int c, int count); + static dchar *cpy(dchar *s1, dchar *s2) { return wcscpy(s1, s2); } + static dchar *str(dchar *s1, dchar *s2) { return wcsstr(s1, s2); } + static hash_t calcHash(const dchar *str, size_t len); + + // Case insensitive versions + static int icmp(dchar *s1, dchar *s2) { return wcsicmp(s1, s2); } + static int memicmp(const dchar *s1, const dchar *s2, int nchars) { return ::wcsnicmp(s1, s2, nchars); } + static hash_t icalcHash(const dchar *str, size_t len); +}; + +#elif MCBS + +#include +#include + +typedef char dchar; +#define TEXT(x) x + +#define Dchar_mbmax MB_LEN_MAX + +#elif UTF8 + +typedef char dchar; +#define TEXT(x) x + +#define Dchar_mbmax 6 + +struct Dchar +{ + static char mblen[256]; + + static dchar *inc(dchar *p) { return p + mblen[*p & 0xFF]; } + static dchar *dec(dchar *pstart, dchar *p); + static int len(const dchar *p) { return strlen(p); } + static int get(dchar *p); + static int getprev(dchar *pstart, dchar *p) + { return *dec(pstart, p) & 0xFF; } + static dchar *put(dchar *p, unsigned c); + static int cmp(dchar *s1, dchar *s2) { return strcmp(s1, s2); } + static int memcmp(const dchar *s1, const dchar *s2, int nchars) { return ::memcmp(s1, s2, nchars); } + static int isDigit(dchar c) { return '0' <= c && c <= '9'; } + static int isAlpha(dchar c) { return c <= 0x7F ? isalpha(c) : 0; } + static int isUpper(dchar c) { return c <= 0x7F ? isupper(c) : 0; } + static int isLower(dchar c) { return c <= 0x7F ? islower(c) : 0; } + static int isLocaleUpper(dchar c) { return isUpper(c); } + static int isLocaleLower(dchar c) { return isLower(c); } + static int toLower(dchar c) { return isUpper(c) ? tolower(c) : c; } + static int toLower(dchar *p) { return toLower(*p); } + static int toUpper(dchar c) { return isLower(c) ? toupper(c) : c; } + static dchar *dup(dchar *p) { return ::strdup(p); } // BUG: out of memory? + static dchar *chr(dchar *p, int c) { return strchr(p, c); } + static dchar *rchr(dchar *p, int c) { return strrchr(p, c); } + static dchar *memchr(dchar *p, int c, int count) + { return (dchar *)::memchr(p, c, count); } + static dchar *cpy(dchar *s1, dchar *s2) { return strcpy(s1, s2); } + static dchar *str(dchar *s1, dchar *s2) { return strstr(s1, s2); } + static hash_t calcHash(const dchar *str, size_t len); + + // Case insensitive versions + static int icmp(dchar *s1, dchar *s2) { return _mbsicmp(s1, s2); } + static int memicmp(const dchar *s1, const dchar *s2, int nchars) { return ::_mbsnicmp(s1, s2, nchars); } +}; + +#else + +#include + +#ifndef GCC_SAFE_DMD +#include +#endif + +typedef char dchar; +#define TEXT(x) x + +#define Dchar_mbmax 1 + +struct Dchar +{ + static dchar *inc(dchar *p) { return p + 1; } + static dchar *dec(dchar *pstart, dchar *p) { return p - 1; } + static int len(const dchar *p) { return strlen(p); } + static int get(dchar *p) { return *p & 0xFF; } + static int getprev(dchar *pstart, dchar *p) { return p[-1] & 0xFF; } + static dchar *put(dchar *p, unsigned c) { *p = c; return p + 1; } + static int cmp(dchar *s1, dchar *s2) { return strcmp(s1, s2); } + static int memcmp(const dchar *s1, const dchar *s2, int nchars) { return ::memcmp(s1, s2, nchars); } + static int isDigit(dchar c) { return '0' <= c && c <= '9'; } +#ifndef GCC_SAFE_DMD + static int isAlpha(dchar c) { return isalpha((unsigned char)c); } + static int isUpper(dchar c) { return isupper((unsigned char)c); } + static int isLower(dchar c) { return islower((unsigned char)c); } + static int isLocaleUpper(dchar c) { return isupper((unsigned char)c); } + static int isLocaleLower(dchar c) { return islower((unsigned char)c); } + static int toLower(dchar c) { return isupper((unsigned char)c) ? tolower(c) : c; } + static int toLower(dchar *p) { return toLower(*p); } + static int toUpper(dchar c) { return islower((unsigned char)c) ? toupper(c) : c; } + static dchar *dup(dchar *p) { return ::strdup(p); } // BUG: out of memory? +#endif + static dchar *chr(dchar *p, int c) { return strchr(p, c); } + static dchar *rchr(dchar *p, int c) { return strrchr(p, c); } + static dchar *memchr(dchar *p, int c, int count) + { return (dchar *)::memchr(p, c, count); } + static dchar *cpy(dchar *s1, dchar *s2) { return strcpy(s1, s2); } + static dchar *str(dchar *s1, dchar *s2) { return strstr(s1, s2); } + static hash_t calcHash(const dchar *str, size_t len); + + // Case insensitive versions +#ifdef __GNUC__ + static int icmp(dchar *s1, dchar *s2) { return strcasecmp(s1, s2); } +#else + static int icmp(dchar *s1, dchar *s2) { return stricmp(s1, s2); } +#endif + static int memicmp(const dchar *s1, const dchar *s2, int nchars) { return ::memicmp(s1, s2, nchars); } + static hash_t icalcHash(const dchar *str, size_t len); +}; + +#endif +#endif + diff --git a/root/dmgcmem.c b/root/dmgcmem.c new file mode 100644 index 00000000..9a283890 --- /dev/null +++ b/root/dmgcmem.c @@ -0,0 +1,499 @@ + + +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ +#include +#include +#endif + +#include "rmem.h" +#include "gc/gc.h" +//#include "printf.h" + +/* This implementation of the storage allocator uses the Digital Mars gc. + */ + +Mem mem; + +//static int nuncollectable; + +extern "C" +{ + void gc_init(); + GC *gc_get(); +} + +void Mem::init() +{ + gc_init(); +} + +char *Mem::strdup(const char *s) +{ + return gc_get()->strdup(s); +} + +void *Mem::malloc(size_t size) +{ + if (gc) // if cached allocator + { +// PRINTF("Using cached gc for size %d, file = '%s', line = %d\n", size, GC::file, GC::line); +// GC::file = NULL; +// GC::line = 0; + return ((GC *)gc)->malloc(size); + } + if (this == &mem) // don't cache global mem + { +// PRINTF("Using global gc for size %d, file = '%s', line = %d\n", size, GC::file, GC::line); +// GC::file = NULL; +// GC::line = 0; + return gc_get()->malloc(size); + } +// PRINTF("Generating cached gc for size %d, file = '%s', line = %d\n", size, GC::file, GC::line); + gc = gc_get(); + return gc->malloc(size); +} + +void *Mem::malloc_uncollectable(size_t size) +{ void *p; + + p = ::malloc(size); + if (!p) + error(); + addroots((char *)p, (char *)p + size); + +#if 0 + ++nuncollectable; + WPRINTF(L"malloc_uncollectable(%u) = %x, n=%d\n", size, p, nuncollectable); +#endif + + return p; +} + +void *Mem::calloc(size_t size, size_t n) +{ + return gc_get()->calloc(size, n); +} + +void *Mem::realloc(void *p, size_t size) +{ + return gc_get()->realloc(p, size); +} + +void Mem::free(void *p) +{ + gc_get()->free(p); +} + +void Mem::free_uncollectable(void *p) +{ + if (p) + { removeroots((char *)p); + ::free(p); + +#if 0 + --nuncollectable; + WPRINTF(L"free_uncollectable(%x) n=%d\n", p, nuncollectable); +#endif + +#if 0 + gc_get()->fullcollect(); + + GCStats stats; + + getStats(&stats); + WPRINTF(L"poolsize = %x, usedsize = %x, freelistsize = %x\n", + stats.poolsize, stats.usedsize, stats.freelistsize); +#endif + } +} + +void *Mem::mallocdup(void *o, size_t size) +{ + return gc_get()->mallocdup(o, size); +} + +void Mem::check(void *p) +{ + if (gc) + gc->check(p); + else + gc_get()->check(p); +} + +void Mem::error() +{ +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ + assert(0); +#endif + printf("Error: out of memory\n"); + exit(EXIT_FAILURE); +} + +void Mem::fullcollect() +{ + gc_get()->fullcollect(); + +#if 0 + { + GCStats stats; + + gc_get()->getStats(&stats); + WPRINTF(L"Thread %x ", Thread::getId()); + WPRINTF(L"poolsize=x%x, usedsize=x%x, freelistsize=x%x, freeblocks=%d, pageblocks=%d\n", + stats.poolsize, stats.usedsize, stats.freelistsize, stats.freeblocks, stats.pageblocks); + } +#endif +} + + +void Mem::fullcollectNoStack() +{ + gc_get()->fullcollectNoStack(); + +#if 0 + { + GCStats stats; + + gc_get()->getStats(&stats); + WPRINTF(L"Thread %x ", Thread::getId()); + WPRINTF(L"poolsize=x%x, usedsize=x%x, freelistsize=x%x, freeblocks=%d, pageblocks=%d\n", + stats.poolsize, stats.usedsize, stats.freelistsize, stats.freeblocks, stats.pageblocks); + } +#endif +} + + +void Mem::mark(void *pointer) +{ + (void) pointer; // for VC /W4 compatibility +} + + +void Mem::addroots(char* pStart, char* pEnd) +{ + gc_get()->addRange(pStart, pEnd); +} + + +void Mem::removeroots(char* pStart) +{ + gc_get()->removeRange(pStart); +} + + +void Mem::setFinalizer(void* pObj, FINALIZERPROC pFn, void* pClientData) +{ + (void)pClientData; + gc_get()->setFinalizer(pObj, pFn); +} + + +void Mem::setStackBottom(void *stackbottom) +{ + gc_get()->setStackBottom(stackbottom); +} + + +GC *Mem::getThreadGC() +{ + return gc_get(); +} + + +/* =================================================== */ + +#if 1 +void * operator new(size_t m_size) +{ + //PRINTF("Call to global operator new(%d), file = '%s', line = %d\n", m_size, GC::file ? GC::file : "(null)", GC::line); + GC::file = NULL; + GC::line = 0; + return mem.malloc(m_size); +} + +void operator delete(void *p) +{ + //WPRINTF(L"Call to global operator delete\n"); + mem.free(p); +} + +void* operator new[](size_t size) +{ + return operator new(size); +} + +void operator delete[](void *pv) +{ + operator delete(pv); +} +#endif + +void * Mem::operator new(size_t m_size) +{ void *p; + + p = gc_get()->malloc(m_size); + //printf("Mem::operator new(%d) = %p\n", m_size, p); + if (!p) + mem.error(); + return p; +} + +void * Mem::operator new(size_t m_size, Mem *mem) +{ void *p; + + p = mem->malloc(m_size); + //printf("Mem::operator new(%d) = %p\n", m_size, p); + if (!p) + ::mem.error(); + return p; +} + +void * Mem::operator new(size_t m_size, GC *gc) +{ void *p; + +// if (!gc) +// WPRINTF(L"gc is NULL\n"); + p = gc->malloc(m_size); + //printf("Mem::operator new(%d) = %p\n", m_size, p); + if (!p) + ::mem.error(); + return p; +} + +void Mem::operator delete(void *p) +{ +// printf("Mem::operator delete(%p)\n", p); + gc_get()->free(p); +} + +/* ============================================================ */ + +/* The following section of code exists to find the right + * garbage collector for this thread. There is one independent instance + * of the collector per thread. + */ + +/* ===================== linux ================================ */ + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ + +#include + +#define LOG 0 // log thread creation / destruction + +extern "C" +{ + +// Key identifying the thread-specific data +static pthread_key_t gc_key; + +/* "Once" variable ensuring that the key for gc_alloc will be allocated + * exactly once. + */ +static pthread_once_t gc_alloc_key_once = PTHREAD_ONCE_INIT; + +/* Forward functions */ +static void gc_alloc_key(); +static void gc_alloc_destroy_gc(void * accu); + + +void gc_init() +{ +#if LOG + WPRINTF(L"Thread %lx: gc_init()\n", pthread_self()); +#endif + pthread_once(&gc_alloc_key_once, gc_alloc_key); +#if LOG + WPRINTF(L"Thread %lx: gc_init() return\n", pthread_self()); +#endif +} + +GC *gc_get() +{ + GC *gc; + + // Get the thread-specific data associated with the key + gc = (GC *) pthread_getspecific(gc_key); + + // It's initially NULL, meaning that we must allocate the buffer first. + if (gc == NULL) + { + GC_LOG(); + gc = new GC(); + gc->init(); + + // Store the buffer pointer in the thread-specific data. + pthread_setspecific(gc_key, (void *) gc); +#if LOG + WPRINTF(L"Thread %lx: allocating gc at %x\n", pthread_self(), gc); +#endif + } + return gc; +} + +// Function to allocate the key for gc_alloc thread-specific data. + +static void gc_alloc_key() +{ + pthread_key_create(&gc_key, gc_alloc_destroy_gc); +#if LOG + WPRINTF(L"Thread %lx: allocated gc key %d\n", pthread_self(), gc_key); +#endif +} + +// Function to free the buffer when the thread exits. +// Called only when the thread-specific data is not NULL. + +static void gc_alloc_destroy_gc(void *gc) +{ +#if LOG + WPRINTF(L"Thread %x: freeing gc at %x\n", pthread_self(), gc); +#endif + delete (GC *)gc; +} + +} + +#endif + +/* ===================== win32 ================================ */ + +#if !defined(linux) && defined(_WIN32) + +#if 1 // single threaded version + +extern "C" +{ + +static GC *gc; + +void gc_init() +{ + if (!gc) + { gc = (GC *)::malloc(sizeof(GC)); + gc->init(); + } +} + +GC *gc_get() +{ + return gc; +} + +} + +#else // multi threaded version + +#include "mutex.h" +#include "thread.h" + +/* This is the win32 version. It suffers from the bug that + * when the thread exits the data structure is not cleared, + * but the memory pool it points to is free'd. + * Thus, if a new thread comes along with the same thread id, + * the data will look initialized, but will point to garbage. + * + * What needs to happen is when a thread exits, the associated + * GC_context data struct is cleared. + */ + +struct GC_context +{ + ThreadId threadid; // identifier of current thread + GC *gc; +}; + +Mutex gc_mutex; + +static GC_context array[64]; + +// Array of pointers to GC_context objects, one per threadid +GC_context *gccontext = array; +unsigned gccontext_allocdim = 64; +unsigned gccontext_dim; + +ThreadId gc_cache_ti; +GC_context *gc_cache_cc; + +extern "C" void gc_init() +{ +} + + +extern "C" GC *gc_get() +{ + /* This works by creating an array of GC_context's, one + * for each thread. We match up by thread id. + */ + + ThreadId ti; + GC_context *cc; + + //PRINTF("gc_get()\n"); + + ti = Thread::getId(); + gc_mutex.acquire(); + + // Used cached version if we can + if (ti == gc_cache_ti) + { + cc = gc_cache_cc; + //exception(L"getGC_context(): cache x%x", ti); + } + else + { + // This does a linear search through gccontext[]. + // A hash table might be faster if there are more + // than a dozen threads. + GC_context *ccp; + GC_context *ccptop = &gccontext[gccontext_dim]; + for (ccp = gccontext; ccp < ccptop; ccp++) + { + cc = ccp; + if (cc->threadid == ti) + { + WPRINTF(L"getGC_context(): existing x%x", ti); + goto Lret; + } + } + + // Do not allocate with garbage collector, as this must reside + // global to all threads. + + assert(gccontext_dim < gccontext_allocdim); + cc = ccp; + memset(cc, 0, sizeof(*cc)); + cc->threadid = ti; + cc->gc = new GC(); + cc->gc->init(); + + gccontext_dim++; + WPRINTF(L"getGC_context(): new x%x\n", ti); + + Lret: + // Cache for next time + gc_cache_ti = ti; + gc_cache_cc = cc; + } + + gc_mutex.release(); + return cc->gc; +} + +#endif + + +#endif diff --git a/root/gc/bits.c b/root/gc/bits.c new file mode 100644 index 00000000..bbf3a324 --- /dev/null +++ b/root/gc/bits.c @@ -0,0 +1,43 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include + +#include "bits.h" + +GCBits::GCBits() +{ + data = NULL; + nwords = 0; + nbits = 0; +} + +GCBits::~GCBits() +{ + if (data) + ::free(data); + data = NULL; +} + +void GCBits::invariant() +{ + if (data) + { + assert(nwords * sizeof(*data) * 8 >= nbits); + } +} + +void GCBits::alloc(unsigned nbits) +{ + this->nbits = nbits; + nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT; + data = (unsigned *)::calloc(nwords + 2, sizeof(unsigned)); + assert(data); +} diff --git a/root/gc/bits.h b/root/gc/bits.h new file mode 100644 index 00000000..df414392 --- /dev/null +++ b/root/gc/bits.h @@ -0,0 +1,83 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include + +#if __DMC__ +// Inline bit operations +#include +#endif + +#ifdef linux +#include "gccbitops.h" +#endif + +#if _MSC_VER + // Disable useless warnings about unreferenced functions + #pragma warning (disable : 4514) +#endif // _MSC_VER + + +#define BITS_PER_WORD 32 +#define BITS_SHIFT 5 +#define BITS_MASK 31 + +struct Mem; + +struct GCBits +{ + unsigned *data; + unsigned nwords; // allocated words in data[] excluding sentinals + unsigned nbits; // number of bits in data[] excluding sentinals + + GCBits(); + ~GCBits(); + void invariant(); + + void alloc(unsigned nbits); + +#if __DMC__ + unsigned test(unsigned i) { return _inline_bt(data + 1, i); } + void set(unsigned i) { _inline_bts(data + 1, i); } + void clear(unsigned i) { _inline_btr(data + 1, i); } + unsigned testClear(unsigned i) { return _inline_btr(data + 1, i); } + unsigned testSet(unsigned i) { return _inline_bts(data + 1, i); } +#elif 0 //defined linux + // for unknown reasons, GCC does badly with this + unsigned test(unsigned i) { return _inline_bt(data + 1, i); } + void set(unsigned i) { _inline_bts(data + 1, i); } + void clear(unsigned i) { _inline_btr(data + 1, i); } + unsigned testClear(unsigned i) { return _inline_btr(data + 1, i); } + unsigned testSet(unsigned i) { return _inline_bts(data + 1, i); } +#else + unsigned test(unsigned i) { return data[1 + (i >> BITS_SHIFT)] & (1 << (i & BITS_MASK)); } + void set(unsigned i) { data[1 + (i >> BITS_SHIFT)] |= (1 << (i & BITS_MASK)); } + void clear(unsigned i) { data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK)); } + unsigned testClear(unsigned i) + { + unsigned *p = &data[1 + (i >> BITS_SHIFT)]; + unsigned mask = (1 << (i & BITS_MASK)); + unsigned result = *p & mask; + *p &= ~mask; + return result; + } + unsigned testSet(unsigned i) + { + unsigned *p = &data[1 + (i >> BITS_SHIFT)]; + unsigned mask = (1 << (i & BITS_MASK)); + unsigned result = *p & mask; + *p |= mask; + return result; + } +#endif + + void zero() { memset(data + 1, 0, nwords * sizeof(unsigned)); } + void copy(GCBits *f) { memcpy(data + 1, f->data + 1, nwords * sizeof(unsigned)); } + + unsigned *base() { return data + 1; } +}; diff --git a/root/gc/gc.c b/root/gc/gc.c new file mode 100644 index 00000000..7c412566 --- /dev/null +++ b/root/gc/gc.c @@ -0,0 +1,2223 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +/************** Debugging ***************************/ + +#define THREADINVARIANT 0 // check thread integrity +#define INVARIANT 0 // check class invariants +#define LOGGING 0 // log allocations / frees +#define MEMSTOMP 0 // stomp on memory +#define SENTINEL 0 // add underrun/overrrun protection +#define PTRCHECK 0 // 0: fast pointer checking + // 1: more pointer checking + // 2: thorough but slow pointer checking + +/*************** Configuration *********************/ + +#define USEROOT 0 // use root for printf +#define STACKGROWSDOWN 1 // 1: growing the stack means subtracting from the stack pointer + // (use 1 for Intel X86 CPUs) + // 0: growing the stack means adding to the stack pointer +#define ATOMIC 1 // mark some mallocs as "atomic" +#define LISTPREV 1 // use List prev pointers + +/***************************************************/ + + +#include +#include +#include +#include + +#include "gc.h" +#include "os.h" +#include "bits.h" + +#if CHECK_OUT_OF_MEM +#include +extern jmp_buf g_setjmp_buf; +#endif + +//#include "../root/perftimer.h" + +#if USEROOT +#if defined linux + +#include "../root/printf.h" + +#elif defined _WIN32 + +#include "..\root\printf.h" + +#endif +#else +#include +#define WPRINTF wprintf +#define PRINTF printf +#endif + +#ifdef linux +#include "gccbitops.h" +#endif + +#ifdef _MSC_VER +#include "mscbitops.h" +#endif + +#define PAGESIZE 4096 +#define COMMITSIZE (4096*16) +#define POOLSIZE (4096*256*2) // 2 megs + +//#define printf 1 || printf + +#undef assert +#define assert(e) if (!(e)) _gc_assert(__LINE__) +void _gc_assert(unsigned line); + +static int zero = 0; // used to avoid complaints about assert(0) by MSVC + +#if LOGGING + +struct Log; + +struct LogArray +{ + unsigned dim; + unsigned allocdim; + Log *data; + + LogArray(); + ~LogArray(); + + void reserve(unsigned nentries); + void push(Log foo); + void remove(unsigned i); + unsigned find(void *p); + void copy(LogArray *from); +}; + +#endif + +enum Bins +{ + B_16, + B_32, + B_64, + B_128, + B_256, + B_512, + B_1024, + B_2048, + B_PAGE, // start of large alloc + B_PAGEPLUS, // continuation of large alloc + B_FREE, // free page + B_UNCOMMITTED, // memory not committed for this page + B_MAX +}; + + +struct List +{ + List *next; + List *prev; +}; + +struct Range +{ + void *pbot; + void *ptop; +}; + +struct Pool +{ + char *baseAddr; + char *topAddr; + GCBits mark; + GCBits scan; + GCBits finals; + GCBits freebits; +#if ATOMIC + GCBits atomic; +#endif + + unsigned npages; + unsigned ncommitted; // ncommitted <= npages + unsigned char *pagetable; + + void init(unsigned npages); + ~Pool(); + void invariant(); + + unsigned allocPages(unsigned n); + void freePages(unsigned pagenum, unsigned npages); + int cmp(Pool *); +}; + +struct Gcx +{ +#if THREADINVARIANT + pthread_t self; +# define thread_invariant(gcx) assert(gcx->self == pthread_self()) +#else +# define thread_invariant(gcx) ((void)0) +#endif + + unsigned nroots; + unsigned rootdim; + void **roots; + + unsigned nranges; + unsigned rangedim; + Range *ranges; + + unsigned noStack; // !=0 means don't scan stack + unsigned log; + unsigned anychanges; + char *stackBottom; + + char *minAddr; // min(baseAddr) + char *maxAddr; // max(topAddr) + + unsigned npages; // total number of pages in all the pools + unsigned npools; + Pool **pooltable; + + List *bucket[B_MAX]; // free list for each size + + GC_FINALIZER finalizer; // finalizer function (one per GC) + + void init(); + ~Gcx(); + void invariant(); + + void addRoot(void *p); + void removeRoot(void *p); + + void addRange(void *pbot, void *ptop); // add range to scan for roots + void removeRange(void *pbot); // remove range + + Pool *findPool(void *p); + unsigned findSize(void *p); + static Bins findBin(unsigned size); + void *bigAlloc(unsigned size); + Pool *newPool(unsigned npages); + int allocPage(Bins bin); + void mark(void *pbot, void *ptop); + unsigned fullcollectshell(); + unsigned fullcollect(void *stackTop); + void doFinalize(void *p); + + + /***** Leak Detector ******/ +#if LOGGING + LogArray current; + LogArray prev; + + void log_init(); + void log_malloc(void *p, unsigned size); + void log_free(void *p); + void log_collect(); + void log_parent(void *p, void *parent); +#else + void log_init() { } + void log_malloc(void *p, unsigned size) { (void)p; (void)size; } + void log_free(void *p) { (void)p; } + void log_collect() { } + void log_parent(void *p, void *parent) { (void)p; (void)parent; } +#endif +}; + +void _gc_assert(unsigned line) +{ + (void)line; +#if USEROOT + WPRINTF(L"GC assert fail: gc.c(%d)\n", line); +#else + printf("GC assert fail: gc.c(%d)\n", line); +#endif + *(char *)0 = 0; + exit(0); +} + +const unsigned binsize[B_MAX] = { 16,32,64,128,256,512,1024,2048,4096 }; +const unsigned notbinsize[B_MAX] = { ~(16u-1),~(32u-1),~(64u-1),~(128u-1),~(256u-1), + ~(512u-1),~(1024u-1),~(2048u-1),~(4096u-1) }; + +unsigned binset[B_PAGE][PAGESIZE / (16 * 32)]; + +/******************************** + * Initialize binset[][]. + */ + +void binset_init() +{ + int bin; + + for (bin = 0; bin < B_PAGE; bin++) + { + unsigned bitstride = binsize[bin] / 16; + + for (unsigned bit = 0; bit < (PAGESIZE / 16); bit += bitstride) + { + unsigned u = bit / 32; + unsigned m = bit % 32; + binset[bin][u] |= 1 << m; + } + } +} + +/* ============================ SENTINEL =============================== */ + + +#if SENTINEL +# define SENTINEL_PRE 0xF4F4F4F4 // 32 bits +# define SENTINEL_POST 0xF5 // 8 bits +# define SENTINEL_EXTRA (2 * sizeof(unsigned) + 1) +# define sentinel_size(p) (((unsigned *)(p))[-2]) +# define sentinel_pre(p) (((unsigned *)(p))[-1]) +# define sentinel_post(p) (((unsigned char *)(p))[sentinel_size(p)]) + +void sentinel_init(void *p, unsigned size) +{ + sentinel_size(p) = size; + sentinel_pre(p) = SENTINEL_PRE; + sentinel_post(p) = SENTINEL_POST; +} + +void sentinel_invariant(void *p, int line) +{ + //WPRINTF(L"pre = %x, line = %d\n", sentinel_pre(p), line); + if (sentinel_pre(p) != SENTINEL_PRE) + WPRINTF(L"p = %x, pre = %x, size = %x line = %d\n", p, sentinel_pre(p), sentinel_size(p), line); + assert(sentinel_pre(p) == SENTINEL_PRE); + assert(sentinel_post(p) == SENTINEL_POST); +} +#define sentinel_invariant(p) sentinel_invariant(p, __LINE__) + +inline void *sentinel_add(void *p) +{ + //assert(((unsigned)p & 3) == 0); + return (void *)((char *)p + 2 * sizeof(unsigned)); +} + +inline void *sentinel_sub(void *p) +{ + return (void *)((char *)p - 2 * sizeof(unsigned)); +} + +#else + +# define SENTINEL_EXTRA 0 +# define sentinel_init(p,size) (void)(p) +# define sentinel_invariant(p) (void)(p) +# define sentinel_add(p) (void *)(p) +# define sentinel_sub(p) (void *)(p) + +#endif + +/* ============================ GC =============================== */ + +unsigned GC::line = 0; +char *GC::file = NULL; + +GC::~GC() +{ +#if defined linux + //WPRINTF(L"Thread %x ", pthread_self()); + //WPRINTF(L"GC::~GC()\n"); +#endif + if (gcx) + { + Gcx *g = (Gcx *)gcx; + delete g; + } +} + +void GC::init() +{ + //printf("GC::init()\n"); + if (!binset[0][0]) + binset_init(); + gcx = (Gcx *)::malloc(sizeof(Gcx)); + gcx->init(); +} + +void GC::setStackBottom(void *p) +{ + thread_invariant(gcx); +#if STACKGROWSDOWN + p = (void *)((unsigned *)p + 4); + if (p > gcx->stackBottom) +#else + p = (void *)((unsigned *)p - 4); + if (p < gcx->stackBottom) +#endif + { + //WPRINTF(L"setStackBottom(%x)\n", p); + gcx->stackBottom = (char *)p; + } +} + +char *GC::strdup(const char *s) +{ + unsigned len; + char *p = NULL; + + thread_invariant(gcx); + if (s) + { + len = strlen(s) + 1; + p = (char *)malloc(len); +#if CHECK_OUT_OF_MEM + if (p) +#endif + memcpy(p, s, len); + } + return p; +} + +void *GC::calloc(size_t size, size_t n) +{ + unsigned len; + void *p; + + thread_invariant(gcx); + len = size * n; + p = malloc(len); + if (p) + { //printf("calloc: %x len %d\n", p, len); + memset(p, 0, len); + } + return p; +} + +void *GC::realloc(void *p, size_t size) +{ + thread_invariant(gcx); + if (!size) + { if (p) + { free(p); + p = NULL; + } + } + else if (!p) + { + p = malloc(size); + } + else + { void *p2; + unsigned psize; + +//WPRINTF(L"GC::realloc(p = %x, size = %u)\n", p, size); + sentinel_invariant(p); +#if SENTINEL + psize = sentinel_size(p); + if (psize != size) +#else + psize = gcx->findSize(p); // find allocated size + if (psize < size || // if new size is bigger + psize > size * 2) // or less than half +#endif + { + p2 = malloc(size); +#if CHECK_OUT_OF_MEM + if (!p2) + return NULL; +#endif + if (psize < size) + size = psize; + //WPRINTF(L"\tcopying %d bytes\n",size); + memcpy(p2, p, size); + //free(p); // causes 507 crash + p = p2; + } + } + return p; +} + +void *GC::malloc_atomic(size_t size) +{ +#if ATOMIC + //WPRINTF(L"GC::malloc_atomic(size = %d)\n", size); + void *p; + + p = malloc(size); + if (p) + { + Pool *pool = gcx->findPool(p); + pool->atomic.set(((char *)p - pool->baseAddr) / 16); + } + return p; +#else + return malloc(size); +#endif +} + +void *GC::malloc(size_t size) +{ void *p; + Bins bin; + + //WPRINTF(L"GC::malloc(size = %d)\n", size); + //PRINTF("GC::malloc(size = %d, file = '%s', line = %d)\n", size, GC::file, GC::line); + //printf("gcx->self = %x, pthread_self() = %x\n", gcx->self, pthread_self()); + thread_invariant(gcx); + if (size) + { + size += SENTINEL_EXTRA; + + // Compute size bin + bin = gcx->findBin(size); + + if (bin < B_PAGE) + { + p = gcx->bucket[bin]; + if (p == NULL) + { + if (!gcx->allocPage(bin)) // try to find a new page + { unsigned freedpages; + + freedpages = gcx->fullcollectshell(); // collect to find a new page + //if (freedpages < gcx->npools * 16) + if (freedpages < gcx->npages / 20 + 1) + { + gcx->newPool(1); + } + } + if (!gcx->bucket[bin] && !gcx->allocPage(bin)) + { int result; + + gcx->newPool(1); // allocate new pool to find a new page + result = gcx->allocPage(bin); +#if CHECK_OUT_OF_MEM + if (!result) + //return NULL; + longjmp(g_setjmp_buf, 1); +#else + assert(result); +#endif + } + p = gcx->bucket[bin]; + } + + // Return next item from free list + gcx->bucket[bin] = ((List *)p)->next; + memset((char *)p + size, 0, binsize[bin] - size); + #if MEMSTOMP + memset(p, 0xF0, size); + #endif + } + else + { + p = gcx->bigAlloc(size); + if (!p) +#if CHECK_OUT_OF_MEM + longjmp(g_setjmp_buf, 1); +#else + return NULL; +#endif + } + size -= SENTINEL_EXTRA; + p = sentinel_add(p); + sentinel_init(p, size); + //WPRINTF(L"\tmalloc => %x, %x\n", sentinel_sub(p), *(unsigned *)sentinel_sub(p)); + gcx->log_malloc(p, size); + return p; + } + return NULL; +} + +void GC::free(void *p) +{ + Pool *pool; + unsigned pagenum; + Bins bin; + unsigned bit; + + thread_invariant(gcx); + if (!p) + return; + + // Find which page it is in + pool = gcx->findPool(p); + if (!pool) // if not one of ours + return; // ignore + sentinel_invariant(p); + p = sentinel_sub(p); + pagenum = ((char *)p - pool->baseAddr) / PAGESIZE; + + if (pool->finals.nbits && gcx->finalizer) + { + bit = (unsigned)((char *)p - pool->baseAddr) / 16; + if (pool->finals.testClear(bit)) + { + (*gcx->finalizer)(sentinel_add(p), NULL); + } + } + + bin = (Bins)pool->pagetable[pagenum]; + if (bin == B_PAGE) // if large alloc + { int npages; + unsigned n; + + // Free pages + npages = 1; + n = pagenum; + while (++n < pool->ncommitted && pool->pagetable[n] == B_PAGEPLUS) + npages++; + #if MEMSTOMP + memset(p, 0xF2, npages * PAGESIZE); + #endif + pool->freePages(pagenum, npages); + } + else + { // Add to free list + List *list = (List *)p; + + #if MEMSTOMP + memset(p, 0xF2, binsize[bin]); + #endif + + list->next = gcx->bucket[bin]; + gcx->bucket[bin] = list; + } + gcx->log_free(sentinel_add(p)); +} + +void *GC::mallocdup(void *o, size_t size) +{ + void *p; + + thread_invariant(gcx); + p = malloc(size); +#if CHECK_OUT_OF_MEM + if (!p) + return NULL; +#endif + return memcpy(p, o, size); +} + +/**************************************** + * Verify that pointer p: + * 1) belongs to this memory pool + * 2) points to the start of an allocated piece of memory + * 3) is not on a free list + */ + +void GC::check(void *p) +{ + if (p) + { + sentinel_invariant(p); +#if PTRCHECK >= 1 + Pool *pool; + unsigned pagenum; + Bins bin; + unsigned size; + + p = sentinel_sub(p); + pool = gcx->findPool(p); + assert(pool); + pagenum = ((char *)p - pool->baseAddr) / PAGESIZE; + bin = (Bins)pool->pagetable[pagenum]; + assert(bin <= B_PAGE); + size = binsize[bin]; + assert(((unsigned)p & (size - 1)) == 0); + +#if PTRCHECK >= 2 + if (bin < B_PAGE) + { + // Check that p is not on a free list + List *list; + + for (list = gcx->bucket[bin]; list; list = list->next) + { + assert((void *)list != p); + } + } +#endif +#endif + } +} + +void GC::error() +{ int i = 0; + + assert(i); +} + +void GC::addRoot(void *p) +{ + thread_invariant(gcx); + gcx->addRoot(p); +} + +void GC::removeRoot(void *p) +{ + gcx->removeRoot(p); +} + +void GC::addRange(void *pbot, void *ptop) +{ + thread_invariant(gcx); + gcx->addRange(pbot, ptop); +} + +void GC::removeRange(void *pbot) +{ + gcx->removeRange(pbot); +} + +void GC::fullcollect() +{ + thread_invariant(gcx); + + gcx->fullcollectshell(); + +#if 0 + { + GCStats stats; + + getStats(&stats); + PRINTF("poolsize = %x, usedsize = %x, freelistsize = %x\n", + stats.poolsize, stats.usedsize, stats.freelistsize); + } +#endif +} + +void GC::fullcollectNoStack() +{ + //WPRINTF(L"fullcollectNoStack()\n"); + gcx->noStack++; + fullcollect(); + gcx->log_collect(); + gcx->noStack--; +} + +void GC::gencollect() +{ + gcx->fullcollectshell(); +} + +void GC::minimize() +{ + // Not implemented, ignore +} + + +void GC::setFinalizer(void *p, GC_FINALIZER pFn) +{ + thread_invariant(gcx); + + gcx->finalizer = pFn; + gcx->doFinalize(p); +} + +/***************************************** + * Retrieve statistics about garbage collection. + * Useful for debugging and tuning. + */ + +void GC::getStats(GCStats *stats) +{ + unsigned psize = 0; + unsigned usize = 0; + unsigned flsize = 0; + + unsigned n; + unsigned bsize = 0; + +//WPRINTF(L"getStats()\n"); + memset(stats, 0, sizeof(*stats)); + for (n = 0; n < gcx->npools; n++) + { Pool *pool = gcx->pooltable[n]; + + psize += pool->ncommitted * PAGESIZE; + for (unsigned j = 0; j < pool->ncommitted; j++) + { + Bins bin = (Bins)pool->pagetable[j]; + if (bin == B_FREE) + stats->freeblocks++; + else if (bin == B_PAGE) + stats->pageblocks++; + else if (bin < B_PAGE) + bsize += PAGESIZE; + } + } + + for (n = 0; n < B_PAGE; n++) + { +//WPRINTF(L"bin %d\n", n); + for (List *list = gcx->bucket[n]; list; list = list->next) + { +//WPRINTF(L"\tlist %x\n", list); + flsize += binsize[n]; + } + } + + usize = bsize - flsize; + + stats->poolsize = psize; + stats->usedsize = bsize - flsize; + stats->freelistsize = flsize; +} + +/* ============================ Gcx =============================== */ + +void Gcx::init() +{ int dummy; + + memset(this, 0, sizeof(Gcx)); + stackBottom = (char *)&dummy; + log_init(); +#if THREADINVARIANT + self = pthread_self(); +#endif + invariant(); +} + +Gcx::~Gcx() +{ + invariant(); + + for (unsigned i = 0; i < npools; i++) + { Pool *pool = pooltable[i]; + + delete pool; + } + if (pooltable) + ::free(pooltable); + + if (roots) + ::free(roots); + + if (ranges) + ::free(ranges); +} + +void Gcx::invariant() +{ +#if INVARIANT + unsigned i; + + thread_invariant(this); // assure we're called on the right thread + for (i = 0; i < npools; i++) + { Pool *pool = pooltable[i]; + + pool->invariant(); + if (i == 0) + { + assert(minAddr == pool->baseAddr); + } + if (i + 1 < npools) + { + assert(pool->cmp(pooltable[i + 1]) < 0); + } + else if (i + 1 == npools) + { + assert(maxAddr == pool->topAddr); + } + } + + if (roots) + { + assert(rootdim != 0); + assert(nroots <= rootdim); + } + + if (ranges) + { + assert(rangedim != 0); + assert(nranges <= rangedim); + + for (i = 0; i < nranges; i++) + { + assert(ranges[i].pbot); + assert(ranges[i].ptop); + assert(ranges[i].pbot <= ranges[i].ptop); + } + } + + for (i = 0; i < B_PAGE; i++) + { + for (List *list = bucket[i]; list; list = list->next) + { + } + } +#endif +} + +/*************************************** + */ + +void Gcx::addRoot(void *p) +{ + if (nroots == rootdim) + { + unsigned newdim = rootdim * 2 + 16; + void **newroots; + + newroots = (void **)::malloc(newdim * sizeof(newroots[0])); +#if CHECK_OUT_OF_MEM + if (!newroots) + longjmp(g_setjmp_buf, 1); +#else + assert(newroots); +#endif + if (roots) + { memcpy(newroots, roots, nroots * sizeof(newroots[0])); + ::free(roots); + } + roots = newroots; + rootdim = newdim; + } + roots[nroots] = p; + nroots++; +} + +void Gcx::removeRoot(void *p) +{ + unsigned i; + for (i = nroots; i--;) + { + if (roots[i] == p) + { + nroots--; + memmove(roots + i, roots + i + 1, (nroots - i) * sizeof(roots[0])); + return; + } + } + assert(zero); +} + + +/*************************************** + */ + +void Gcx::addRange(void *pbot, void *ptop) +{ + //WPRINTF(L"Thread %x ", pthread_self()); + //WPRINTF(L"%x->Gcx::addRange(%x, %x), nranges = %d\n", this, pbot, ptop, nranges); + if (nranges == rangedim) + { + unsigned newdim = rangedim * 2 + 16; + Range *newranges; + + newranges = (Range *)::malloc(newdim * sizeof(newranges[0])); +#if CHECK_OUT_OF_MEM + if (!newranges) + longjmp(g_setjmp_buf, 1); +#else + assert(newranges); +#endif + if (ranges) + { memcpy(newranges, ranges, nranges * sizeof(newranges[0])); + ::free(ranges); + } + ranges = newranges; + rangedim = newdim; + } + ranges[nranges].pbot = pbot; + ranges[nranges].ptop = ptop; + nranges++; +} + +void Gcx::removeRange(void *pbot) +{ + //WPRINTF(L"Thread %x ", pthread_self()); + //WPRINTF(L"%x->Gcx::removeRange(%x), nranges = %d\n", this, pbot, nranges); + for (unsigned i = nranges; i--;) + { + if (ranges[i].pbot == pbot) + { + nranges--; + memmove(ranges + i, ranges + i + 1, (nranges - i) * sizeof(ranges[0])); + return; + } + } + //WPRINTF(L"Wrong thread\n"); + + // This is a fatal error, but ignore it at Sun's request. + // The problem is that we can get a Close() call on a thread + // other than the one the range was allocated on. + //assert(zero); +} + + +/*********************************** + * Allocate a new pool with at least npages in it. + * Sort it into pooltable[]. + * Return NULL if failed. + */ + +Pool *Gcx::newPool(unsigned npages) +{ + Pool *pool; + Pool **newpooltable; + unsigned newnpools; + unsigned i; + + //WPRINTF(L"************Gcx::newPool(npages = %d)****************\n", npages); + + // Round up to COMMITSIZE pages + npages = (npages + (COMMITSIZE/PAGESIZE) - 1) & ~(COMMITSIZE/PAGESIZE - 1); + + // Minimum of POOLSIZE + if (npages < POOLSIZE/PAGESIZE) + npages = POOLSIZE/PAGESIZE; + + // Allocate successively larger pools up to 8 megs + if (npools) + { unsigned n; + + n = npools; + if (n > 8) + n = 8; // cap pool size at 8 megs + n *= (POOLSIZE / PAGESIZE); + if (npages < n) + npages = n; + } + + pool = (Pool *)::malloc(sizeof(Pool)); + if (pool) + { + pool->init(npages); + if (!pool->baseAddr) + goto Lerr; + + newnpools = npools + 1; + newpooltable = (Pool **)::realloc(pooltable, newnpools * sizeof(Pool *)); + if (!newpooltable) + goto Lerr; + + // Sort pool into newpooltable[] + for (i = 0; i < npools; i++) + { + if (pool->cmp(newpooltable[i]) < 0) + break; + } + memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * sizeof(Pool *)); + newpooltable[i] = pool; + + pooltable = newpooltable; + npools = newnpools; + this->npages += npages; + + minAddr = pooltable[0]->baseAddr; + maxAddr = pooltable[npools - 1]->topAddr; + } + return pool; + + Lerr: + delete pool; + return NULL; +} + +/**************************************** + * Allocate a chunk of memory that is larger than a page. + * Return NULL if out of memory. + */ + +void *Gcx::bigAlloc(unsigned size) +{ + Pool *pool; + unsigned npages; + unsigned n; + unsigned pn; + unsigned freedpages; + void *p; + int state; + + npages = (size + PAGESIZE - 1) / PAGESIZE; + + for (state = 0; ; ) + { + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + pn = pool->allocPages(npages); + if (pn != ~0u) + goto L1; + } + + // Failed + switch (state) + { + case 0: + // Try collecting + freedpages = fullcollectshell(); + if (freedpages >= npools * ((POOLSIZE / PAGESIZE) / 2)) + { state = 1; + continue; + } + // Allocate new pool + pool = newPool(npages); + if (!pool) + { state = 2; + continue; + } + pn = pool->allocPages(npages); + assert(pn != ~0u); + goto L1; + + case 1: + // Allocate new pool + pool = newPool(npages); + if (!pool) + goto Lnomemory; + pn = pool->allocPages(npages); + assert(pn != ~0u); + goto L1; + + case 2: + goto Lnomemory; + } + } + + L1: + pool->pagetable[pn] = B_PAGE; + if (npages > 1) + memset(&pool->pagetable[pn + 1], B_PAGEPLUS, npages - 1); + p = pool->baseAddr + pn * PAGESIZE; + memset((char *)p + size, 0, npages * PAGESIZE - size); + #if MEMSTOMP + memset(p, 0xF1, size); + #endif + //printf("\tp = %x\n", p); + return p; + + Lnomemory: + //assert(zero); + return NULL; +} + +/******************************* + * Allocate a page of bin's. + * Returns: + * 0 failed + */ + +int Gcx::allocPage(Bins bin) +{ + Pool *pool; + unsigned n; + unsigned pn; + char *p; + char *ptop; + + //printf("Gcx::allocPage(bin = %d)\n", bin); + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + pn = pool->allocPages(1); + if (pn != ~0u) + goto L1; + } + return 0; // failed + + L1: + pool->pagetable[pn] = (unsigned char)bin; + + // Convert page to free list + unsigned size = binsize[bin]; + List **b = &bucket[bin]; + + p = pool->baseAddr + pn * PAGESIZE; + ptop = p + PAGESIZE; + for (; p < ptop; p += size) + { List *list = (List *)p; + + list->next = *b; + *b = list; + } + return 1; +} + +/******************************* + * Find Pool that pointer is in. + * Return NULL if not in a Pool. + * Assume pooltable[] is sorted. + */ + +Pool *Gcx::findPool(void *p) +{ + if (p >= minAddr && p < maxAddr) + { + if (npools == 1) + { + return pooltable[0]; + } + + for (unsigned i = 0; i < npools; i++) + { Pool *pool; + + pool = pooltable[i]; + if (p < pool->topAddr) + { if (pool->baseAddr <= p) + return pool; + break; + } + } + } + return NULL; +} + +/******************************* + * Find size of pointer p. + * Returns 0 if not a gc'd pointer + */ + +unsigned Gcx::findSize(void *p) +{ + Pool *pool; + unsigned size = 0; + + pool = findPool(p); + if (pool) + { + unsigned pagenum; + Bins bin; + + pagenum = ((unsigned)((char *)p - pool->baseAddr)) / PAGESIZE; + bin = (Bins)pool->pagetable[pagenum]; + size = binsize[bin]; + if (bin == B_PAGE) + { unsigned npages = pool->ncommitted; + unsigned char *pt; + unsigned i; + + pt = &pool->pagetable[0]; + for (i = pagenum + 1; i < npages; i++) + { + if (pt[i] != B_PAGEPLUS) + break; + } + size = (i - pagenum) * PAGESIZE; + } + } + return size; +} + + +/******************************* + * Compute bin for size. + */ + +Bins Gcx::findBin(unsigned size) +{ Bins bin; + + if (size <= 256) + { + if (size <= 64) + { + if (size <= 16) + bin = B_16; + else if (size <= 32) + bin = B_32; + else + bin = B_64; + } + else + { + if (size <= 128) + bin = B_128; + else + bin = B_256; + } + } + else + { + if (size <= 1024) + { + if (size <= 512) + bin = B_512; + else + bin = B_1024; + } + else + { + if (size <= 2048) + bin = B_2048; + else + bin = B_PAGE; + } + } + return bin; +} + +/************************************ + * Search a range of memory values and mark any pointers into the GC pool. + */ + +void Gcx::mark(void *pbot, void *ptop) +{ + void **p1 = (void **)pbot; + void **p2 = (void **)ptop; + unsigned changes = 0; + Pool *pool; + + //if (log) printf("Gcx::mark(%p .. %p)\n", pbot, ptop); + if (npools == 1) + pool = pooltable[0]; + + for (; p1 < p2; p1++) + { + char *p = (char *)(*p1); + + //if (log) WPRINTF(L"\tmark %x\n", p); + if (p >= minAddr && p < maxAddr /*&& ((int)p & 3) == 0*/) + { + if (npools != 1) + { pool = findPool(p); + if (!pool) + continue; + } + + unsigned offset = (unsigned)(p - pool->baseAddr); + unsigned bit; + unsigned pn = offset / PAGESIZE; + Bins bin = (Bins)pool->pagetable[pn]; + + //printf("\t\tfound pool %x, base=%x, pn = %d, bin = %d, bit = x%x\n", pool, pool->baseAddr, pn, bin, bit); + + // Adjust bit to be at start of allocated memory block + if (bin <= B_PAGE) + { + bit = (offset & notbinsize[bin]) >> 4; + //printf("\t\tbit = x%x\n", bit); + } + else if (bin == B_PAGEPLUS) + { + do + { --pn; + } while ((Bins)pool->pagetable[pn] == B_PAGEPLUS); + bit = pn * (PAGESIZE / 16); + } + else + { + // Don't mark bits in B_FREE or B_UNCOMMITTED pages + continue; + } + + //printf("\t\tmark(x%x) = %d\n", bit, pool->mark.test(bit)); + if (!pool->mark.testSet(bit)) + { + //if (log) PRINTF("\t\tmarking %p\n", p); + //pool->mark.set(bit); +#if ATOMIC + if (!pool->atomic.test(bit)) +#endif + { + pool->scan.set(bit); + changes += 1; + } + log_parent(sentinel_add(pool->baseAddr + bit * 16), sentinel_add(pbot)); + } + } + } + anychanges += changes; +} + +/********************************* + * Return number of full pages free'd. + */ + +unsigned Gcx::fullcollectshell() +{ +#if __GCC__ + asm("pushl %eax"); + asm("pushl %ebx"); + asm("pushl %ecx"); + asm("pushl %edx"); + asm("pushl %ebp"); + asm("pushl %esi"); + asm("pushl %edi"); + // This function must ensure that all register variables are on the stack + // before &dummy + unsigned dummy; + dummy = fullcollect(&dummy - 7); + asm("addl $28,%esp"); +#elif _MSC_VER || __DMC__ + __asm push eax; + __asm push ebx; + __asm push ecx; + __asm push edx; + __asm push ebp; + __asm push esi; + __asm push edi; + // This function must ensure that all register variables are on the stack + // before &dummy + unsigned dummy; + dummy = fullcollect(&dummy - 7); + __asm add esp,28; +#else + // This function must ensure that all register variables are on the stack + // before &dummy + unsigned dummy; + dummy = fullcollect(&dummy); +#endif + return dummy; +} + +unsigned Gcx::fullcollect(void *stackTop) +{ + unsigned n; + Pool *pool; + unsigned freedpages = 0; + unsigned freed = 0; + unsigned recoveredpages = 0; + +int x1 = 0; +int x2 = 0; +int x3 = 0; + + //PRINTF("Gcx::fullcollect() npools = %d\n", npools); +//PerfTimer pf(L"fullcollect"); + invariant(); + anychanges = 0; + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + pool->mark.zero(); + pool->scan.zero(); + pool->freebits.zero(); + } + + // Mark each free entry, so it doesn't get scanned + for (n = 0; n < B_PAGE; n++) + { + List *list = bucket[n]; + List *prev = NULL; + + //WPRINTF(L"bin = %d\n", n); + for (; list; list = list->next) + { + if (list->prev != prev) + list->prev = prev; + prev = list; + pool = findPool(list); + assert(pool); + //WPRINTF(L" list = %x, bit = %d\n", list, (unsigned)((char *)list - pool->baseAddr) / 16); + pool->freebits.set((unsigned)((char *)list - pool->baseAddr) / 16); + assert(pool->freebits.test((unsigned)((char *)list - pool->baseAddr) / 16)); + } + } + +#if SENTINEL + // Every memory item should either be on the free list or have the sentinel + // set. + for (n = 0; n < npools; n++) + { unsigned pn; + unsigned ncommitted; + + pool = pooltable[n]; + ncommitted = pool->ncommitted; + for (pn = 0; pn < ncommitted; pn++) + { + char *p; + char *ptop; + Bins bin = (Bins)pool->pagetable[pn]; + unsigned bit; + + p = pool->baseAddr + pn * PAGESIZE; + ptop = p + PAGESIZE; + + //WPRINTF(L"pn = %d, bin = %d\n", pn, bin); + if (bin < B_PAGE) + { + unsigned size = binsize[bin]; + unsigned bitstride = size / 16; + bit = pn * (PAGESIZE/16); + + for (; p < ptop; p += size, bit += bitstride) + { + if (pool->freebits.test(bit)) + ; + else + { + //WPRINTF(L"p = %x, *p = %x\n", p, *(unsigned *)p); + sentinel_invariant(sentinel_add(p)); + } + } + } + } + } +#endif + + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + pool->mark.copy(&pool->freebits); + } + + if (!noStack) + { + // Scan stack + //WPRINTF(L"scan stack bot = %x, top = %x\n", stackTop, stackBottom); +#if STACKGROWSDOWN + mark(stackTop, stackBottom); +#else + mark(stackBottom, stackTop); +#endif + } + + // Scan roots[] + //WPRINTF(L"scan roots[]\n"); + mark(roots, roots + nroots); + + // Scan ranges[] + //WPRINTF(L"scan ranges[]\n"); + //log++; + for (n = 0; n < nranges; n++) + { + //WPRINTF(L"\t%x .. %x\n", ranges[n].pbot, ranges[n].ptop); + mark(ranges[n].pbot, ranges[n].ptop); + } + //log--; + + //WPRINTF(L"\tscan heap\n"); +{ +//PerfTimer pf(L"fullcollect: scanning "); + while (anychanges) + { + //WPRINTF(L"anychanges = %d\n", anychanges); + anychanges = 0; + for (n = 0; n < npools; n++) + { + unsigned *bbase; + unsigned *b; + unsigned *btop; + + pool = pooltable[n]; + + bbase = pool->scan.base(); + btop = bbase + pool->scan.nwords; + for (b = bbase; b < btop;) + { Bins bin; + unsigned pn; + unsigned u; + unsigned bitm; + char *o; + char *ostart; + + bitm = *b; + if (!bitm) + { b++; + continue; + } + //WPRINTF(L"bitm = x%08x, b = %x\n", bitm, b); + pn = (b - bbase) / (PAGESIZE / (32 * 16)); + bin = (Bins)pool->pagetable[pn]; + o = pool->baseAddr + (b - bbase) * 32 * 16; + *b = 0; + + if (bin < B_PAGE) + { int size = binsize[bin]; + unsigned index; + + do + { + index = _inline_bsf(bitm); + o += index * 16; + mark(o, o + size); + o += 16; + + // Cannot combine these two, because 0x80000000<<32 is + // still 0x80000000 + bitm >>= 1; + } while ((bitm >>= index) != 0); + } + else if (bin == B_PAGE) + { + u = 1; + while (pn + u < pool->ncommitted && + pool->pagetable[pn + u] == B_PAGEPLUS) + u++; + o = pool->baseAddr + pn * PAGESIZE; + mark(o, o + u * PAGESIZE); + b = bbase + (pn + u) * (PAGESIZE / (32 * 16)); + } + else + { + assert(0); + } + } + } + } +} + + // Free up everything not marked +{ +//PerfTimer pf(L"fullcollect: freeing "); + //WPRINTF(L"\tfree'ing\n"); + for (n = 0; n < npools; n++) + { unsigned pn; + unsigned ncommitted; + unsigned *bbase; + unsigned *fbase; + int delta; + + pool = pooltable[n]; + bbase = pool->mark.base(); + delta = pool->freebits.base() - bbase; + ncommitted = pool->ncommitted; + for (pn = 0; pn < ncommitted; pn++, bbase += PAGESIZE / (32 * 16)) + { + Bins bin = (Bins)pool->pagetable[pn]; + + if (bin < B_PAGE) + { char *p; + char *ptop; + unsigned bit; + unsigned bitstride; + unsigned size = binsize[bin]; + + p = pool->baseAddr + pn * PAGESIZE; + ptop = p + PAGESIZE; + bit = pn * (PAGESIZE/16); + bitstride = size / 16; + +#if 1 + // If free'd entire page + fbase = bbase + delta; +#if INVARIANT + assert(bbase == pool->mark.base() + pn * 8); +#endif +#if 1 + if ((bbase[0] ^ fbase[0]) == 0 && + (bbase[1] ^ fbase[1]) == 0 && + (bbase[2] ^ fbase[2]) == 0 && + (bbase[3] ^ fbase[3]) == 0 && + (bbase[4] ^ fbase[4]) == 0 && + (bbase[5] ^ fbase[5]) == 0 && + (bbase[6] ^ fbase[6]) == 0 && + (bbase[7] ^ fbase[7]) == 0) +#else + if ((bbase[0]) == 0 && + (bbase[1]) == 0 && + (bbase[2]) == 0 && + (bbase[3]) == 0 && + (bbase[4]) == 0 && + (bbase[5]) == 0 && + (bbase[6]) == 0 && + (bbase[7]) == 0) +#endif + { +x1++; + for (; p < ptop; p += size, bit += bitstride) + { +#if LISTPREV + if (pool->freebits.test(bit)) + { // Remove from free list + List *list = (List *)p; + + //WPRINTF(L"bbase = %x, bbase[0] = %x, mark = %d\n", bbase, bbase[0], pool->mark.test(bit)); + //WPRINTF(L"p = %x, bin = %d, size = %d, bit = %d\n", p, bin, size, bit); + + if (bucket[bin] == list) + bucket[bin] = list->next; + if (list->next) + list->next->prev = list->prev;; + if (list->prev) + list->prev->next = list->next; + continue; + } +#endif +#if ATOMIC + pool->atomic.clear(bit); +#endif + if (finalizer && pool->finals.nbits && + pool->finals.testClear(bit)) + { + (*finalizer)((List *)sentinel_add(p), NULL); + } + + List *list = (List *)p; + //printf("\tcollecting %x\n", list); + log_free(sentinel_add(list)); + + #if MEMSTOMP + memset(p, 0xF3, size); + #endif + } + pool->pagetable[pn] = B_FREE; + recoveredpages++; + //printf("freeing entire page %d\n", pn); + continue; + } +#endif + if (bbase[0] == binset[bin][0] && + bbase[1] == binset[bin][1] && + bbase[2] == binset[bin][2] && + bbase[3] == binset[bin][3] && + bbase[4] == binset[bin][4] && + bbase[5] == binset[bin][5] && + bbase[6] == binset[bin][6] && + bbase[7] == binset[bin][7]) + { +x2++; + continue; + } +x3++; + for (; p < ptop; p += size, bit += bitstride) + { + if (!pool->mark.test(bit)) + { + sentinel_invariant(sentinel_add(p)); + +#if ATOMIC + pool->atomic.clear(bit); +#endif + pool->freebits.set(bit); + if (finalizer && pool->finals.nbits && + pool->finals.testClear(bit)) + { + (*finalizer)((List *)sentinel_add(p), NULL); + } + + List *list = (List *)p; + //WPRINTF(L"\tcollecting %x, bin = %d\n", list, bin); + log_free(sentinel_add(list)); + + #if MEMSTOMP + memset(p, 0xF3, size); + #endif + +#if LISTPREV + // Add to free list + list->next = bucket[bin]; + list->prev = NULL; + if (list->next) + list->next->prev = list; + bucket[bin] = list; +#endif + freed += size; + } + } + } + else if (bin == B_PAGE) + { unsigned bit = pn * (PAGESIZE / 16); + + if (!pool->mark.test(bit)) + { char *p = pool->baseAddr + pn * PAGESIZE; + + sentinel_invariant(sentinel_add(p)); +#if ATOMIC + pool->atomic.clear(bit); +#endif + if (finalizer && pool->finals.nbits && + pool->finals.testClear(bit)) + { + (*finalizer)(sentinel_add(p), NULL); + } + + //printf("\tcollecting big %x\n", p); + log_free(sentinel_add(p)); + pool->pagetable[pn] = B_FREE; + freedpages++; + #if MEMSTOMP + memset(p, 0xF3, PAGESIZE); + #endif + while (pn + 1 < ncommitted && pool->pagetable[pn + 1] == B_PAGEPLUS) + { + pn++; + bbase += PAGESIZE / (32 * 16); + pool->pagetable[pn] = B_FREE; + freedpages++; + + #if MEMSTOMP + p += PAGESIZE; + memset(p, 0xF3, PAGESIZE); + #endif + } + } + } + } + } +} + +#if !LISTPREV + // Zero buckets + memset(bucket, 0, sizeof(bucket)); + + // Free complete pages, rebuild free list + //WPRINTF(L"\tfree complete pages\n"); +PerfTimer pf(L"fullcollect: recoverpages"); + recoveredpages = 0; + for (n = 0; n < npools; n++) + { unsigned pn; + unsigned ncommitted; + + pool = pooltable[n]; + ncommitted = pool->ncommitted; + for (pn = 0; pn < ncommitted; pn++) + { + Bins bin = (Bins)pool->pagetable[pn]; + unsigned bit; + unsigned u; + + if (bin < B_PAGE) + { + unsigned size = binsize[bin]; + unsigned bitstride = size / 16; + unsigned bitbase = pn * (PAGESIZE / 16); + unsigned bittop = bitbase + (PAGESIZE / 16); + char *p; + + bit = bitbase; + for (bit = bitbase; bit < bittop; bit += bitstride) + { if (!pool->freebits.test(bit)) + goto Lnotfree; + } + pool->pagetable[pn] = B_FREE; + recoveredpages++; + continue; + + Lnotfree: + p = pool->baseAddr + pn * PAGESIZE; + for (bit = bitbase; bit < bittop; bit += bitstride) + { if (pool->freebits.test(bit)) + { List *list; + + u = (bit - bitbase) * 16; + list = (List *)(p + u); + if (list->next != bucket[bin]) // avoid unnecessary writes + list->next = bucket[bin]; + bucket[bin] = list; + } + } + } + } + } +#endif + +#undef printf +// printf("recovered pages = %d\n", recoveredpages); +// printf("\tfree'd %u bytes, %u pages from %u pools\n", freed, freedpages, npools); +#define printf 1 || printf + + //WPRINTF(L"\tfree'd %u bytes, %u pages from %u pools\n", freed, freedpages, npools); + invariant(); + +#if 0 +if (noStack) +{ + WPRINTF(L"\tdone, freedpages = %d, recoveredpages = %d, freed = %d, total = %d\n", freedpages, recoveredpages, freed / PAGESIZE, freedpages + recoveredpages + freed / PAGESIZE); + WPRINTF(L"\tx1 = %d, x2 = %d, x3 = %d\n", x1, x2, x3); + int psize = 0; + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + psize += pool->topAddr - pool->baseAddr; + } + WPRINTF(L"total memory = x%x (npages=%d) in %d pools\n", psize, npages, npools); + + psize = 0; + for (n = 0; n < npools; n++) + { + pool = pooltable[n]; + for (unsigned i = 0; i < pool->ncommitted; i++) + { + if (pool->pagetable[i] < B_FREE) + { psize++; + if (psize <= 25) + WPRINTF(L"\tbin = %d\n", pool->pagetable[i]); + } + } + } + WPRINTF(L"total used pages = %d\n", psize); +} +#endif + return freedpages + recoveredpages + freed / PAGESIZE; +} + +/********************************* + * Run finalizer on p when it is free'd. + */ + +void Gcx::doFinalize(void *p) +{ + Pool *pool = findPool(p); + assert(pool); + + // Only allocate finals[] if we actually need it + if (!pool->finals.nbits) + pool->finals.alloc(pool->mark.nbits); + + pool->finals.set(((char *)p - pool->baseAddr) / 16); +} + +/* ============================ Pool =============================== */ + +void Pool::init(unsigned npages) +{ + unsigned poolsize; + + //printf("Pool::Pool(%u)\n", npages); + poolsize = npages * PAGESIZE; + assert(poolsize >= POOLSIZE); + baseAddr = (char *)os_mem_map(poolsize); + + if (!baseAddr) + { +#if CHECK_OUT_OF_MEM + longjmp(g_setjmp_buf, 1); +#endif + WPRINTF(L"GC fail: poolsize = x%x, errno = %d\n", poolsize, errno); +#if USEROOT + PRINTF("message = '%s'\n", sys_errlist[errno]); +#else + printf("message = '%s'\n", sys_errlist[errno]); +#endif + npages = 0; + poolsize = 0; + } + //assert(baseAddr); + topAddr = baseAddr + poolsize; + + mark.alloc(poolsize / 16); + scan.alloc(poolsize / 16); + freebits.alloc(poolsize / 16); +#if ATOMIC + atomic.alloc(poolsize / 16); +#endif + + pagetable = (unsigned char *)::malloc(npages); + memset(pagetable, B_UNCOMMITTED, npages); + + this->npages = npages; + ncommitted = 0; + + invariant(); +} + +Pool::~Pool() +{ + invariant(); + if (baseAddr) + { + int result; + + if (ncommitted) + { + result = os_mem_decommit(baseAddr, 0, ncommitted * PAGESIZE); + assert(result == 0); + } + + if (npages) + { + result = os_mem_unmap(baseAddr, npages * PAGESIZE); + assert(result == 0); + } + } + if (pagetable) + ::free(pagetable); +} + +void Pool::invariant() +{ +#if INVARIANT + mark.invariant(); + scan.invariant(); + + assert(baseAddr < topAddr); + assert(baseAddr + npages * PAGESIZE == topAddr); + assert(ncommitted <= npages); + + for (unsigned i = 0; i < npages; i++) + { Bins bin = (Bins)pagetable[i]; + + assert(bin < B_MAX); +#if 0 + // Buggy GCC doesn't compile this right with -O + if (i < ncommitted) + assert(bin != B_UNCOMMITTED); + else + assert(bin == B_UNCOMMITTED); +#endif + } +#endif +} + +/*************************** + * Used for sorting pooltable[] + */ + +int Pool::cmp(Pool *p2) +{ + return baseAddr - p2->baseAddr; +} + +/************************************** + * Allocate n pages from Pool. + * Returns ~0u on failure. + */ + +unsigned Pool::allocPages(unsigned n) +{ + unsigned i; + unsigned n2; + + //printf("Pool::allocPages(n = %d)\n", n); + n2 = n; + for (i = 0; i < ncommitted; i++) + { + if (pagetable[i] == B_FREE) + { + if (--n2 == 0) + { //printf("\texisting pn = %d\n", i - n + 1); + return i - n + 1; + } + } + else + n2 = n; + } + if (ncommitted + n < npages) + { + unsigned tocommit; + + tocommit = (n + (COMMITSIZE/PAGESIZE) - 1) & ~(COMMITSIZE/PAGESIZE - 1); + if (ncommitted + tocommit > npages) + tocommit = npages - ncommitted; + //printf("\tlooking to commit %d more pages\n", tocommit); + //fflush(stdout); + if (os_mem_commit(baseAddr, ncommitted * PAGESIZE, tocommit * PAGESIZE) == 0) + { + memset(pagetable + ncommitted, B_FREE, tocommit); + i = ncommitted; + ncommitted += tocommit; + + while (i && pagetable[i - 1] == B_FREE) + i--; + + return i; + } + //printf("\tfailed to commit %d pages\n", tocommit); + } + + return ~0u; +} + +/********************************** + * Free npages pages starting with pagenum. + */ + +void Pool::freePages(unsigned pagenum, unsigned npages) +{ + memset(&pagetable[pagenum], B_FREE, npages); +} + +/* ======================= Leak Detector =========================== */ + +#if LOGGING + +struct Log +{ + void *p; + unsigned size; + unsigned line; + char *file; + void *parent; + + void print(); +}; + +void Log::print() +{ + WPRINTF(L" p = %x, size = %d, parent = %x ", p, size, parent); + if (file) + { + PRINTF("%s(%u)", file, line); + } + WPRINTF(L"\n"); +} + +LogArray::LogArray() +{ + data = NULL; + dim = 0; + allocdim = 0; +} + +LogArray::~LogArray() +{ + if (data) + ::free(data); + data = NULL; +} + +void LogArray::reserve(unsigned nentries) +{ + //WPRINTF(L"LogArray::reserve(%d)\n", nentries); + assert(dim <= allocdim); + if (allocdim - dim < nentries) + { + allocdim = (dim + nentries) * 2; + assert(dim + nentries <= allocdim); + if (!data) + { + data = (Log *)::malloc(allocdim * sizeof(*data)); + } + else + { Log *newdata; + + newdata = (Log *)::malloc(allocdim * sizeof(*data)); + assert(newdata); + memcpy(newdata, data, dim * sizeof(Log)); + ::free(data); + data = newdata; + } + assert(!allocdim || data); + } +} + +void LogArray::push(Log log) +{ + reserve(1); + data[dim++] = log; +} + +void LogArray::remove(unsigned i) +{ + memmove(data + i, data + i + 1, (dim - i) * sizeof(data[0])); + dim--; +} + +unsigned LogArray::find(void *p) +{ + for (unsigned i = 0; i < dim; i++) + { + if (data[i].p == p) + return i; + } + return ~0u; // not found +} + +void LogArray::copy(LogArray *from) +{ + if (from->dim > dim) + { reserve(from->dim - dim); + assert(from->dim <= allocdim); + } + memcpy(data, from->data, from->dim * sizeof(data[0])); + dim = from->dim; +} + + +/****************************/ + +void Gcx::log_init() +{ + //WPRINTF(L"+log_init()\n"); + current.reserve(1000); + prev.reserve(1000); + //WPRINTF(L"-log_init()\n"); +} + +void Gcx::log_parent(void *p, void *parent) +{ + //WPRINTF(L"+log_parent()\n"); + unsigned i; + + i = current.find(p); + if (i == ~0u) + { + WPRINTF(L"parent'ing unallocated memory %x, parent = %x\n", p, parent); + Pool *pool; + pool = findPool(p); + assert(pool); + unsigned offset = (unsigned)((char *)p - pool->baseAddr); + unsigned bit; + unsigned pn = offset / PAGESIZE; + Bins bin = (Bins)pool->pagetable[pn]; + bit = (offset & notbinsize[bin]); + WPRINTF(L"\tbin = %d, offset = x%x, bit = x%x\n", bin, offset, bit); + } + else + { + current.data[i].parent = parent; + } + //WPRINTF(L"-log_parent()\n"); +} + +void Gcx::log_malloc(void *p, unsigned size) +{ + //WPRINTF(L"+log_malloc(p = %x, size = %d)\n", p, size); + Log log; + + log.p = p; + log.size = size; + log.line = GC::line; + log.file = GC::file; + log.parent = NULL; + + GC::line = 0; + GC::file = NULL; + + current.push(log); + //WPRINTF(L"-log_malloc()\n"); +} + +void Gcx::log_free(void *p) +{ + //WPRINTF(L"+log_free(%x)\n", p); + unsigned i; + + i = current.find(p); + if (i == ~0u) + { + WPRINTF(L"free'ing unallocated memory %x\n", p); + } + else + current.remove(i); + //WPRINTF(L"-log_free()\n"); +} + +void Gcx::log_collect() +{ + //WPRINTF(L"+log_collect()\n"); + // Print everything in current that is not in prev + + WPRINTF(L"New pointers this cycle: --------------------------------\n"); + int used = 0; + for (unsigned i = 0; i < current.dim; i++) + { + unsigned j; + + j = prev.find(current.data[i].p); + if (j == ~0u) + current.data[i].print(); + else + used++; + } + + WPRINTF(L"All roots this cycle: --------------------------------\n"); + for (unsigned i = 0; i < current.dim; i++) + { + void *p; + unsigned j; + + p = current.data[i].p; + if (!findPool(current.data[i].parent)) + { + j = prev.find(current.data[i].p); + if (j == ~0u) + WPRINTF(L"N"); + else + WPRINTF(L" ");; + current.data[i].print(); + } + } + + WPRINTF(L"Used = %d-------------------------------------------------\n", used); + prev.copy(¤t); + + WPRINTF(L"-log_collect()\n"); +} + +#endif diff --git a/root/gc/gc.h b/root/gc/gc.h new file mode 100644 index 00000000..9f5e926b --- /dev/null +++ b/root/gc/gc.h @@ -0,0 +1,68 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef GC_H +#define GC_H + +struct Gcx; // private data + +typedef void (*GC_FINALIZER)(void *p, void *dummy); + +struct GCStats +{ + unsigned poolsize; // total size of pool + unsigned usedsize; // bytes allocated + unsigned freeblocks; // number of blocks marked FREE + unsigned freelistsize; // total of memory on free lists + unsigned pageblocks; // number of blocks marked PAGE +}; + +struct GC +{ + // For passing to debug code + static unsigned line; + static char *file; +// #define GC_LOG() ((GC::line = __LINE__), (GC::file = __FILE__)) + #define GC_LOG() ((void)0) + + Gcx *gcx; // implementation + + ~GC(); + + void init(); + + char *strdup(const char *s); + void *malloc(size_t size); + void *malloc_atomic(size_t size); + void *calloc(size_t size, size_t n); + void *realloc(void *p, size_t size); + void free(void *p); + void *mallocdup(void *o, size_t size); + void check(void *p); + void error(); + + void setStackBottom(void *p); + + void addRoot(void *p); // add p to list of roots + void removeRoot(void *p); // remove p from list of roots + + void addRange(void *pbot, void *ptop); // add range to scan for roots + void removeRange(void *pbot); // remove range + + void fullcollect(); // do full garbage collection + void fullcollectNoStack(); // do full garbage collection; no scan stack + void gencollect(); // do generational garbage collection + void minimize(); // minimize physical memory usage + + void setFinalizer(void *p, GC_FINALIZER pFn); + + void getStats(GCStats *stats); +}; + +#endif + diff --git a/root/gc/gccbitops.h b/root/gc/gccbitops.h new file mode 100644 index 00000000..89fd82b7 --- /dev/null +++ b/root/gc/gccbitops.h @@ -0,0 +1,69 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Bit operations for GCC and I386 + +#ifndef GCCBITOPS_H +#define GCCBITOPS_H 1 + +inline int _inline_bsf(int w) +{ int index; + + __asm__ __volatile__ + ( + "bsfl %1, %0 \n\t" + : "=r" (index) + : "r" (w) + ); + return index; +} + + +inline int _inline_bt(unsigned *p, int i) +{ + char result; + + __asm__ __volatile__ + ( + "btl %2,%1 \n\t" + "setc %0 \n\t" + :"=r" (result) + :"m" (*p), "r" (i) + ); + return result; +} + +inline int _inline_bts(unsigned *p, int i) +{ + char result; + + __asm__ __volatile__ + ( + "btsl %2,%1 \n\t" + "setc %0 \n\t" + :"=r" (result) + :"m" (*p), "r" (i) + ); + return result; +} + +inline int _inline_btr(unsigned *p, int i) +{ + char result; + + __asm__ __volatile__ + ( + "btrl %2,%1 \n\t" + "setc %0 \n\t" + :"=r" (result) + :"m" (*p), "r" (i) + ); + return result; +} + +#endif diff --git a/root/gc/linux.c b/root/gc/linux.c new file mode 100644 index 00000000..5d50ad51 --- /dev/null +++ b/root/gc/linux.c @@ -0,0 +1,96 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include + + +/************************************* + * This is all necessary to get fd initialized at startup. + */ + +#define FDMAP 0 + +#if FDMAP +#include + +struct OS_INIT +{ + static int fd; + + OS_INIT(); +}; + +OS_INIT os_init; + +int OS_INIT::fd = 0; + +OS_INIT::OS_INIT() +{ + fd = open("/dev/zero", O_RDONLY); +} +#endif + +/*********************************** + * Map memory. + */ + +void *os_mem_map(unsigned nbytes) +{ void *p; + + errno = 0; +#if FDMAP + p = mmap(NULL, nbytes, PROT_READ | PROT_WRITE, MAP_PRIVATE, OS_INIT::fd, 0); +#else + p = mmap(NULL, nbytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); +#endif + return (p == MAP_FAILED) ? NULL : p; +} + +/*********************************** + * Commit memory. + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_commit(void *base, unsigned offset, unsigned nbytes) +{ + return 0; +} + + +/*********************************** + * Decommit memory. + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_decommit(void *base, unsigned offset, unsigned nbytes) +{ + return 0; +} + +/*********************************** + * Unmap memory allocated with os_mem_map(). + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_unmap(void *base, unsigned nbytes) +{ + return munmap(base, nbytes); +} + + + + diff --git a/root/gc/mscbitops.h b/root/gc/mscbitops.h new file mode 100644 index 00000000..bc84a3da --- /dev/null +++ b/root/gc/mscbitops.h @@ -0,0 +1,25 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Bit operations for MSC and I386 + +#ifndef MSCBITOPS_H +#define MSCBITOPS_H 1 + +inline int _inline_bsf(int w) +{ int index; + + index = 0; + while (!(w & 1)) + { index++; + w >>= 1; + } + return index; +} + +#endif diff --git a/root/gc/os.h b/root/gc/os.h new file mode 100644 index 00000000..4ee7d8f1 --- /dev/null +++ b/root/gc/os.h @@ -0,0 +1,25 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +// OS specific routines + +void *os_mem_map(unsigned nbytes); +int os_mem_commit(void *base, unsigned offset, unsigned nbytes); +int os_mem_decommit(void *base, unsigned offset, unsigned nbytes); +int os_mem_unmap(void *base, unsigned nbytes); + + +// Threading + +#if defined linux +#include +#else +typedef long pthread_t; +pthread_t pthread_self(); +#endif diff --git a/root/gc/testgc.c b/root/gc/testgc.c new file mode 100644 index 00000000..683c1f86 --- /dev/null +++ b/root/gc/testgc.c @@ -0,0 +1,300 @@ +/* Digital Mars DMDScript source code. + * Copyright (c) 2001-2007 by Digital Mars + * All Rights Reserved, written by Walter Bright + * http://www.digitalmars.com/dscript/cppscript.html + * + * This software is for evaluation purposes only. + * It may not be redistributed in binary or source form, + * incorporated into any product or program, + * or used for any purpose other than evaluating it. + * To purchase a license, + * see http://www.digitalmars.com/dscript/cpplicense.html + * + * Use at your own risk. There is no warranty, express or implied. + */ + +// GC tester program + +#include +#include +#include +#include + +#include "gc.h" + +void *stackbottom; + +void printStats(GC *gc) +{ + GCStats stats; + + gc->getStats(&stats); + printf("poolsize = x%x, usedsize = x%x, freelistsize = x%x, freeblocks = %d, pageblocks = %d\n", + stats.poolsize, stats.usedsize, stats.freelistsize, stats.freeblocks, stats.pageblocks); +} + +#define PERMUTE(key) (key + 1) + +void fill(void *p, unsigned key, unsigned size) +{ + unsigned i; + char *q = (char *)p; + + for (i = 0; i < size; i++) + { + key = PERMUTE(key); + q[i] = (char)key; + } +} + +void verify(void *p, unsigned key, unsigned size) +{ + unsigned i; + char *q = (char *)p; + + for (i = 0; i < size; i++) + { + key = PERMUTE(key); + assert(q[i] == (char)key); + } +} + +long desregs() +{ + return strlen("foo"); +} + +/* ---------------------------- */ + +void smoke() +{ + GC *gc; + + printf("--------------------------smoke()\n"); + + gc = new GC(); + delete gc; + + gc = new GC(); + gc->init(); + delete gc; + + gc = new GC(); + gc->init(); + gc->setStackBottom(stackbottom); + char *p = (char *)gc->malloc(10); + assert(p); + strcpy(p, "Hello!"); + char *p2 = gc->strdup(p); + printf("p2 = %x, '%s'\n", p2, p2); + int result = strcmp(p, p2); + assert(result == 0); + gc->strdup(p); + + printf("p = %x\n", p); + p = NULL; + gc->fullcollect(); + printStats(gc); + + delete gc; +} + +/* ---------------------------- */ + +void finalizer(void *p, void *dummy) +{ + (void)p; + (void)dummy; +} + +void smoke2() +{ + GC *gc; + int *p; + int i; + + #define SMOKE2_SIZE 100 + int *foo[SMOKE2_SIZE]; + + printf("--------------------------smoke2()\n"); + + gc = new GC(); + gc->init(); + gc->setStackBottom(stackbottom); + + for (i = 0; i < SMOKE2_SIZE; i++) + { + p = (int *)gc->calloc(i + 1, 500); + p[0] = i * 3; + foo[i] = p; + gc->setFinalizer(p, finalizer); + } + + for (i = 0; i < SMOKE2_SIZE; i += 2) + { + p = foo[i]; + if (p[0] != i * 3) + { + printf("p = %x, i = %d, p[0] = %d\n", p, i, p[0]); + fflush(stdout); + } + assert(p[0] == i * 3); + gc->free(p); + } + + p = NULL; + memset(foo, 0, sizeof(foo)); + + gc->fullcollect(); + printStats(gc); + + delete gc; +} + +/* ---------------------------- */ + +void smoke3() +{ + GC *gc; + int *p; + int i; + + printf("--------------------------smoke3()\n"); + + gc = new GC(); + gc->init(); + gc->setStackBottom(stackbottom); + + for (i = 0; i < 1000000; i++) +// for (i = 0; i < 1000; i++) + { + unsigned size = rand() % 2048; + p = (int *)gc->malloc(size); + memset(p, i, size); + + size = rand() % 2048; + p = (int *)gc->realloc(p, size); + memset(p, i + 1, size); + } + + p = NULL; + desregs(); + gc->fullcollect(); + printStats(gc); + + delete gc; +} + +/* ---------------------------- */ + +void smoke4() +{ + GC *gc; + int *p; + int i; + + printf("--------------------------smoke4()\n"); + + gc = new GC(); + gc->init(); + gc->setStackBottom(stackbottom); + + for (i = 0; i < 80000; i++) + { + unsigned size = i; + p = (int *)gc->malloc(size); + memset(p, i, size); + + size = rand() % 2048; + gc->check(p); + p = (int *)gc->realloc(p, size); + memset(p, i + 1, size); + } + + p = NULL; + desregs(); + gc->fullcollect(); + printStats(gc); + + delete gc; +} + +/* ---------------------------- */ + +void smoke5(GC *gc) +{ + char *p; + int i; + int j; + #define SMOKE5_SIZE 1000 + char *array[SMOKE5_SIZE]; + unsigned offset[SMOKE5_SIZE]; + + printf("--------------------------smoke5()\n"); + + memset(array, 0, sizeof(array)); + memset(offset, 0, sizeof(offset)); + + for (j = 0; j < 20; j++) + { + for (i = 0; i < 4000; i++) + { + unsigned size = (rand() % 2048) + 1; + unsigned index = rand() % SMOKE5_SIZE; + + //printf("index = %d, size = %d\n", index, size); + p = array[index] - offset[index]; + p = (char *)gc->realloc(p, size); + if (array[index]) + { unsigned s; + + //printf("\tverify = %d\n", p[0]); + s = offset[index]; + if (size < s) + s = size; + verify(p, index, s); + } + array[index] = p; + fill(p, index, size); + offset[index] = rand() % size; + array[index] += offset[index]; + + //printf("p[0] = %d\n", p[0]); + } + gc->fullcollect(); + } + + p = NULL; + memset(array, 0, sizeof(array)); + gc->fullcollect(); + printStats(gc); +} + +/* ---------------------------- */ + +/* ---------------------------- */ + +int main(int argc, char *argv[]) +{ + GC *gc; + + printf("GC test start\n"); + + (void)argc; + stackbottom = &argv; + + gc = new GC(); + gc->init(); + gc->setStackBottom(stackbottom); + + smoke(); + smoke2(); + smoke3(); + smoke4(); + smoke5(gc); + + delete gc; + + printf("GC test success\n"); + return EXIT_SUCCESS; +} diff --git a/root/gc/win32.c b/root/gc/win32.c new file mode 100644 index 00000000..ddff10d5 --- /dev/null +++ b/root/gc/win32.c @@ -0,0 +1,72 @@ +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include + +#include "os.h" + +/*********************************** + * Map memory. + */ + +void *os_mem_map(unsigned nbytes) +{ + return VirtualAlloc(NULL, nbytes, MEM_RESERVE, PAGE_READWRITE); +} + +/*********************************** + * Commit memory. + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_commit(void *base, unsigned offset, unsigned nbytes) +{ + void *p; + + p = VirtualAlloc((char *)base + offset, nbytes, MEM_COMMIT, PAGE_READWRITE); + return (p == NULL); +} + + +/*********************************** + * Decommit memory. + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_decommit(void *base, unsigned offset, unsigned nbytes) +{ + return VirtualFree((char *)base + offset, nbytes, MEM_DECOMMIT) == 0; +} + +/*********************************** + * Unmap memory allocated with os_mem_map(). + * Memory must have already been decommitted. + * Returns: + * 0 success + * !=0 failure + */ + +int os_mem_unmap(void *base, unsigned nbytes) +{ + (void)nbytes; + return VirtualFree(base, 0, MEM_RELEASE) == 0; +} + + +/******************************************** + */ + +pthread_t pthread_self() +{ + return (pthread_t) GetCurrentThreadId(); +} diff --git a/root/gnuc.c b/root/gnuc.c new file mode 100644 index 00000000..8f33d839 --- /dev/null +++ b/root/gnuc.c @@ -0,0 +1,55 @@ + +// Put functions in here missing from gnu C + +#include "gnuc.h" + +int memicmp(const char *s1, const char *s2, int n) +{ + int result = 0; + + for (int i = 0; i < n; i++) + { char c1 = s1[i]; + char c2 = s2[i]; + + result = c1 - c2; + if (result) + { + if ('A' <= c1 && c1 <= 'Z') + c1 += 'a' - 'A'; + if ('A' <= c2 && c2 <= 'Z') + c2 += 'a' - 'A'; + result = c1 - c2; + if (result) + break; + } + } + return result; +} + +int stricmp(const char *s1, const char *s2) +{ + int result = 0; + + for (;;) + { char c1 = *s1; + char c2 = *s2; + + result = c1 - c2; + if (result) + { + if ('A' <= c1 && c1 <= 'Z') + c1 += 'a' - 'A'; + if ('A' <= c2 && c2 <= 'Z') + c2 += 'a' - 'A'; + result = c1 - c2; + if (result) + break; + } + if (!c1) + break; + s1++; + s2++; + } + return result; +} + diff --git a/root/gnuc.h b/root/gnuc.h new file mode 100644 index 00000000..00c9851d --- /dev/null +++ b/root/gnuc.h @@ -0,0 +1,8 @@ + +#ifndef _GNUC_H +#define _GNUC_H 1 + +int memicmp(const char *s1, const char *s2, int n); +int stricmp(const char *s1, const char *s2); + +#endif diff --git a/root/lstring.c b/root/lstring.c new file mode 100644 index 00000000..a4e41ed5 --- /dev/null +++ b/root/lstring.c @@ -0,0 +1,63 @@ +// lstring.c + +// Copyright (c) 1999-2002 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include + +#include "dchar.h" +#include "rmem.h" +#include "lstring.h" + +#ifdef _MSC_VER // prevent compiler internal crash +Lstring Lstring::zero; +#else +Lstring Lstring::zero = LSTRING_EMPTY(); +#endif + +Lstring *Lstring::ctor(const dchar *p, unsigned length) +{ + Lstring *s; + + s = alloc(length); + memcpy(s->string, p, length * sizeof(dchar)); + return s; +} + +Lstring *Lstring::alloc(unsigned length) +{ + Lstring *s; + + s = (Lstring *)mem.malloc(size(length)); + s->length = length; + s->string[length] = 0; + return s; +} + +Lstring *Lstring::append(const Lstring *s) +{ + Lstring *t; + + if (!s->length) + return this; + t = alloc(length + s->length); + memcpy(t->string, string, length * sizeof(dchar)); + memcpy(t->string + length, s->string, s->length * sizeof(dchar)); + return t; +} + +Lstring *Lstring::substring(int start, int end) +{ + Lstring *t; + + if (start == end) + return &zero; + t = alloc(end - start); + memcpy(t->string, string + start, (end - start) * sizeof(dchar)); + return t; +} diff --git a/root/lstring.h b/root/lstring.h new file mode 100644 index 00000000..17a8e447 --- /dev/null +++ b/root/lstring.h @@ -0,0 +1,72 @@ + +// lstring.h +// length-prefixed strings + +// Copyright (c) 1999-2002 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef LSTRING_H +#define LSTRING_H 1 + +#include "dchar.h" + +struct Lstring +{ + unsigned length; + + // Disable warning about nonstandard extension + #pragma warning (disable : 4200) + dchar string[]; + + static Lstring zero; // 0 length string + + // No constructors because we want to be able to statically + // initialize Lstring's, and Lstrings are of variable size. + + #if M_UNICODE + #define LSTRING(p,length) { length, L##p } + #else + #define LSTRING(p,length) { length, p } + #endif + +#if __GNUC__ + #define LSTRING_EMPTY() { 0 } +#else + #define LSTRING_EMPTY() LSTRING("", 0) +#endif + + static Lstring *ctor(const dchar *p) { return ctor(p, Dchar::len(p)); } + static Lstring *ctor(const dchar *p, unsigned length); + static unsigned size(unsigned length) { return sizeof(Lstring) + (length + 1) * sizeof(dchar); } + static Lstring *alloc(unsigned length); + Lstring *clone(); + + unsigned len() { return length; } + + dchar *toDchars() { return string; } + + hash_t hash() { return Dchar::calcHash(string, length); } + hash_t ihash() { return Dchar::icalcHash(string, length); } + + static int cmp(const Lstring *s1, const Lstring *s2) + { + int c = s2->length - s1->length; + return c ? c : Dchar::memcmp(s1->string, s2->string, s1->length); + } + + static int icmp(const Lstring *s1, const Lstring *s2) + { + int c = s2->length - s1->length; + return c ? c : Dchar::memicmp(s1->string, s2->string, s1->length); + } + + Lstring *append(const Lstring *s); + Lstring *substring(int start, int end); +}; + +#endif diff --git a/root/man.c b/root/man.c new file mode 100644 index 00000000..3770aa96 --- /dev/null +++ b/root/man.c @@ -0,0 +1,100 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2008-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if _WIN32 + +#include + +#pragma comment(lib,"shell32.lib") + +void browse(const char *url) +{ + ShellExecute(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL); +} + +#endif + +#if linux || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + +#include +#include +#include + +void browse(const char *url) +{ + pid_t childpid; + const char *args[3]; + + const char *browser = getenv("BROWSER"); + if (browser) + browser = strdup(browser); + else + browser = "x-www-browser"; + + args[0] = browser; + args[1] = url; + args[2] = NULL; + + childpid = fork(); + if (childpid == 0) + { + execvp(args[0], (char**)args); + perror(args[0]); // failed to execute + return; + } +} + +#endif + +#if __APPLE__ + +#include +#include +#include + +void browse(const char *url) +{ + pid_t childpid; + const char *args[5]; + + char *browser = getenv("BROWSER"); + if (browser) + { browser = strdup(browser); + args[0] = browser; + args[1] = url; + args[2] = NULL; + } + else + { + //browser = "/Applications/Safari.app/Contents/MacOS/Safari"; + args[0] = "open"; + args[1] = "-a"; + args[2] = "/Applications/Safari.app"; + args[3] = url; + args[4] = NULL; + } + + childpid = fork(); + if (childpid == 0) + { + execvp(args[0], (char**)args); + perror(args[0]); // failed to execute + return; + } +} + +#endif + + diff --git a/root/port.c b/root/port.c new file mode 100644 index 00000000..59698cba --- /dev/null +++ b/root/port.c @@ -0,0 +1,792 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#include "port.h" +#if __DMC__ +#include +#include +#include +#include +#include +#include + +double Port::nan = NAN; +double Port::infinity = INFINITY; +double Port::dbl_max = DBL_MAX; +double Port::dbl_min = DBL_MIN; +long double Port::ldbl_max = LDBL_MAX; + +int Port::isNan(double r) +{ + return ::isnan(r); +} + +int Port::isNan(long double r) +{ + return ::isnan(r); +} + +int Port::isSignallingNan(double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 51 of 0..63 for 64 bit doubles. + */ + return isNan(r) && !((((unsigned char*)&r)[6]) & 8); +} + +int Port::isSignallingNan(long double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 62 of 0..79 for 80 bit reals. + */ + return isNan(r) && !((((unsigned char*)&r)[7]) & 0x40); +} + +int Port::isFinite(double r) +{ + return ::isfinite(r); +} + +int Port::isInfinity(double r) +{ + return (::fpclassify(r) == FP_INFINITE); +} + +int Port::Signbit(double r) +{ + return ::signbit(r); +} + +double Port::floor(double d) +{ + return ::floor(d); +} + +double Port::pow(double x, double y) +{ + return ::pow(x, y); +} + +long double Port::fmodl(long double x, long double y) +{ + return ::fmodl(x, y); +} + +unsigned long long Port::strtoull(const char *p, char **pend, int base) +{ + return ::strtoull(p, pend, base); +} + +char *Port::ull_to_string(char *buffer, ulonglong ull) +{ + sprintf(buffer, "%llu", ull); + return buffer; +} + +wchar_t *Port::ull_to_string(wchar_t *buffer, ulonglong ull) +{ + swprintf(buffer, sizeof(ulonglong) * 3 + 1, L"%llu", ull); + return buffer; +} + +double Port::ull_to_double(ulonglong ull) +{ + return (double) ull; +} + +const char *Port::list_separator() +{ + // LOCALE_SLIST for Windows + return ","; +} + +const wchar_t *Port::wlist_separator() +{ + // LOCALE_SLIST for Windows + return L","; +} + +char *Port::strupr(char *s) +{ + return ::strupr(s); +} + +#endif + +#if _MSC_VER + +// Disable useless warnings about unreferenced functions +#pragma warning (disable : 4514) + +#include +#include +#include +#include +#include +#include +#include +#include // for std::numeric_limits + +static unsigned long nanarray[2]= { 0xFFFFFFFF, 0x7FFFFFFF }; +//static unsigned long nanarray[2] = {0,0x7FF80000 }; +double Port::nan = (*(double *)nanarray); + +//static unsigned long infinityarray[2] = {0,0x7FF00000 }; +static double zero = 0; +double Port::infinity = 1 / zero; + +double Port::dbl_max = DBL_MAX; +double Port::dbl_min = DBL_MIN; +long double Port::ldbl_max = LDBL_MAX; + +struct PortInitializer +{ + PortInitializer(); +}; + +static PortInitializer portinitializer; + +PortInitializer::PortInitializer() +{ + Port::infinity = std::numeric_limits::infinity(); +} + +int Port::isNan(double r) +{ + return ::_isnan(r); +} + +int Port::isNan(long double r) +{ + return ::_isnan(r); +} + +int Port::isSignallingNan(double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 51 of 0..63 for 64 bit doubles. + */ + return isNan(r) && !((((unsigned char*)&r)[6]) & 8); +} + +int Port::isSignallingNan(long double r) +{ + /* MSVC doesn't have 80 bit long doubles + */ + return isSignallingNan((double) r); +} + +int Port::isFinite(double r) +{ + return ::_finite(r); +} + +int Port::isInfinity(double r) +{ + return (::_fpclass(r) & (_FPCLASS_NINF | _FPCLASS_PINF)); +} + +int Port::Signbit(double r) +{ + return (long)(((long *)&(r))[1] & 0x80000000); +} + +double Port::floor(double d) +{ + return ::floor(d); +} + +double Port::pow(double x, double y) +{ + if (y == 0) + return 1; // even if x is NAN + return ::pow(x, y); +} + +long double Port::fmodl(long double x, long double y) +{ + return ::fmodl(x, y); +} + +unsigned _int64 Port::strtoull(const char *p, char **pend, int base) +{ + unsigned _int64 number = 0; + int c; + int error; +#ifndef ULLONG_MAX + #define ULLONG_MAX ((unsigned _int64)~0I64) +#endif + + while (isspace((unsigned char)*p)) /* skip leading white space */ + p++; + if (*p == '+') + p++; + switch (base) + { case 0: + base = 10; /* assume decimal base */ + if (*p == '0') + { base = 8; /* could be octal */ + p++; + switch (*p) + { case 'x': + case 'X': + base = 16; /* hex */ + p++; + break; +#if BINARY + case 'b': + case 'B': + base = 2; /* binary */ + p++; + break; +#endif + } + } + break; + case 16: /* skip over '0x' and '0X' */ + if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) + p += 2; + break; +#if BINARY + case 2: /* skip over '0b' and '0B' */ + if (*p == '0' && (p[1] == 'b' || p[1] == 'B')) + p += 2; + break; +#endif + } + error = 0; + for (;;) + { c = *p; + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c = (c & ~0x20) - ('A' - 10); + else /* unrecognized character */ + break; + if (c >= base) /* not in number base */ + break; + if ((ULLONG_MAX - c) / base < number) + error = 1; + number = number * base + c; + p++; + } + if (pend) + *pend = (char *)p; + if (error) + { number = ULLONG_MAX; + errno = ERANGE; + } + return number; +} + +char *Port::ull_to_string(char *buffer, ulonglong ull) +{ + _ui64toa(ull, buffer, 10); + return buffer; +} + +wchar_t *Port::ull_to_string(wchar_t *buffer, ulonglong ull) +{ + _ui64tow(ull, buffer, 10); + return buffer; +} + +double Port::ull_to_double(ulonglong ull) +{ double d; + + if ((__int64) ull < 0) + { + // MSVC doesn't implement the conversion + d = (double) (__int64)(ull - 0x8000000000000000i64); + d += (double)(signed __int64)(0x7FFFFFFFFFFFFFFFi64) + 1.0; + } + else + d = (double)(__int64)ull; + return d; +} + +const char *Port::list_separator() +{ + // LOCALE_SLIST for Windows + return ","; +} + +const wchar_t *Port::wlist_separator() +{ + // LOCALE_SLIST for Windows + return L","; +} + +char *Port::strupr(char *s) +{ + return ::strupr(s); +} + +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ + +#include +#if linux +#include +#include +#endif +#if __FreeBSD__ && __i386__ +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +static double zero = 0; +double Port::nan = copysign(NAN, 1.0); +double Port::infinity = 1 / zero; +double Port::dbl_max = 1.7976931348623157e308; +double Port::dbl_min = 5e-324; +long double Port::ldbl_max = LDBL_MAX; + +struct PortInitializer +{ + PortInitializer(); +}; + +static PortInitializer portinitializer; + +PortInitializer::PortInitializer() +{ + assert(!signbit(Port::nan)); + +#if __FreeBSD__ && __i386__ + // LDBL_MAX comes out as infinity. Fix. + static unsigned char x[sizeof(long double)] = + { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F }; + Port::ldbl_max = *(long double *)&x[0]; + // FreeBSD defaults to double precision. Switch to extended precision. + fpsetprec(FP_PE); +#endif +} + +int Port::isNan(double r) +{ +#if __APPLE__ + return __inline_isnan(r); +#elif __OpenBSD__ + return isnan(r); +#else + #undef isnan + return ::isnan(r); +#endif +} + +int Port::isNan(long double r) +{ +#if __APPLE__ + return __inline_isnan(r); +#elif __OpenBSD__ + return isnan(r); +#else + #undef isnan + return ::isnan(r); +#endif +} + +int Port::isSignallingNan(double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 51 of 0..63 for 64 bit doubles. + */ + return isNan(r) && !((((unsigned char*)&r)[6]) & 8); +} + +int Port::isSignallingNan(long double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 62 of 0..79 for 80 bit reals. + */ + return isNan(r) && !((((unsigned char*)&r)[7]) & 0x40); +} + +#undef isfinite +int Port::isFinite(double r) +{ + return ::finite(r); +} + +int Port::isInfinity(double r) +{ +#if __APPLE__ + return fpclassify(r) == FP_INFINITE; +#elif __OpenBSD__ + return isinf(r); +#else + #undef isinf + return ::isinf(r); +#endif +} + +#undef signbit +int Port::Signbit(double r) +{ + union { double d; long long ll; } u; + u.d = r; + return u.ll < 0; +} + +double Port::floor(double d) +{ + return ::floor(d); +} + +double Port::pow(double x, double y) +{ + return ::pow(x, y); +} + +long double Port::fmodl(long double x, long double y) +{ +#if __FreeBSD__ || __OpenBSD__ + return ::fmod(x, y); // hack for now, fix later +#else + return ::fmodl(x, y); +#endif +} + +unsigned long long Port::strtoull(const char *p, char **pend, int base) +{ + return ::strtoull(p, pend, base); +} + +char *Port::ull_to_string(char *buffer, ulonglong ull) +{ + sprintf(buffer, "%llu", ull); + return buffer; +} + +wchar_t *Port::ull_to_string(wchar_t *buffer, ulonglong ull) +{ +#if __OpenBSD__ + assert(0); +#else + swprintf(buffer, sizeof(ulonglong) * 3 + 1, L"%llu", ull); +#endif + return buffer; +} + +double Port::ull_to_double(ulonglong ull) +{ + return (double) ull; +} + +const char *Port::list_separator() +{ + return ","; +} + +const wchar_t *Port::wlist_separator() +{ + return L","; +} + +char *Port::strupr(char *s) +{ + char *t = s; + + while (*s) + { + *s = toupper(*s); + s++; + } + + return t; +} + +#endif + +#if __sun&&__SVR4 + +#define __C99FEATURES__ 1 // Needed on Solaris for NaN and more +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static double zero = 0; +double Port::nan = NAN; +double Port::infinity = 1 / zero; +double Port::dbl_max = 1.7976931348623157e308; +double Port::dbl_min = 5e-324; +long double Port::ldbl_max = LDBL_MAX; + +struct PortInitializer +{ + PortInitializer(); +}; + +static PortInitializer portinitializer; + +PortInitializer::PortInitializer() +{ + // gcc nan's have the sign bit set by default, so turn it off + // Need the volatile to prevent gcc from doing incorrect + // constant folding. + volatile long double foo; + foo = NAN; + if (signbit(foo)) // signbit sometimes, not always, set + foo = -foo; // turn off sign bit + Port::nan = foo; +} + +int Port::isNan(double r) +{ + return isnan(r); +} + +int Port::isNan(long double r) +{ + return isnan(r); +} + +int Port::isSignallingNan(double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 51 of 0..63 for 64 bit doubles. + */ + return isNan(r) && !((((unsigned char*)&r)[6]) & 8); +} + +int Port::isSignallingNan(long double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 62 of 0..79 for 80 bit reals. + */ + return isNan(r) && !((((unsigned char*)&r)[7]) & 0x40); +} + +#undef isfinite +int Port::isFinite(double r) +{ + return finite(r); +} + +int Port::isInfinity(double r) +{ + return isinf(r); +} + +#undef signbit +int Port::Signbit(double r) +{ + return (long)(((long *)&r)[1] & 0x80000000); +} + +double Port::floor(double d) +{ + return ::floor(d); +} + +double Port::pow(double x, double y) +{ + return ::pow(x, y); +} + +unsigned long long Port::strtoull(const char *p, char **pend, int base) +{ + return ::strtoull(p, pend, base); +} + +char *Port::ull_to_string(char *buffer, ulonglong ull) +{ + sprintf(buffer, "%llu", ull); + return buffer; +} + +wchar_t *Port::ull_to_string(wchar_t *buffer, ulonglong ull) +{ + swprintf(buffer, sizeof(ulonglong) * 3 + 1, L"%llu", ull); + return buffer; +} + +double Port::ull_to_double(ulonglong ull) +{ + return (double) ull; +} + +const char *Port::list_separator() +{ + return ","; +} + +const wchar_t *Port::wlist_separator() +{ + return L","; +} + +char *Port::strupr(char *s) +{ + char *t = s; + + while (*s) + { + *s = toupper(*s); + s++; + } + + return t; +} + +#endif + +#if IN_GCC + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static double zero = 0; +double Port::nan = NAN; +double Port::infinity = 1 / zero; +double Port::dbl_max = 1.7976931348623157e308; +double Port::dbl_min = 5e-324; +long double Port::ldbl_max = LDBL_MAX; + +#include "d-gcc-real.h" +extern "C" bool real_isnan (const real_t *); + +struct PortInitializer +{ + PortInitializer(); +}; + +static PortInitializer portinitializer; + +PortInitializer::PortInitializer() +{ + Port::infinity = real_t::getinfinity(); + Port::nan = real_t::getnan(real_t::LongDouble); +} + +#undef isnan +int Port::isNan(double r) +{ +#if __APPLE__ + return __inline_isnan(r); +#else + return ::isnan(r); +#endif +} + +int Port::isNan(long double r) +{ + return real_isnan(&r); +} + +int Port::isSignallingNan(double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 51 of 0..63 for 64 bit doubles. + */ + return isNan(r) && !((((unsigned char*)&r)[6]) & 8); +} + +int Port::isSignallingNan(long double r) +{ + /* A signalling NaN is a NaN with 0 as the most significant bit of + * its significand, which is bit 62 of 0..79 for 80 bit reals. + */ + return isNan(r) && !((((unsigned char*)&r)[7]) & 0x40); +} + +#undef isfinite +int Port::isFinite(double r) +{ + return ::finite(r); +} + +#undef isinf +int Port::isInfinity(double r) +{ + return ::isinf(r); +} + +#undef signbit +int Port::Signbit(double r) +{ + return (long)(((long *)&r)[1] & 0x80000000); +} + +double Port::floor(double d) +{ + return ::floor(d); +} + +double Port::pow(double x, double y) +{ + return ::pow(x, y); +} + +unsigned long long Port::strtoull(const char *p, char **pend, int base) +{ + return ::strtoull(p, pend, base); +} + +char *Port::ull_to_string(char *buffer, ulonglong ull) +{ + sprintf(buffer, "%llu", ull); + return buffer; +} + +wchar_t *Port::ull_to_string(wchar_t *buffer, ulonglong ull) +{ + swprintf(buffer, L"%llu", ull); + return buffer; +} + +double Port::ull_to_double(ulonglong ull) +{ + return (double) ull; +} + +const char *Port::list_separator() +{ + return ","; +} + +const wchar_t *Port::wlist_separator() +{ + return L","; +} + +char *Port::strupr(char *s) +{ + char *t = s; + + while (*s) + { + *s = toupper(*s); + s++; + } + + return t; +} + +#endif + diff --git a/root/port.h b/root/port.h new file mode 100644 index 00000000..40c07bb9 --- /dev/null +++ b/root/port.h @@ -0,0 +1,81 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#ifndef PORT_H +#define PORT_H + +// Portable wrapper around compiler/system specific things. +// The idea is to minimize #ifdef's in the app code. + +#ifndef TYPEDEFS +#define TYPEDEFS + +#include + +#if _MSC_VER +typedef __int64 longlong; +typedef unsigned __int64 ulonglong; + +// According to VC 8.0 docs, long double is the same as double +#define strtold strtod +#define strtof strtod + +#else +typedef long long longlong; +typedef unsigned long long ulonglong; +#endif + +#endif + +typedef double d_time; + +struct Port +{ + static double nan; + static double infinity; + static double dbl_max; + static double dbl_min; + static long double ldbl_max; + +#if __OpenBSD__ +#elif __GNUC__ + // These conflict with macros in math.h, should rename them + #undef isnan + #undef isfinite + #undef isinfinity + #undef signbit +#endif + static int isNan(double); + static int isNan(long double); + + static int isSignallingNan(double); + static int isSignallingNan(long double); + + static int isFinite(double); + static int isInfinity(double); + static int Signbit(double); + + static double floor(double); + static double pow(double x, double y); + + static long double fmodl(long double x, long double y); + + static ulonglong strtoull(const char *p, char **pend, int base); + + static char *ull_to_string(char *buffer, ulonglong ull); + static wchar_t *ull_to_string(wchar_t *buffer, ulonglong ull); + + // Convert ulonglong to double + static double ull_to_double(ulonglong ull); + + // Get locale-dependent list separator + static const char *list_separator(); + static const wchar_t *wlist_separator(); + + static char *strupr(char *); +}; + +#endif diff --git a/root/response.c b/root/response.c new file mode 100644 index 00000000..2096f11b --- /dev/null +++ b/root/response.c @@ -0,0 +1,290 @@ +// Copyright (C) 1990-1998 by Symantec +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved +// http://www.digitalmars.com +// Written by Walter Bright +/* + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +#include +#include +#include +#include +#include + +#if _WIN32 +#include +#include +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#include +#include +#include +#include +#endif + +/********************************* + * #include + * int response_expand(int *pargc,char ***pargv); + * + * Expand any response files in command line. + * Response files are arguments that look like: + * @NAME + * The name is first searched for in the environment. If it is not + * there, it is searched for as a file name. + * Arguments are separated by spaces, tabs, or newlines. These can be + * imbedded within arguments by enclosing the argument in '' or "". + * Recursively expands nested response files. + * + * To use, put the line: + * response_expand(&argc,&argv); + * as the first executable statement in main(int argc, char **argv). + * argc and argv are adjusted to be the new command line arguments + * after response file expansion. + * + * Digital Mars's MAKE program can be notified that a program can accept + * long command lines via environment variables by preceding the rule + * line for the program with a *. + * + * Returns: + * 0 success + * !=0 failure (argc, argv unchanged) + */ + +struct Narg +{ + int argc; /* arg count */ + int argvmax; /* dimension of nargv[] */ + char **argv; +}; + +static int addargp(struct Narg *n, char *p) +{ + /* The 2 is to always allow room for a NULL argp at the end */ + if (n->argc + 2 > n->argvmax) + { + n->argvmax = n->argc + 2; + char **ap = n->argv; + ap = (char **) realloc(ap,n->argvmax * sizeof(char *)); + if (!ap) + { if (n->argv) + free(n->argv); + memset(n, 0, sizeof(*n)); + return 1; + } + n->argv = ap; + } + n->argv[n->argc++] = p; + return 0; +} + +int response_expand(int *pargc, char ***pargv) +{ + struct Narg n; + int i; + char *cp; + int recurse = 0; + + n.argc = 0; + n.argvmax = 0; /* dimension of n.argv[] */ + n.argv = NULL; + for(i=0; i<*pargc; ++i) + { + cp = (*pargv)[i]; + if (*cp == '@') + { + char *buffer; + char *bufend; + char *p; + + cp++; + p = getenv(cp); + if (p) + { + buffer = strdup(p); + if (!buffer) + goto noexpand; + bufend = buffer + strlen(buffer); + } + else + { + long length; + int fd; + int nread; + size_t len; + +#if __DMC__ + length = filesize(cp); +#else + struct stat statbuf; + if (stat(cp, &statbuf)) + goto noexpand; + length = statbuf.st_size; +#endif + if (length & 0xF0000000) /* error or file too big */ + goto noexpand; + len = length; + buffer = (char *)malloc(len + 1); + if (!buffer) + goto noexpand; + bufend = &buffer[len]; + /* Read file into buffer */ +#if _WIN32 + fd = _open(cp,O_RDONLY|O_BINARY); +#else + fd = open(cp,O_RDONLY); +#endif + if (fd == -1) + goto noexpand; + nread = read(fd,buffer,len); + close(fd); + + if (nread != len) + goto noexpand; + } + + // The logic of this should match that in setargv() + + for (p = buffer; p < bufend; p++) + { + char *d; + char c,lastc; + unsigned char instring; + int num_slashes,non_slashes; + + switch (*p) + { + case 26: /* ^Z marks end of file */ + goto L2; + + case 0xD: + case 0: + case ' ': + case '\t': + case '\n': + continue; // scan to start of argument + + case '@': + recurse = 1; + default: /* start of new argument */ + if (addargp(&n,p)) + goto noexpand; + instring = 0; + c = 0; + num_slashes = 0; + for (d = p; 1; p++) + { + lastc = c; + if (p >= bufend) + goto Lend; + c = *p; + switch (c) + { + case '"': + /* + Yes this looks strange,but this is so that we are + MS Compatible, tests have shown that: + \\\\"foo bar" gets passed as \\foo bar + \\\\foo gets passed as \\\\foo + \\\"foo gets passed as \"foo + and \"foo gets passed as "foo in VC! + */ + non_slashes = num_slashes % 2; + num_slashes = num_slashes / 2; + for (; num_slashes > 0; num_slashes--) + { + d--; + *d = '\0'; + } + + if (non_slashes) + { + *(d-1) = c; + } + else + { + instring ^= 1; + } + break; + case 26: + Lend: + *d = 0; // terminate argument + goto L2; + + case 0xD: // CR + c = lastc; + continue; // ignore + + case '@': + recurse = 1; + goto Ladd; + + case ' ': + case '\t': + if (!instring) + { + case '\n': + case 0: + *d = 0; // terminate argument + goto Lnextarg; + } + default: + Ladd: + if (c == '\\') + num_slashes++; + else + num_slashes = 0; + *d++ = c; + break; + } +#ifdef _MBCS + if (_istlead (c)) { + *d++ = *++p; + if (*(d - 1) == '\0') { + d--; + goto Lnextarg; + } + } +#endif + } + break; + } + Lnextarg: + ; + } + L2: + ; + } + else if (addargp(&n,(*pargv)[i])) + goto noexpand; + } + if (n.argvmax == 0) + { + n.argvmax = 1; + n.argv = (char **) calloc(n.argvmax, sizeof(char *)); + if (!n.argv) + return 1; + } + else + n.argv[n.argc] = NULL; + if (recurse) + { + /* Recursively expand @filename */ + if (response_expand(&n.argc,&n.argv)) + goto noexpand; + } + *pargc = n.argc; + *pargv = n.argv; + return 0; /* success */ + +noexpand: /* error */ + free(n.argv); + /* BUG: any file buffers are not free'd */ + return 1; +} diff --git a/root/rmem.c b/root/rmem.c new file mode 100644 index 00000000..2504ab93 --- /dev/null +++ b/root/rmem.c @@ -0,0 +1,155 @@ + +/* Copyright (c) 2000 Digital Mars */ +/* All Rights Reserved */ + +#include +#include +#include + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include "../root/rmem.h" +#else +#include "rmem.h" +#endif + +/* This implementation of the storage allocator uses the standard C allocation package. + */ + +Mem mem; + +void Mem::init() +{ +} + +char *Mem::strdup(const char *s) +{ + char *p; + + if (s) + { + p = ::strdup(s); + if (p) + return p; + error(); + } + return NULL; +} + +void *Mem::malloc(size_t size) +{ void *p; + + if (!size) + p = NULL; + else + { + p = ::malloc(size); + if (!p) + error(); + } + return p; +} + +void *Mem::calloc(size_t size, size_t n) +{ void *p; + + if (!size || !n) + p = NULL; + else + { + p = ::calloc(size, n); + if (!p) + error(); + } + return p; +} + +void *Mem::realloc(void *p, size_t size) +{ + if (!size) + { if (p) + { ::free(p); + p = NULL; + } + } + else if (!p) + { + p = ::malloc(size); + if (!p) + error(); + } + else + { + void *psave = p; + p = ::realloc(psave, size); + if (!p) + { free(psave); + error(); + } + } + return p; +} + +void Mem::free(void *p) +{ + if (p) + ::free(p); +} + +void *Mem::mallocdup(void *o, size_t size) +{ void *p; + + if (!size) + p = NULL; + else + { + p = ::malloc(size); + if (!p) + error(); + else + memcpy(p,o,size); + } + return p; +} + +void Mem::error() +{ + printf("Error: out of memory\n"); + exit(EXIT_FAILURE); +} + +void Mem::fullcollect() +{ +} + +void Mem::mark(void *pointer) +{ + (void) pointer; // necessary for VC /W4 +} + +void Mem::setStackBottom(void *bottom) +{ +} + +void Mem::addroots(char* pStart, char* pEnd) +{ +} + + +/* =================================================== */ + +void * operator new(size_t m_size) +{ + void *p = malloc(m_size); + if (p) + return p; + printf("Error: out of memory\n"); + exit(EXIT_FAILURE); + return p; +} + +void operator delete(void *p) +{ + free(p); +} + + diff --git a/root/rmem.h b/root/rmem.h new file mode 100644 index 00000000..d22145a9 --- /dev/null +++ b/root/rmem.h @@ -0,0 +1,51 @@ +// Copyright (C) 2000-2011 by Digital Mars +// All Rights Reserved + +#ifndef ROOT_MEM_H +#define ROOT_MEM_H + +#include // for size_t + +typedef void (*FINALIZERPROC)(void* pObj, void* pClientData); + +struct GC; // thread specific allocator + +struct Mem +{ + GC *gc; // pointer to our thread specific allocator + Mem() { gc = NULL; } + + void init(); + + // Derive from Mem to get these storage allocators instead of global new/delete + void * operator new(size_t m_size); + void * operator new(size_t m_size, Mem *mem); + void * operator new(size_t m_size, GC *gc); + void operator delete(void *p); + + void * operator new[](size_t m_size); + void operator delete[](void *p); + + char *strdup(const char *s); + void *malloc(size_t size); + void *malloc_uncollectable(size_t size); + void *calloc(size_t size, size_t n); + void *realloc(void *p, size_t size); + void free(void *p); + void free_uncollectable(void *p); + void *mallocdup(void *o, size_t size); + void error(); + void check(void *p); // validate pointer + void fullcollect(); // do full garbage collection + void fullcollectNoStack(); // do full garbage collection, no scan stack + void mark(void *pointer); + void addroots(char* pStart, char* pEnd); + void removeroots(char* pStart); + void setFinalizer(void* pObj, FINALIZERPROC pFn, void* pClientData); + void setStackBottom(void *bottom); + GC *getThreadGC(); // get apartment allocator for this thread +}; + +extern Mem mem; + +#endif /* ROOT_MEM_H */ diff --git a/root/root.c b/root/root.c new file mode 100644 index 00000000..f0d02426 --- /dev/null +++ b/root/root.c @@ -0,0 +1,2089 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#define POSIX (linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4) + +#include +#include +#include +#include +#include +#include +#include + +#if (defined (__SVR4) && defined (__sun)) +#include +#endif + +#if _MSC_VER ||__MINGW32__ +#include +#include +#endif + +#if _WIN32 +#include +#include +#include +#endif + +#if POSIX +#include +#include +#include +#include +#include +#include +#endif + +#include "port.h" +#include "root.h" +#include "dchar.h" +#include "rmem.h" + +#if 0 //__SC__ //def DEBUG +extern "C" void __cdecl _assert(void *e, void *f, unsigned line) +{ + printf("Assert('%s','%s',%d)\n",e,f,line); + fflush(stdout); + *(char *)0 = 0; +} +#endif + + +/************************************* + * Convert wchar string to ascii string. + */ + +char *wchar2ascii(wchar_t *us) +{ + return wchar2ascii(us, wcslen(us)); +} + +char *wchar2ascii(wchar_t *us, unsigned len) +{ + unsigned i; + char *p; + + p = (char *)mem.malloc(len + 1); + for (i = 0; i <= len; i++) + p[i] = (char) us[i]; + return p; +} + +int wcharIsAscii(wchar_t *us) +{ + return wcharIsAscii(us, wcslen(us)); +} + +int wcharIsAscii(wchar_t *us, unsigned len) +{ + unsigned i; + + for (i = 0; i <= len; i++) + { + if (us[i] & ~0xFF) // if high bits set + return 0; // it's not ascii + } + return 1; +} + + +/*********************************** + * Compare length-prefixed strings (bstr). + */ + +int bstrcmp(unsigned char *b1, unsigned char *b2) +{ + return (*b1 == *b2 && memcmp(b1 + 1, b2 + 1, *b2) == 0) ? 0 : 1; +} + +/*************************************** + * Convert bstr into a malloc'd string. + */ + +char *bstr2str(unsigned char *b) +{ + char *s; + unsigned len; + + len = *b; + s = (char *) mem.malloc(len + 1); + s[len] = 0; + return (char *)memcpy(s,b + 1,len); +} + +/************************************** + * Print error message and exit. + */ + +void error(const char *format, ...) +{ + va_list ap; + + va_start(ap, format); + printf("Error: "); + vprintf(format, ap); + va_end( ap ); + printf("\n"); + fflush(stdout); + + exit(EXIT_FAILURE); +} + +#if M_UNICODE +void error(const dchar *format, ...) +{ + va_list ap; + + va_start(ap, format); + printf("Error: "); + vwprintf(format, ap); + va_end( ap ); + printf("\n"); + fflush(stdout); + + exit(EXIT_FAILURE); +} +#endif + +void error_mem() +{ + error("out of memory"); +} + +/************************************** + * Print warning message. + */ + +void warning(const char *format, ...) +{ + va_list ap; + + va_start(ap, format); + printf("Warning: "); + vprintf(format, ap); + va_end( ap ); + printf("\n"); + fflush(stdout); +} + +/****************************** Object ********************************/ + +int Object::equals(Object *o) +{ + return o == this; +} + +hash_t Object::hashCode() +{ + return (hash_t) this; +} + +int Object::compare(Object *obj) +{ + return this - obj; +} + +void Object::print() +{ + printf("%s %p\n", toChars(), this); +} + +char *Object::toChars() +{ + return (char *)"Object"; +} + +dchar *Object::toDchars() +{ +#if M_UNICODE + return L"Object"; +#else + return toChars(); +#endif +} + +int Object::dyncast() +{ + return 0; +} + +void Object::toBuffer(OutBuffer *b) +{ + b->writestring("Object"); +} + +void Object::mark() +{ +} + +/****************************** String ********************************/ + +String::String(char *str, int ref) +{ + this->str = ref ? str : mem.strdup(str); + this->ref = ref; +} + +String::~String() +{ + mem.free(str); +} + +void String::mark() +{ + mem.mark(str); +} + +hash_t String::calcHash(const char *str, size_t len) +{ + hash_t hash = 0; + + for (;;) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(uint8_t *)str; + return hash; + + case 2: + hash *= 37; + hash += *(uint16_t *)str; + return hash; + + case 3: + hash *= 37; + hash += (*(uint16_t *)str << 8) + + ((uint8_t *)str)[2]; + return hash; + + default: + hash *= 37; + hash += *(uint32_t *)str; + str += 4; + len -= 4; + break; + } + } +} + +hash_t String::calcHash(const char *str) +{ + return calcHash(str, strlen(str)); +} + +hash_t String::hashCode() +{ + return calcHash(str, strlen(str)); +} + +unsigned String::len() +{ + return strlen(str); +} + +int String::equals(Object *obj) +{ + return strcmp(str,((String *)obj)->str) == 0; +} + +int String::compare(Object *obj) +{ + return strcmp(str,((String *)obj)->str); +} + +char *String::toChars() +{ + return str; +} + +void String::print() +{ + printf("String '%s'\n",str); +} + + +/****************************** FileName ********************************/ + +FileName::FileName(char *str, int ref) + : String(str,ref) +{ +} + +char *FileName::combine(const char *path, const char *name) +{ char *f; + size_t pathlen; + size_t namelen; + + if (!path || !*path) + return (char *)name; + pathlen = strlen(path); + namelen = strlen(name); + f = (char *)mem.malloc(pathlen + 1 + namelen + 1); + memcpy(f, path, pathlen); +#if POSIX + if (path[pathlen - 1] != '/') + { f[pathlen] = '/'; + pathlen++; + } +#elif _WIN32 + if (path[pathlen - 1] != '\\' && + path[pathlen - 1] != '/' && + path[pathlen - 1] != ':') + { f[pathlen] = '\\'; + pathlen++; + } +#else + assert(0); +#endif + memcpy(f + pathlen, name, namelen + 1); + return f; +} + +FileName::FileName(char *path, char *name) + : String(combine(path,name),1) +{ +} + +// Split a path into an Array of paths +Strings *FileName::splitPath(const char *path) +{ + char c = 0; // unnecessary initializer is for VC /W4 + const char *p; + OutBuffer buf; + Strings *array; + + array = new Strings(); + if (path) + { + p = path; + do + { char instring = 0; + + while (isspace((unsigned char)*p)) // skip leading whitespace + p++; + buf.reserve(strlen(p) + 1); // guess size of path + for (; ; p++) + { + c = *p; + switch (c) + { + case '"': + instring ^= 1; // toggle inside/outside of string + continue; + +#if MACINTOSH + case ',': +#endif +#if _WIN32 + case ';': +#endif +#if POSIX + case ':': +#endif + p++; + break; // note that ; cannot appear as part + // of a path, quotes won't protect it + + case 0x1A: // ^Z means end of file + case 0: + break; + + case '\r': + continue; // ignore carriage returns + +#if POSIX + case '~': + buf.writestring(getenv("HOME")); + continue; +#endif + +#if 0 + case ' ': + case '\t': // tabs in filenames? + if (!instring) // if not in string + break; // treat as end of path +#endif + default: + buf.writeByte(c); + continue; + } + break; + } + if (buf.offset) // if path is not empty + { + buf.writeByte(0); // to asciiz + array->push(buf.extractData()); + } + } while (c); + } + return array; +} + +hash_t FileName::hashCode() +{ +#if _WIN32 + // We need a different hashCode because it must be case-insensitive + size_t len = strlen(str); + hash_t hash = 0; + unsigned char *s = (unsigned char *)str; + + for (;;) + { + switch (len) + { + case 0: + return hash; + + case 1: + hash *= 37; + hash += *(uint8_t *)s | 0x20; + return hash; + + case 2: + hash *= 37; + hash += *(uint16_t *)s | 0x2020; + return hash; + + case 3: + hash *= 37; + hash += ((*(uint16_t *)s << 8) + + ((uint8_t *)s)[2]) | 0x202020; + break; + + default: + hash *= 37; + hash += *(uint32_t *)s | 0x20202020; + s += 4; + len -= 4; + break; + } + } +#else + // darwin HFS is case insensitive, though... + return String::hashCode(); +#endif +} + +int FileName::compare(Object *obj) +{ + return compare(str, ((FileName *)obj)->str); +} + +int FileName::compare(const char *name1, const char *name2) +{ +#if _WIN32 + return stricmp(name1, name2); +#else + return strcmp(name1, name2); +#endif +} + +int FileName::equals(Object *obj) +{ + return compare(obj) == 0; +} + +int FileName::equals(const char *name1, const char *name2) +{ + return compare(name1, name2) == 0; +} + +/************************************ + * Return !=0 if absolute path name. + */ + +int FileName::absolute(const char *name) +{ +#if _WIN32 + return (*name == '\\') || + (*name == '/') || + (*name && name[1] == ':'); +#elif POSIX + return (*name == '/'); +#else + assert(0); +#endif +} + +/******************************** + * Return filename extension (read-only). + * Points past '.' of extension. + * If there isn't one, return NULL. + */ + +char *FileName::ext(const char *str) +{ + char *e; + size_t len = strlen(str); + + e = (char *)str + len; + for (;;) + { + switch (*e) + { case '.': + return e + 1; +#if POSIX + case '/': + break; +#endif +#if _WIN32 + case '\\': + case ':': + case '/': + break; +#endif + default: + if (e == str) + break; + e--; + continue; + } + return NULL; + } +} + +char *FileName::ext() +{ + return ext(str); +} + +/******************************** + * Return mem.malloc'd filename with extension removed. + */ + +char *FileName::removeExt(const char *str) +{ + const char *e = ext(str); + if (e) + { size_t len = (e - str) - 1; + char *n = (char *)mem.malloc(len + 1); + memcpy(n, str, len); + n[len] = 0; + return n; + } + return mem.strdup(str); +} + +/******************************** + * Return filename name excluding path (read-only). + */ + +char *FileName::name(const char *str) +{ + char *e; + size_t len = strlen(str); + + e = (char *)str + len; + for (;;) + { + switch (*e) + { +#if POSIX + case '/': + return e + 1; +#endif +#if _WIN32 + case '/': + case '\\': + return e + 1; + case ':': + /* The ':' is a drive letter only if it is the second + * character or the last character, + * otherwise it is an ADS (Alternate Data Stream) separator. + * Consider ADS separators as part of the file name. + */ + if (e == str + 1 || e == str + len - 1) + return e + 1; +#endif + default: + if (e == str) + break; + e--; + continue; + } + return e; + } +} + +char *FileName::name() +{ + return name(str); +} + +/************************************** + * Return path portion of str. + * Path will does not include trailing path separator. + */ + +char *FileName::path(const char *str) +{ + char *n = name(str); + char *path; + size_t pathlen; + + if (n > str) + { +#if POSIX + if (n[-1] == '/') + n--; +#elif _WIN32 + if (n[-1] == '\\' || n[-1] == '/') + n--; +#else + assert(0); +#endif + } + pathlen = n - str; + path = (char *)mem.malloc(pathlen + 1); + memcpy(path, str, pathlen); + path[pathlen] = 0; + return path; +} + +/************************************** + * Replace filename portion of path. + */ + +const char *FileName::replaceName(const char *path, const char *name) +{ char *f; + char *n; + size_t pathlen; + size_t namelen; + + if (absolute(name)) + return name; + + n = FileName::name(path); + if (n == path) + return name; + pathlen = n - path; + namelen = strlen(name); + f = (char *)mem.malloc(pathlen + 1 + namelen + 1); + memcpy(f, path, pathlen); +#if POSIX + if (path[pathlen - 1] != '/') + { f[pathlen] = '/'; + pathlen++; + } +#elif _WIN32 + if (path[pathlen - 1] != '\\' && + path[pathlen - 1] != '/' && + path[pathlen - 1] != ':') + { f[pathlen] = '\\'; + pathlen++; + } +#else + assert(0); +#endif + memcpy(f + pathlen, name, namelen + 1); + return f; +} + +/*************************** + */ + +FileName *FileName::defaultExt(const char *name, const char *ext) +{ + char *e; + char *s; + size_t len; + size_t extlen; + + e = FileName::ext(name); + if (e) // if already has an extension + return new FileName((char *)name, 0); + + len = strlen(name); + extlen = strlen(ext); + s = (char *)alloca(len + 1 + extlen + 1); + memcpy(s,name,len); + s[len] = '.'; + memcpy(s + len + 1, ext, extlen + 1); + return new FileName(s, 0); +} + +/*************************** + */ + +FileName *FileName::forceExt(const char *name, const char *ext) +{ + char *e; + char *s; + size_t len; + size_t extlen; + + e = FileName::ext(name); + if (e) // if already has an extension + { + len = e - name; + extlen = strlen(ext); + + s = (char *)alloca(len + extlen + 1); + memcpy(s,name,len); + memcpy(s + len, ext, extlen + 1); + return new FileName(s, 0); + } + else + return defaultExt(name, ext); // doesn't have one +} + +/****************************** + * Return !=0 if extensions match. + */ + +int FileName::equalsExt(const char *ext) +{ const char *e; + + e = FileName::ext(); + if (!e && !ext) + return 1; + if (!e || !ext) + return 0; +#if POSIX + return strcmp(e,ext) == 0; +#elif _WIN32 + return stricmp(e,ext) == 0; +#else + assert(0); +#endif +} + +/************************************* + * Copy file from this to to. + */ + +void FileName::CopyTo(FileName *to) +{ + File file(this); + +#if _WIN32 + file.touchtime = mem.malloc(sizeof(WIN32_FIND_DATAA)); // keep same file time +#elif POSIX + file.touchtime = mem.malloc(sizeof(struct stat)); // keep same file time +#else + assert(0); +#endif + file.readv(); + file.name = to; + file.writev(); +} + +/************************************* + * Search Path for file. + * Input: + * cwd if !=0, search current directory before searching path + */ + +char *FileName::searchPath(Strings *path, const char *name, int cwd) +{ + if (absolute(name)) + { + return exists(name) ? (char *)name : NULL; + } + if (cwd) + { + if (exists(name)) + return (char *)name; + } + if (path) + { unsigned i; + + for (i = 0; i < path->dim; i++) + { + char *p = path->tdata()[i]; + char *n = combine(p, name); + + if (exists(n)) + return n; + } + } + return NULL; +} + + +/************************************* + * Search Path for file in a safe manner. + * + * Be wary of CWE-22: Improper Limitation of a Pathname to a Restricted Directory + * ('Path Traversal') attacks. + * http://cwe.mitre.org/data/definitions/22.html + * More info: + * https://www.securecoding.cert.org/confluence/display/seccode/FIO02-C.+Canonicalize+path+names+originating+from+untrusted+sources + * Returns: + * NULL file not found + * !=NULL mem.malloc'd file name + */ + +char *FileName::safeSearchPath(Strings *path, const char *name) +{ +#if _WIN32 + /* Disallow % / \ : and .. in name characters + */ + for (const char *p = name; *p; p++) + { + char c = *p; + if (c == '\\' || c == '/' || c == ':' || c == '%' || + (c == '.' && p[1] == '.')) + { + return NULL; + } + } + + return FileName::searchPath(path, name, 0); +#elif POSIX + /* Even with realpath(), we must check for // and disallow it + */ + for (const char *p = name; *p; p++) + { + char c = *p; + if (c == '/' && p[1] == '/') + { + return NULL; + } + } + + if (path) + { unsigned i; + + /* Each path is converted to a cannonical name and then a check is done to see + * that the searched name is really a child one of the the paths searched. + */ + for (i = 0; i < path->dim; i++) + { + char *cname = NULL; + char *cpath = canonicalName(path->tdata()[i]); + //printf("FileName::safeSearchPath(): name=%s; path=%s; cpath=%s\n", + // name, (char *)path->data[i], cpath); + if (cpath == NULL) + goto cont; + cname = canonicalName(combine(cpath, name)); + //printf("FileName::safeSearchPath(): cname=%s\n", cname); + if (cname == NULL) + goto cont; + //printf("FileName::safeSearchPath(): exists=%i " + // "strncmp(cpath, cname, %i)=%i\n", exists(cname), + // strlen(cpath), strncmp(cpath, cname, strlen(cpath))); + // exists and name is *really* a "child" of path + if (exists(cname) && strncmp(cpath, cname, strlen(cpath)) == 0) + { + free(cpath); + char *p = mem.strdup(cname); + free(cname); + return p; + } +cont: + if (cpath) + free(cpath); + if (cname) + free(cname); + } + } + return NULL; +#else + assert(0); +#endif +} + + +int FileName::exists(const char *name) +{ +#if POSIX + struct stat st; + + if (stat(name, &st) < 0) + return 0; + if (S_ISDIR(st.st_mode)) + return 2; + return 1; +#elif _WIN32 + DWORD dw; + int result; + + dw = GetFileAttributesA(name); + if (dw == -1L) + result = 0; + else if (dw & FILE_ATTRIBUTE_DIRECTORY) + result = 2; + else + result = 1; + return result; +#else + assert(0); +#endif +} + +void FileName::ensurePathExists(const char *path) +{ + //printf("FileName::ensurePathExists(%s)\n", path ? path : ""); + if (path && *path) + { + if (!exists(path)) + { + char *p = FileName::path(path); + if (*p) + { +#if _WIN32 + size_t len = strlen(path); + if (len > 2 && p[-1] == ':' && path + 2 == p) + { mem.free(p); + return; + } +#endif + ensurePathExists(p); + mem.free(p); + } +#if _WIN32 + if (path[strlen(path) - 1] != '\\') +#endif +#if POSIX + if (path[strlen(path) - 1] != '\\') +#endif + { + //printf("mkdir(%s)\n", path); +#if _WIN32 + if (_mkdir(path)) +#endif +#if POSIX + if (mkdir(path, 0777)) +#endif + { + /* Don't error out if another instance of dmd just created + * this directory + */ + if (errno != EEXIST) + error("cannot create directory %s", path); + } + } + } + } +} + + +/****************************************** + * Return canonical version of name in a malloc'd buffer. + * This code is high risk. + */ +char *FileName::canonicalName(const char *name) +{ +#if linux + // Lovely glibc extension to do it for us + return canonicalize_file_name(name); +#elif POSIX + #if _POSIX_VERSION >= 200809L || defined (linux) + // NULL destination buffer is allowed and preferred + return realpath(name, NULL); + #else + char *cname = NULL; + #if PATH_MAX + /* PATH_MAX must be defined as a constant in , + * otherwise using it is unsafe due to TOCTOU + */ + size_t path_max = (size_t)PATH_MAX; + if (path_max > 0) + { + /* Need to add one to PATH_MAX because of realpath() buffer overflow bug: + * http://isec.pl/vulnerabilities/isec-0011-wu-ftpd.txt + */ + cname = (char *)malloc(path_max + 1); + if (cname == NULL) + return NULL; + } + #endif + return realpath(name, cname); + #endif +#elif _WIN32 + /* Apparently, there is no good way to do this on Windows. + * GetFullPathName isn't it. + */ + assert(0); + return NULL; +#else + assert(0); + return NULL; +#endif +} + + +/****************************** File ********************************/ + +File::File(FileName *n) +{ + ref = 0; + buffer = NULL; + len = 0; + touchtime = NULL; + name = n; +} + +File::File(char *n) +{ + ref = 0; + buffer = NULL; + len = 0; + touchtime = NULL; + name = new FileName(n, 0); +} + +File::~File() +{ + if (buffer) + { + if (ref == 0) + mem.free(buffer); +#if _WIN32 + else if (ref == 2) + UnmapViewOfFile(buffer); +#endif + } + if (touchtime) + mem.free(touchtime); +} + +void File::mark() +{ + mem.mark(buffer); + mem.mark(touchtime); + mem.mark(name); +} + +/************************************* + */ + +int File::read() +{ +#if POSIX + off_t size; + ssize_t numread; + int fd; + struct stat buf; + int result = 0; + char *name; + + name = this->name->toChars(); + //printf("File::read('%s')\n",name); + fd = open(name, O_RDONLY); + if (fd == -1) + { + //printf("\topen error, errno = %d\n",errno); + goto err1; + } + + if (!ref) + ::free(buffer); + ref = 0; // we own the buffer now + + //printf("\tfile opened\n"); + if (fstat(fd, &buf)) + { + printf("\tfstat error, errno = %d\n",errno); + goto err2; + } + size = buf.st_size; + buffer = (unsigned char *) ::malloc(size + 2); + if (!buffer) + { + printf("\tmalloc error, errno = %d\n",errno); + goto err2; + } + + numread = ::read(fd, buffer, size); + if (numread != size) + { + printf("\tread error, errno = %d\n",errno); + goto err2; + } + + if (touchtime) + memcpy(touchtime, &buf, sizeof(buf)); + + if (close(fd) == -1) + { + printf("\tclose error, errno = %d\n",errno); + goto err; + } + + len = size; + + // Always store a wchar ^Z past end of buffer so scanner has a sentinel + buffer[size] = 0; // ^Z is obsolete, use 0 + buffer[size + 1] = 0; + return 0; + +err2: + close(fd); +err: + ::free(buffer); + buffer = NULL; + len = 0; + +err1: + result = 1; + return result; +#elif _WIN32 + DWORD size; + DWORD numread; + HANDLE h; + int result = 0; + char *name; + + name = this->name->toChars(); + h = CreateFileA(name,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,0); + if (h == INVALID_HANDLE_VALUE) + goto err1; + + if (!ref) + ::free(buffer); + ref = 0; + + size = GetFileSize(h,NULL); + buffer = (unsigned char *) ::malloc(size + 2); + if (!buffer) + goto err2; + + if (ReadFile(h,buffer,size,&numread,NULL) != TRUE) + goto err2; + + if (numread != size) + goto err2; + + if (touchtime) + { + if (!GetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime)) + goto err2; + } + + if (!CloseHandle(h)) + goto err; + + len = size; + + // Always store a wchar ^Z past end of buffer so scanner has a sentinel + buffer[size] = 0; // ^Z is obsolete, use 0 + buffer[size + 1] = 0; + return 0; + +err2: + CloseHandle(h); +err: + ::free(buffer); + buffer = NULL; + len = 0; + +err1: + result = 1; + return result; +#else + assert(0); +#endif +} + +/***************************** + * Read a file with memory mapped file I/O. + */ + +int File::mmread() +{ +#if POSIX + return read(); +#elif _WIN32 + HANDLE hFile; + HANDLE hFileMap; + DWORD size; + char *name; + + name = this->name->toChars(); + hFile = CreateFile(name, GENERIC_READ, + FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) + goto Lerr; + size = GetFileSize(hFile, NULL); + //printf(" file created, size %d\n", size); + + hFileMap = CreateFileMapping(hFile,NULL,PAGE_READONLY,0,size,NULL); + if (CloseHandle(hFile) != TRUE) + goto Lerr; + + if (hFileMap == NULL) + goto Lerr; + + //printf(" mapping created\n"); + + if (!ref) + mem.free(buffer); + ref = 2; + buffer = (unsigned char *)MapViewOfFileEx(hFileMap, FILE_MAP_READ,0,0,size,NULL); + if (CloseHandle(hFileMap) != TRUE) + goto Lerr; + if (buffer == NULL) // mapping view failed + goto Lerr; + + len = size; + //printf(" buffer = %p\n", buffer); + + return 0; + +Lerr: + return GetLastError(); // failure +#else + assert(0); +#endif +} + +/********************************************* + * Write a file. + * Returns: + * 0 success + */ + +int File::write() +{ +#if POSIX + int fd; + ssize_t numwritten; + char *name; + + name = this->name->toChars(); + fd = open(name, O_CREAT | O_WRONLY | O_TRUNC, 0644); + if (fd == -1) + goto err; + + numwritten = ::write(fd, buffer, len); + if (len != numwritten) + goto err2; + + if (close(fd) == -1) + goto err; + + if (touchtime) + { struct utimbuf ubuf; + + ubuf.actime = ((struct stat *)touchtime)->st_atime; + ubuf.modtime = ((struct stat *)touchtime)->st_mtime; + if (utime(name, &ubuf)) + goto err; + } + return 0; + +err2: + close(fd); + ::remove(name); +err: + return 1; +#elif _WIN32 + HANDLE h; + DWORD numwritten; + char *name; + + name = this->name->toChars(); + h = CreateFileA(name,GENERIC_WRITE,0,NULL,CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL); + if (h == INVALID_HANDLE_VALUE) + goto err; + + if (WriteFile(h,buffer,len,&numwritten,NULL) != TRUE) + goto err2; + + if (len != numwritten) + goto err2; + + if (touchtime) { + SetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime); + } + if (!CloseHandle(h)) + goto err; + return 0; + +err2: + CloseHandle(h); + DeleteFileA(name); +err: + return 1; +#else + assert(0); +#endif +} + +/********************************************* + * Append to a file. + * Returns: + * 0 success + */ + +int File::append() +{ +#if POSIX + return 1; +#elif _WIN32 + HANDLE h; + DWORD numwritten; + char *name; + + name = this->name->toChars(); + h = CreateFileA(name,GENERIC_WRITE,0,NULL,OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL); + if (h == INVALID_HANDLE_VALUE) + goto err; + +#if 1 + SetFilePointer(h, 0, NULL, FILE_END); +#else // INVALID_SET_FILE_POINTER doesn't seem to have a definition + if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER) + goto err; +#endif + + if (WriteFile(h,buffer,len,&numwritten,NULL) != TRUE) + goto err2; + + if (len != numwritten) + goto err2; + + if (touchtime) { + SetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime); + } + if (!CloseHandle(h)) + goto err; + return 0; + +err2: + CloseHandle(h); +err: + return 1; +#else + assert(0); +#endif +} + +/************************************** + */ + +void File::readv() +{ + if (read()) + error("Error reading file '%s'\n",name->toChars()); +} + +/************************************** + */ + +void File::mmreadv() +{ + if (mmread()) + readv(); +} + +void File::writev() +{ + if (write()) + error("Error writing file '%s'\n",name->toChars()); +} + +void File::appendv() +{ + if (write()) + error("Error appending to file '%s'\n",name->toChars()); +} + +/******************************************* + * Return !=0 if file exists. + * 0: file doesn't exist + * 1: normal file + * 2: directory + */ + +int File::exists() +{ +#if POSIX + return 0; +#elif _WIN32 + DWORD dw; + int result; + char *name; + + name = this->name->toChars(); + if (touchtime) + dw = ((WIN32_FIND_DATAA *)touchtime)->dwFileAttributes; + else + dw = GetFileAttributesA(name); + if (dw == -1L) + result = 0; + else if (dw & FILE_ATTRIBUTE_DIRECTORY) + result = 2; + else + result = 1; + return result; +#else + assert(0); +#endif +} + +void File::remove() +{ +#if POSIX + ::remove(this->name->toChars()); +#elif _WIN32 + DeleteFileA(this->name->toChars()); +#else + assert(0); +#endif +} + +Files *File::match(char *n) +{ + return match(new FileName(n, 0)); +} + +Files *File::match(FileName *n) +{ +#if POSIX + return NULL; +#elif _WIN32 + HANDLE h; + WIN32_FIND_DATAA fileinfo; + Files *a; + char *c; + char *name; + + a = new Files(); + c = n->toChars(); + name = n->name(); + h = FindFirstFileA(c,&fileinfo); + if (h != INVALID_HANDLE_VALUE) + { + do + { + // Glue path together with name + char *fn; + File *f; + + fn = (char *)mem.malloc(name - c + strlen(fileinfo.cFileName) + 1); + memcpy(fn, c, name - c); + strcpy(fn + (name - c), fileinfo.cFileName); + f = new File(fn); + f->touchtime = mem.malloc(sizeof(WIN32_FIND_DATAA)); + memcpy(f->touchtime, &fileinfo, sizeof(fileinfo)); + a->push(f); + } while (FindNextFileA(h,&fileinfo) != FALSE); + FindClose(h); + } + return a; +#else + assert(0); +#endif +} + +int File::compareTime(File *f) +{ +#if POSIX + return 0; +#elif _WIN32 + if (!touchtime) + stat(); + if (!f->touchtime) + f->stat(); + return CompareFileTime(&((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime, &((WIN32_FIND_DATAA *)f->touchtime)->ftLastWriteTime); +#else + assert(0); +#endif +} + +void File::stat() +{ +#if POSIX + if (!touchtime) + { + touchtime = mem.calloc(1, sizeof(struct stat)); + } +#elif _WIN32 + HANDLE h; + + if (!touchtime) + { + touchtime = mem.calloc(1, sizeof(WIN32_FIND_DATAA)); + } + h = FindFirstFileA(name->toChars(),(WIN32_FIND_DATAA *)touchtime); + if (h != INVALID_HANDLE_VALUE) + { + FindClose(h); + } +#else + assert(0); +#endif +} + +void File::checkoffset(size_t offset, size_t nbytes) +{ + if (offset > len || offset + nbytes > len) + error("Corrupt file '%s': offset x%zx off end of file",toChars(),offset); +} + +char *File::toChars() +{ + return name->toChars(); +} + + +/************************* OutBuffer *************************/ + +OutBuffer::OutBuffer() +{ + data = NULL; + offset = 0; + size = 0; +} + +OutBuffer::~OutBuffer() +{ + mem.free(data); +} + +char *OutBuffer::extractData() +{ + char *p; + + p = (char *)data; + data = NULL; + offset = 0; + size = 0; + return p; +} + +void OutBuffer::mark() +{ + mem.mark(data); +} + +void OutBuffer::reserve(unsigned nbytes) +{ + //printf("OutBuffer::reserve: size = %d, offset = %d, nbytes = %d\n", size, offset, nbytes); + if (size - offset < nbytes) + { + size = (offset + nbytes) * 2; + data = (unsigned char *)mem.realloc(data, size); + } +} + +void OutBuffer::reset() +{ + offset = 0; +} + +void OutBuffer::setsize(unsigned size) +{ + offset = size; +} + +void OutBuffer::write(const void *data, unsigned nbytes) +{ + reserve(nbytes); + memcpy(this->data + offset, data, nbytes); + offset += nbytes; +} + +void OutBuffer::writebstring(unsigned char *string) +{ + write(string,*string + 1); +} + +void OutBuffer::writestring(const char *string) +{ + write(string,strlen(string)); +} + +void OutBuffer::writedstring(const char *string) +{ +#if M_UNICODE + for (; *string; string++) + { + writedchar(*string); + } +#else + write(string,strlen(string)); +#endif +} + +void OutBuffer::writedstring(const wchar_t *string) +{ +#if M_UNICODE + write(string,wcslen(string) * sizeof(wchar_t)); +#else + for (; *string; string++) + { + writedchar(*string); + } +#endif +} + +void OutBuffer::prependstring(const char *string) +{ unsigned len; + + len = strlen(string); + reserve(len); + memmove(data + len, data, offset); + memcpy(data, string, len); + offset += len; +} + +void OutBuffer::writenl() +{ +#if _WIN32 +#if M_UNICODE + write4(0x000A000D); // newline is CR,LF on Microsoft OS's +#else + writeword(0x0A0D); // newline is CR,LF on Microsoft OS's +#endif +#else +#if M_UNICODE + writeword('\n'); +#else + writeByte('\n'); +#endif +#endif +} + +void OutBuffer::writeByte(unsigned b) +{ + reserve(1); + this->data[offset] = (unsigned char)b; + offset++; +} + +void OutBuffer::writeUTF8(unsigned b) +{ + reserve(6); + if (b <= 0x7F) + { + this->data[offset] = (unsigned char)b; + offset++; + } + else if (b <= 0x7FF) + { + this->data[offset + 0] = (unsigned char)((b >> 6) | 0xC0); + this->data[offset + 1] = (unsigned char)((b & 0x3F) | 0x80); + offset += 2; + } + else if (b <= 0xFFFF) + { + this->data[offset + 0] = (unsigned char)((b >> 12) | 0xE0); + this->data[offset + 1] = (unsigned char)(((b >> 6) & 0x3F) | 0x80); + this->data[offset + 2] = (unsigned char)((b & 0x3F) | 0x80); + offset += 3; + } + else if (b <= 0x1FFFFF) + { + this->data[offset + 0] = (unsigned char)((b >> 18) | 0xF0); + this->data[offset + 1] = (unsigned char)(((b >> 12) & 0x3F) | 0x80); + this->data[offset + 2] = (unsigned char)(((b >> 6) & 0x3F) | 0x80); + this->data[offset + 3] = (unsigned char)((b & 0x3F) | 0x80); + offset += 4; + } + else if (b <= 0x3FFFFFF) + { + this->data[offset + 0] = (unsigned char)((b >> 24) | 0xF8); + this->data[offset + 1] = (unsigned char)(((b >> 18) & 0x3F) | 0x80); + this->data[offset + 2] = (unsigned char)(((b >> 12) & 0x3F) | 0x80); + this->data[offset + 3] = (unsigned char)(((b >> 6) & 0x3F) | 0x80); + this->data[offset + 4] = (unsigned char)((b & 0x3F) | 0x80); + offset += 5; + } + else if (b <= 0x7FFFFFFF) + { + this->data[offset + 0] = (unsigned char)((b >> 30) | 0xFC); + this->data[offset + 1] = (unsigned char)(((b >> 24) & 0x3F) | 0x80); + this->data[offset + 2] = (unsigned char)(((b >> 18) & 0x3F) | 0x80); + this->data[offset + 3] = (unsigned char)(((b >> 12) & 0x3F) | 0x80); + this->data[offset + 4] = (unsigned char)(((b >> 6) & 0x3F) | 0x80); + this->data[offset + 5] = (unsigned char)((b & 0x3F) | 0x80); + offset += 6; + } + else + assert(0); +} + +void OutBuffer::writedchar(unsigned b) +{ + reserve(Dchar_mbmax * sizeof(dchar)); + offset = (unsigned char *)Dchar::put((dchar *)(this->data + offset), (dchar)b) - + this->data; +} + +void OutBuffer::prependbyte(unsigned b) +{ + reserve(1); + memmove(data + 1, data, offset); + data[0] = (unsigned char)b; + offset++; +} + +void OutBuffer::writeword(unsigned w) +{ + reserve(2); + *(unsigned short *)(this->data + offset) = (unsigned short)w; + offset += 2; +} + +void OutBuffer::writeUTF16(unsigned w) +{ + reserve(4); + if (w <= 0xFFFF) + { + *(unsigned short *)(this->data + offset) = (unsigned short)w; + offset += 2; + } + else if (w <= 0x10FFFF) + { + *(unsigned short *)(this->data + offset) = (unsigned short)((w >> 10) + 0xD7C0); + *(unsigned short *)(this->data + offset + 2) = (unsigned short)((w & 0x3FF) | 0xDC00); + offset += 4; + } + else + assert(0); +} + +void OutBuffer::write4(unsigned w) +{ + reserve(4); + *(unsigned *)(this->data + offset) = w; + offset += 4; +} + +void OutBuffer::write(OutBuffer *buf) +{ + if (buf) + { reserve(buf->offset); + memcpy(data + offset, buf->data, buf->offset); + offset += buf->offset; + } +} + +void OutBuffer::write(Object *obj) +{ + if (obj) + { + writestring(obj->toChars()); + } +} + +void OutBuffer::fill0(unsigned nbytes) +{ + reserve(nbytes); + memset(data + offset,0,nbytes); + offset += nbytes; +} + +void OutBuffer::align(unsigned size) +{ unsigned nbytes; + + nbytes = ((offset + size - 1) & ~(size - 1)) - offset; + fill0(nbytes); +} + + +//////////////////////////////////////////////////////////////// +// The compiler shipped with Visual Studio 2005 (and possible +// other versions) does not support C99 printf format specfiers +// such as %z and %j +#if _MSC_VER +using std::string; +using std::wstring; + +template +inline void +search_and_replace(S& str, const S& what, const S& replacement) +{ + assert(!what.empty()); + size_t pos = str.find(what); + while (pos != S::npos) + { + str.replace(pos, what.size(), replacement); + pos = str.find(what, pos + replacement.size()); + } +} +#define WORKAROUND_C99_SPECIFIERS_BUG(S,tmp,f) \ + S tmp = f; \ + search_and_replace(fmt, S("%z"), S("%l")); \ + search_and_replace(fmt, S("%j"), S("%i")); \ + f = tmp.c_str(); +#else +#define WORKAROUND_C99_SPECIFIERS_BUG(S,tmp,f) +#endif + +void OutBuffer::vprintf(const char *format, va_list args) +{ + char buffer[128]; + char *p; + unsigned psize; + int count; + + WORKAROUND_C99_SPECIFIERS_BUG(string, fmt, format); + + p = buffer; + psize = sizeof(buffer); + for (;;) + { +#if _WIN32 + count = _vsnprintf(p,psize,format,args); + if (count != -1) + break; + psize *= 2; +#elif POSIX + va_list va; + va_copy(va, args); +/* + The functions vprintf(), vfprintf(), vsprintf(), vsnprintf() + are equivalent to the functions printf(), fprintf(), sprintf(), + snprintf(), respectively, except that they are called with a + va_list instead of a variable number of arguments. These + functions do not call the va_end macro. Consequently, the value + of ap is undefined after the call. The application should call + va_end(ap) itself afterwards. + */ + count = vsnprintf(p,psize,format,va); + va_end(va); + if (count == -1) + psize *= 2; + else if (count >= psize) + psize = count + 1; + else + break; +#else + assert(0); +#endif + p = (char *) alloca(psize); // buffer too small, try again with larger size + } + write(p,count); +} + +#if M_UNICODE +void OutBuffer::vprintf(const wchar_t *format, va_list args) +{ + dchar buffer[128]; + dchar *p; + unsigned psize; + int count; + + WORKAROUND_C99_SPECIFIERS_BUG(wstring, fmt, format); + + p = buffer; + psize = sizeof(buffer) / sizeof(buffer[0]); + for (;;) + { +#if _WIN32 + count = _vsnwprintf(p,psize,format,args); + if (count != -1) + break; + psize *= 2; +#elif POSIX + va_list va; + va_copy(va, args); + count = vsnwprintf(p,psize,format,va); + va_end(va); + + if (count == -1) + psize *= 2; + else if (count >= psize) + psize = count + 1; + else + break; +#else + assert(0); +#endif + p = (dchar *) alloca(psize * 2); // buffer too small, try again with larger size + } + write(p,count * 2); +} +#endif + +void OutBuffer::printf(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + vprintf(format,ap); + va_end(ap); +} + +#if M_UNICODE +void OutBuffer::printf(const wchar_t *format, ...) +{ + va_list ap; + va_start(ap, format); + vprintf(format,ap); + va_end(ap); +} +#endif + +void OutBuffer::bracket(char left, char right) +{ + reserve(2); + memmove(data + 1, data, offset); + data[0] = left; + data[offset + 1] = right; + offset += 2; +} + +/****************** + * Insert left at i, and right at j. + * Return index just past right. + */ + +unsigned OutBuffer::bracket(unsigned i, const char *left, unsigned j, const char *right) +{ + size_t leftlen = strlen(left); + size_t rightlen = strlen(right); + reserve(leftlen + rightlen); + insert(i, left, leftlen); + insert(j + leftlen, right, rightlen); + return j + leftlen + rightlen; +} + +void OutBuffer::spread(unsigned offset, unsigned nbytes) +{ + reserve(nbytes); + memmove(data + offset + nbytes, data + offset, + this->offset - offset); + this->offset += nbytes; +} + +/**************************************** + * Returns: offset + nbytes + */ + +unsigned OutBuffer::insert(unsigned offset, const void *p, unsigned nbytes) +{ + spread(offset, nbytes); + memmove(data + offset, p, nbytes); + return offset + nbytes; +} + +void OutBuffer::remove(unsigned offset, unsigned nbytes) +{ + memmove(data + offset, data + offset + nbytes, this->offset - (offset + nbytes)); + this->offset -= nbytes; +} + +char *OutBuffer::toChars() +{ + writeByte(0); + return (char *)data; +} + +/********************************* Bits ****************************/ + +Bits::Bits() +{ + data = NULL; + bitdim = 0; + allocdim = 0; +} + +Bits::~Bits() +{ + mem.free(data); +} + +void Bits::mark() +{ + mem.mark(data); +} + +void Bits::resize(unsigned bitdim) +{ + unsigned allocdim; + unsigned mask; + + allocdim = (bitdim + 31) / 32; + data = (unsigned *)mem.realloc(data, allocdim * sizeof(data[0])); + if (this->allocdim < allocdim) + memset(data + this->allocdim, 0, (allocdim - this->allocdim) * sizeof(data[0])); + + // Clear other bits in last word + mask = (1 << (bitdim & 31)) - 1; + if (mask) + data[allocdim - 1] &= ~mask; + + this->bitdim = bitdim; + this->allocdim = allocdim; +} + +void Bits::set(unsigned bitnum) +{ + data[bitnum / 32] |= 1 << (bitnum & 31); +} + +void Bits::clear(unsigned bitnum) +{ + data[bitnum / 32] &= ~(1 << (bitnum & 31)); +} + +int Bits::test(unsigned bitnum) +{ + return data[bitnum / 32] & (1 << (bitnum & 31)); +} + +void Bits::set() +{ unsigned mask; + + memset(data, ~0, allocdim * sizeof(data[0])); + + // Clear other bits in last word + mask = (1 << (bitdim & 31)) - 1; + if (mask) + data[allocdim - 1] &= mask; +} + +void Bits::clear() +{ + memset(data, 0, allocdim * sizeof(data[0])); +} + +void Bits::copy(Bits *from) +{ + assert(bitdim == from->bitdim); + memcpy(data, from->data, allocdim * sizeof(data[0])); +} + +Bits *Bits::clone() +{ + Bits *b; + + b = new Bits(); + b->resize(bitdim); + b->copy(this); + return b; +} + +void Bits::sub(Bits *b) +{ + unsigned u; + + for (u = 0; u < allocdim; u++) + data[u] &= ~b->data[u]; +} + + + + + + + + + + + + + + + diff --git a/root/root.h b/root/root.h new file mode 100644 index 00000000..bac6036e --- /dev/null +++ b/root/root.h @@ -0,0 +1,417 @@ + + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef ROOT_H +#define ROOT_H + +#include +#include +#ifdef DEBUG +#include +#endif + +#if __DMC__ +#pragma once +#endif + +typedef size_t hash_t; + +#include "dchar.h" + +char *wchar2ascii(wchar_t *); +int wcharIsAscii(wchar_t *); +char *wchar2ascii(wchar_t *, unsigned len); +int wcharIsAscii(wchar_t *, unsigned len); + +int bstrcmp(unsigned char *s1, unsigned char *s2); +char *bstr2str(unsigned char *b); +void error(const char *format, ...); +void error(const wchar_t *format, ...); +void warning(const char *format, ...); + +#ifndef TYPEDEFS +#define TYPEDEFS + +#if _MSC_VER +#include // for _isnan +#include // for alloca +// According to VC 8.0 docs, long double is the same as double +#define strtold strtod +#define strtof strtod +#define isnan _isnan + +typedef __int64 longlong; +typedef unsigned __int64 ulonglong; +#else +typedef long long longlong; +typedef unsigned long long ulonglong; +#endif + +#endif + +longlong randomx(); + +/* + * Root of our class library. + */ + +struct OutBuffer; + +// Can't include arraytypes.h here, need to declare these directly. +template struct ArrayBase; +typedef ArrayBase Files; +typedef ArrayBase Strings; + + +struct Object +{ + Object() { } + virtual ~Object() { } + + virtual int equals(Object *o); + + /** + * Returns a hash code, useful for things like building hash tables of Objects. + */ + virtual hash_t hashCode(); + + /** + * Return <0, ==0, or >0 if this is less than, equal to, or greater than obj. + * Useful for sorting Objects. + */ + virtual int compare(Object *obj); + + /** + * Pretty-print an Object. Useful for debugging the old-fashioned way. + */ + virtual void print(); + + virtual char *toChars(); + virtual dchar *toDchars(); + virtual void toBuffer(OutBuffer *buf); + + /** + * Used as a replacement for dynamic_cast. Returns a unique number + * defined by the library user. For Object, the return value is 0. + */ + virtual int dyncast(); + + /** + * Marks pointers for garbage collector by calling mem.mark() for all pointers into heap. + */ + /*virtual*/ // not used, disable for now + void mark(); +}; + +struct String : Object +{ + int ref; // != 0 if this is a reference to someone else's string + char *str; // the string itself + + String(char *str, int ref = 1); + + ~String(); + + static hash_t calcHash(const char *str, size_t len); + static hash_t calcHash(const char *str); + hash_t hashCode(); + unsigned len(); + int equals(Object *obj); + int compare(Object *obj); + char *toChars(); + void print(); + void mark(); +}; + +struct FileName : String +{ + FileName(char *str, int ref); + FileName(char *path, char *name); + hash_t hashCode(); + int equals(Object *obj); + static int equals(const char *name1, const char *name2); + int compare(Object *obj); + static int compare(const char *name1, const char *name2); + static int absolute(const char *name); + static char *ext(const char *); + char *ext(); + static char *removeExt(const char *str); + static char *name(const char *); + char *name(); + static char *path(const char *); + static const char *replaceName(const char *path, const char *name); + + static char *combine(const char *path, const char *name); + static Strings *splitPath(const char *path); + static FileName *defaultExt(const char *name, const char *ext); + static FileName *forceExt(const char *name, const char *ext); + int equalsExt(const char *ext); + + void CopyTo(FileName *to); + static char *searchPath(Strings *path, const char *name, int cwd); + static char *safeSearchPath(Strings *path, const char *name); + static int exists(const char *name); + static void ensurePathExists(const char *path); + static char *canonicalName(const char *name); +}; + +struct File : Object +{ + int ref; // != 0 if this is a reference to someone else's buffer + unsigned char *buffer; // data for our file + unsigned len; // amount of data in buffer[] + void *touchtime; // system time to use for file + + FileName *name; // name of our file + + File(char *); + File(FileName *); + ~File(); + + void mark(); + + char *toChars(); + + /* Read file, return !=0 if error + */ + + int read(); + + /* Write file, either succeed or fail + * with error message & exit. + */ + + void readv(); + + /* Read file, return !=0 if error + */ + + int mmread(); + + /* Write file, either succeed or fail + * with error message & exit. + */ + + void mmreadv(); + + /* Write file, return !=0 if error + */ + + int write(); + + /* Write file, either succeed or fail + * with error message & exit. + */ + + void writev(); + + /* Return !=0 if file exists. + * 0: file doesn't exist + * 1: normal file + * 2: directory + */ + + /* Append to file, return !=0 if error + */ + + int append(); + + /* Append to file, either succeed or fail + * with error message & exit. + */ + + void appendv(); + + /* Return !=0 if file exists. + * 0: file doesn't exist + * 1: normal file + * 2: directory + */ + + int exists(); + + /* Given wildcard filespec, return an array of + * matching File's. + */ + + static Files *match(char *); + static Files *match(FileName *); + + // Compare file times. + // Return <0 this < f + // =0 this == f + // >0 this > f + int compareTime(File *f); + + // Read system file statistics + void stat(); + + /* Set buffer + */ + + void setbuffer(void *buffer, unsigned len) + { + this->buffer = (unsigned char *)buffer; + this->len = len; + } + + void checkoffset(size_t offset, size_t nbytes); + + void remove(); // delete file +}; + +struct OutBuffer : Object +{ + unsigned char *data; + unsigned offset; + unsigned size; + + OutBuffer(); + ~OutBuffer(); + char *extractData(); + void mark(); + + void reserve(unsigned nbytes); + void setsize(unsigned size); + void reset(); + void write(const void *data, unsigned nbytes); + void writebstring(unsigned char *string); + void writestring(const char *string); + void writedstring(const char *string); + void writedstring(const wchar_t *string); + void prependstring(const char *string); + void writenl(); // write newline + void writeByte(unsigned b); + void writebyte(unsigned b) { writeByte(b); } + void writeUTF8(unsigned b); + void writedchar(unsigned b); + void prependbyte(unsigned b); + void writeword(unsigned w); + void writeUTF16(unsigned w); + void write4(unsigned w); + void write(OutBuffer *buf); + void write(Object *obj); + void fill0(unsigned nbytes); + void align(unsigned size); + void vprintf(const char *format, va_list args); + void printf(const char *format, ...); +#if M_UNICODE + void vprintf(const unsigned short *format, va_list args); + void printf(const unsigned short *format, ...); +#endif + void bracket(char left, char right); + unsigned bracket(unsigned i, const char *left, unsigned j, const char *right); + void spread(unsigned offset, unsigned nbytes); + unsigned insert(unsigned offset, const void *data, unsigned nbytes); + void remove(unsigned offset, unsigned nbytes); + char *toChars(); + char *extractString(); +}; + +struct Array : Object +{ + unsigned dim; + void **data; + + private: + unsigned allocdim; + #define SMALLARRAYCAP 1 + void *smallarray[SMALLARRAYCAP]; // inline storage for small arrays + + public: + Array(); + ~Array(); + //Array(const Array&); + void mark(); + char *toChars(); + + void reserve(unsigned nentries); + void setDim(unsigned newdim); + void fixDim(); + void push(void *ptr); + void *pop(); + void shift(void *ptr); + void insert(unsigned index, void *ptr); + void insert(unsigned index, Array *a); + void append(Array *a); + void remove(unsigned i); + void zero(); + void *tos(); + void sort(); + Array *copy(); +}; + +template +struct ArrayBase : Array +{ + TYPE **tdata() + { + return (TYPE **)data; + } + + TYPE*& operator[] (size_t index) + { +#ifdef DEBUG + assert(index < dim); +#endif + return ((TYPE **)data)[index]; + } + + void insert(size_t index, TYPE *v) + { + Array::insert(index, (void *)v); + } + + void insert(size_t index, ArrayBase *a) + { + Array::insert(index, (Array *)a); + } + + void append(ArrayBase *a) + { + Array::append((Array *)a); + } + + void push(TYPE *a) + { + Array::push((void *)a); + } + + ArrayBase *copy() + { + return (ArrayBase *)Array::copy(); + } +}; + +struct Bits : Object +{ + unsigned bitdim; + unsigned allocdim; + unsigned *data; + + Bits(); + ~Bits(); + void mark(); + + void resize(unsigned bitdim); + + void set(unsigned bitnum); + void clear(unsigned bitnum); + int test(unsigned bitnum); + + void set(); + void clear(); + void copy(Bits *from); + Bits *clone(); + + void sub(Bits *b); +}; + +#endif diff --git a/root/speller.c b/root/speller.c new file mode 100644 index 00000000..d6437379 --- /dev/null +++ b/root/speller.c @@ -0,0 +1,257 @@ + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "speller.h" + +const char idchars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"; + +/************************************************** + * Looks for correct spelling. + * Currently only looks a 'distance' of one from the seed[]. + * This does an exhaustive search, so can potentially be very slow. + * Input: + * seed wrongly spelled word + * fp search function + * fparg argument to search function + * charset character set + * Returns: + * NULL no correct spellings found + * void* value returned by fp() for first possible correct spelling + */ + +void *spellerY(const char *seed, size_t seedlen, fp_speller_t fp, void *fparg, + const char *charset, size_t index) +{ + if (!seedlen) + return NULL; + assert(seed[seedlen] == 0); + + char tmp[30]; + char *buf; + if (seedlen <= sizeof(tmp) - 2) + buf = tmp; + else + { + buf = (char *)alloca(seedlen + 2); // leave space for extra char + if (!buf) + return NULL; // no matches + } + + memcpy(buf, seed, index); + + /* Delete at seed[index] */ + if (index < seedlen) + { + memcpy(buf + index, seed + index + 1, seedlen - index); + assert(buf[seedlen - 1] == 0); + void *p = (*fp)(fparg, buf); + if (p) + return p; + } + + if (charset && *charset) + { + /* Substitutions */ + if (index < seedlen) + { + memcpy(buf, seed, seedlen + 1); + for (const char *s = charset; *s; s++) + { + buf[index] = *s; + + //printf("sub buf = '%s'\n", buf); + void *p = (*fp)(fparg, buf); + if (p) + return p; + } + assert(buf[seedlen] == 0); + } + + /* Insertions */ + memcpy (buf + index + 1, seed + index, seedlen + 1 - index); + + for (const char *s = charset; *s; s++) + { + buf[index] = *s; + + //printf("ins buf = '%s'\n", buf); + void *p = (*fp)(fparg, buf); + if (p) + return p; + } + assert(buf[seedlen + 1] == 0); + } + + return NULL; // didn't find any corrections +} + +void *spellerX(const char *seed, size_t seedlen, fp_speller_t fp, void *fparg, + const char *charset, int flag) +{ + if (!seedlen) + return NULL; + + char tmp[30]; + char *buf; + if (seedlen <= sizeof(tmp) - 2) + buf = tmp; + else + { + buf = (char *)alloca(seedlen + 2); // leave space for extra char + if (!buf) + return NULL; // no matches + } + + /* Deletions */ + memcpy(buf, seed + 1, seedlen); + for (size_t i = 0; i < seedlen; i++) + { + //printf("del buf = '%s'\n", buf); + void *p; + if (flag) + p = spellerY(buf, seedlen - 1, fp, fparg, charset, i); + else + p = (*fp)(fparg, buf); + if (p) + return p; + + buf[i] = seed[i]; + } + + /* Transpositions */ + if (!flag) + { + memcpy(buf, seed, seedlen + 1); + for (size_t i = 0; i + 1 < seedlen; i++) + { + // swap [i] and [i + 1] + buf[i] = seed[i + 1]; + buf[i + 1] = seed[i]; + + //printf("tra buf = '%s'\n", buf); + void *p = (*fp)(fparg, buf); + if (p) + return p; + + buf[i] = seed[i]; + } + } + + if (charset && *charset) + { + /* Substitutions */ + memcpy(buf, seed, seedlen + 1); + for (size_t i = 0; i < seedlen; i++) + { + for (const char *s = charset; *s; s++) + { + buf[i] = *s; + + //printf("sub buf = '%s'\n", buf); + void *p; + if (flag) + p = spellerY(buf, seedlen, fp, fparg, charset, i + 1); + else + p = (*fp)(fparg, buf); + if (p) + return p; + } + buf[i] = seed[i]; + } + + /* Insertions */ + memcpy(buf + 1, seed, seedlen + 1); + for (size_t i = 0; i <= seedlen; i++) // yes, do seedlen+1 iterations + { + for (const char *s = charset; *s; s++) + { + buf[i] = *s; + + //printf("ins buf = '%s'\n", buf); + void *p; + if (flag) + p = spellerY(buf, seedlen + 1, fp, fparg, charset, i + 1); + else + p = (*fp)(fparg, buf); + if (p) + return p; + } + buf[i] = seed[i]; // going past end of seed[] is ok, as we hit the 0 + } + } + + return NULL; // didn't find any corrections +} + +void *speller(const char *seed, fp_speller_t fp, void *fparg, const char *charset) +{ + size_t seedlen = strlen(seed); + for (int distance = 0; distance < 2; distance++) + { void *p = spellerX(seed, seedlen, fp, fparg, charset, distance); + if (p) + return p; +// if (seedlen > 10) +// break; + } + return NULL; // didn't find it +} + + +#if UNITTEST + +#include +#include +#include + +void *speller_test(void *fparg, const char *s) +{ + //printf("speller_test(%s, %s)\n", fparg, s); + if (strcmp((char *)fparg, s) == 0) + return fparg; + return NULL; +} + +void unittest_speller() +{ + static const char *cases[][3] = + { + { "hello", "hell", "y" }, + { "hello", "hel", "y" }, + { "hello", "ello", "y" }, + { "hello", "llo", "y" }, + { "hello", "hellox", "y" }, + { "hello", "helloxy", "y" }, + { "hello", "xhello", "y" }, + { "hello", "xyhello", "y" }, + { "hello", "ehllo", "y" }, + { "hello", "helol", "y" }, + { "hello", "abcd", "n" }, + //{ "ehllo", "helol", "y" }, + { "hello", "helxxlo", "y" }, + { "hello", "ehlxxlo", "n" }, + { "hello", "heaao", "y" }, + { "_123456789_123456789_123456789_123456789", "_123456789_123456789_123456789_12345678", "y" }, + }; + //printf("unittest_speller()\n"); + const void *p = speller("hello", &speller_test, (void *)"hell", idchars); + assert(p != NULL); + for (int i = 0; i < sizeof(cases)/sizeof(cases[0]); i++) + { + //printf("case [%d]\n", i); + void *p = speller(cases[i][0], &speller_test, (void *)cases[i][1], idchars); + if (p) + assert(cases[i][2][0] == 'y'); + else + assert(cases[i][2][0] == 'n'); + } + //printf("unittest_speller() success\n"); +} + +#endif diff --git a/root/speller.h b/root/speller.h new file mode 100644 index 00000000..bfffb739 --- /dev/null +++ b/root/speller.h @@ -0,0 +1,7 @@ + +typedef void *(fp_speller_t)(void *, const char *); + +extern const char idchars[]; + +void *speller(const char *seed, fp_speller_t fp, void *fparg, const char *charset); + diff --git a/root/stringtable.c b/root/stringtable.c new file mode 100644 index 00000000..f1c0044a --- /dev/null +++ b/root/stringtable.c @@ -0,0 +1,139 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include + +#include "root.h" +#include "rmem.h" +#include "dchar.h" +#include "lstring.h" +#include "stringtable.h" + +void StringTable::init(unsigned size) +{ + table = (void **)mem.calloc(size, sizeof(void *)); + tabledim = size; + count = 0; +} + +StringTable::~StringTable() +{ + unsigned i; + + // Zero out dangling pointers to help garbage collector. + // Should zero out StringEntry's too. + for (i = 0; i < count; i++) + table[i] = NULL; + + mem.free(table); + table = NULL; +} + +struct StringEntry +{ + StringEntry *left; + StringEntry *right; + hash_t hash; + + StringValue value; + + static StringEntry *alloc(const dchar *s, unsigned len); +}; + +StringEntry *StringEntry::alloc(const dchar *s, unsigned len) +{ + StringEntry *se; + + se = (StringEntry *) mem.calloc(1,sizeof(StringEntry) - sizeof(Lstring) + Lstring::size(len)); + se->value.lstring.length = len; + se->hash = Dchar::calcHash(s,len); + memcpy(se->value.lstring.string, s, len * sizeof(dchar)); + return se; +} + +void **StringTable::search(const dchar *s, unsigned len) +{ + hash_t hash; + unsigned u; + int cmp; + StringEntry **se; + + //printf("StringTable::search(%p,%d)\n",s,len); + hash = Dchar::calcHash(s,len); + u = hash % tabledim; + se = (StringEntry **)&table[u]; + //printf("\thash = %d, u = %d\n",hash,u); + while (*se) + { + cmp = (*se)->hash - hash; + if (cmp == 0) + { + cmp = (*se)->value.lstring.len() - len; + if (cmp == 0) + { + cmp = Dchar::memcmp(s,(*se)->value.lstring.toDchars(),len); + if (cmp == 0) + break; + } + } + if (cmp < 0) + se = &(*se)->left; + else + se = &(*se)->right; + } + //printf("\treturn %p, %p\n",se, (*se)); + return (void **)se; +} + +StringValue *StringTable::lookup(const dchar *s, unsigned len) +{ StringEntry *se; + + se = *(StringEntry **)search(s,len); + if (se) + return &se->value; + else + return NULL; +} + +StringValue *StringTable::update(const dchar *s, unsigned len) +{ StringEntry **pse; + StringEntry *se; + + pse = (StringEntry **)search(s,len); + se = *pse; + if (!se) // not in table: so create new entry + { + se = StringEntry::alloc(s, len); + *pse = se; + } + return &se->value; +} + +StringValue *StringTable::insert(const dchar *s, unsigned len) +{ StringEntry **pse; + StringEntry *se; + + pse = (StringEntry **)search(s,len); + se = *pse; + if (se) + return NULL; // error: already in table + else + { + se = StringEntry::alloc(s, len); + *pse = se; + } + return &se->value; +} + + + + diff --git a/root/stringtable.h b/root/stringtable.h new file mode 100644 index 00000000..ce714587 --- /dev/null +++ b/root/stringtable.h @@ -0,0 +1,48 @@ +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#ifndef STRINGTABLE_H +#define STRINGTABLE_H + +#if __SC__ +#pragma once +#endif + +#include "root.h" +#include "dchar.h" +#include "lstring.h" + +struct StringValue +{ + union + { int intvalue; + void *ptrvalue; + dchar *string; + }; + Lstring lstring; +}; + +struct StringTable +{ + void **table; + unsigned count; + unsigned tabledim; + + void init(unsigned size = 37); + ~StringTable(); + + StringValue *lookup(const dchar *s, unsigned len); + StringValue *insert(const dchar *s, unsigned len); + StringValue *update(const dchar *s, unsigned len); + +private: + void **search(const dchar *s, unsigned len); +}; + +#endif diff --git a/root/thread.h b/root/thread.h new file mode 100644 index 00000000..58e53c24 --- /dev/null +++ b/root/thread.h @@ -0,0 +1,12 @@ + +#ifndef THREAD_H +#define THREAD_H 1 + +typedef long ThreadId; + +struct Thread +{ + static ThreadId getId(); +}; + +#endif diff --git a/s2ir.c b/s2ir.c new file mode 100644 index 00000000..172b0515 --- /dev/null +++ b/s2ir.c @@ -0,0 +1,1722 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2000-2011 by Digital Mars +// All Rights Reserved +// Written by Walter Bright +// http://www.digitalmars.com + +#include +#include +#include + +#include "mars.h" +#include "lexer.h" +#include "statement.h" +#include "expression.h" +#include "mtype.h" +#include "dsymbol.h" +#include "declaration.h" +#include "irstate.h" +#include "init.h" +#include "module.h" +#include "enum.h" +#include "aggregate.h" +#include "template.h" +#include "id.h" + +// Back end +#include "cc.h" +#include "type.h" +#include "code.h" +#include "oper.h" +#include "global.h" +#include "dt.h" + +#include "rmem.h" + +static char __file__[] = __FILE__; // for tassert.h +#include "tassert.h" + +elem *callfunc(Loc loc, + IRState *irs, + int directcall, // 1: don't do virtual call + Type *tret, // return type + elem *ec, // evaluates to function address + Type *ectype, // original type of ec + FuncDeclaration *fd, // if !=NULL, this is the function being called + Type *t, // TypeDelegate or TypeFunction for this function + elem *ehidden, // if !=NULL, this is the 'hidden' argument + Expressions *arguments); + +elem *exp2_copytotemp(elem *e); +elem *incUsageElem(IRState *irs, Loc loc); +StructDeclaration *needsPostblit(Type *t); + +#define elem_setLoc(e,loc) ((e)->Esrcpos.Sfilename = (char *)(loc).filename, \ + (e)->Esrcpos.Slinnum = (loc).linnum) + +#define SEH (TARGET_WINDOS) + +/*********************************************** + * Generate code to set index into scope table. + */ + +#if SEH +void setScopeIndex(Blockx *blx, block *b, int scope_index) +{ + block_appendexp(b, nteh_setScopeTableIndex(blx, scope_index)); +} +#else +#define setScopeIndex(blx, b, scope_index) ; +#endif + +/**************************************** + * Allocate a new block, and set the tryblock. + */ + +block *block_calloc(Blockx *blx) +{ + block *b = block_calloc(); + b->Btry = blx->tryblock; + return b; +} + +/************************************** + * Convert label to block. + */ + +block *labelToBlock(Loc loc, Blockx *blx, LabelDsymbol *label, int flag = 0) +{ + if (!label->statement) + { + error(loc, "undefined label %s", label->toChars()); + return NULL; + } + LabelStatement *s = label->statement; + if (!s->lblock) + { s->lblock = block_calloc(blx); + s->lblock->Btry = NULL; // fill this in later + + if (flag) + { + // Keep track of the forward reference to this block, so we can check it later + if (!s->fwdrefs) + s->fwdrefs = new Blocks(); + s->fwdrefs->push(blx->curblock); + } + } + return s->lblock; +} + +/************************************** + * Add in code to increment usage count for linnum. + */ + +void incUsage(IRState *irs, Loc loc) +{ + + if (global.params.cov && loc.linnum) + { + block_appendexp(irs->blx->curblock, incUsageElem(irs, loc)); + } +} + +/**************************************** + * This should be overridden by each statement class. + */ + +void Statement::toIR(IRState *irs) +{ + print(); + assert(0); +} + +/************************************* + */ + +void OnScopeStatement::toIR(IRState *irs) +{ +} + +/**************************************** + */ + +void IfStatement::toIR(IRState *irs) +{ + elem *e; + Blockx *blx = irs->blx; + + //printf("IfStatement::toIR('%s')\n", condition->toChars()); + + IRState mystate(irs, this); + + // bexit is the block that gets control after this IfStatement is done + block *bexit = mystate.breakBlock ? mystate.breakBlock : block_calloc(); + + incUsage(irs, loc); +#if 0 + if (match) + { /* Generate: + * if (match = RTLSYM_IFMATCH(string, pattern)) ... + */ + assert(condition->op == TOKmatch); + e = matchexp_toelem((MatchExp *)condition, &mystate, RTLSYM_IFMATCH); + Symbol *s = match->toSymbol(); + symbol_add(s); + e = el_bin(OPeq, TYnptr, el_var(s), e); + } + else +#endif + e = condition->toElemDtor(&mystate); + block_appendexp(blx->curblock, e); + block *bcond = blx->curblock; + block_next(blx, BCiftrue, NULL); + + list_append(&bcond->Bsucc, blx->curblock); + if (ifbody) + ifbody->toIR(&mystate); + list_append(&blx->curblock->Bsucc, bexit); + + if (elsebody) + { + block_next(blx, BCgoto, NULL); + list_append(&bcond->Bsucc, blx->curblock); + elsebody->toIR(&mystate); + list_append(&blx->curblock->Bsucc, bexit); + } + else + list_append(&bcond->Bsucc, bexit); + + block_next(blx, BCgoto, bexit); + +} + +/************************************** + */ + +#if DMDV2 +void PragmaStatement::toIR(IRState *irs) +{ + //printf("PragmaStatement::toIR()\n"); + if (ident == Id::startaddress) + { + assert(args && args->dim == 1); + Expression *e = args->tdata()[0]; + Dsymbol *sa = getDsymbol(e); + FuncDeclaration *f = sa->isFuncDeclaration(); + assert(f); + Symbol *s = f->toSymbol(); + while (irs->prev) + irs = irs->prev; + irs->startaddress = s; + } +} +#endif + +/*********************** + */ + +void WhileStatement::toIR(IRState *irs) +{ + assert(0); // was "lowered" +#if 0 + Blockx *blx = irs->blx; + + /* Create a new state, because we need a new continue and break target + */ + IRState mystate(irs,this); + mystate.breakBlock = block_calloc(blx); + mystate.contBlock = block_calloc(blx); + + list_append(&blx->curblock->Bsucc, mystate.contBlock); + block_next(blx, BCgoto, mystate.contBlock); + incUsage(irs, loc); + block_appendexp(mystate.contBlock, condition->toElem(&mystate)); + + block_next(blx, BCiftrue, NULL); + + /* curblock is the start of the while loop body + */ + list_append(&mystate.contBlock->Bsucc, blx->curblock); + if (body) + body->toIR(&mystate); + list_append(&blx->curblock->Bsucc, mystate.contBlock); + block_next(blx, BCgoto, mystate.breakBlock); + + list_append(&mystate.contBlock->Bsucc, mystate.breakBlock); +#endif +} + +/****************************************** + */ + +void DoStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + IRState mystate(irs,this); + mystate.breakBlock = block_calloc(blx); + mystate.contBlock = block_calloc(blx); + + block *bpre = blx->curblock; + block_next(blx, BCgoto, NULL); + list_append(&bpre->Bsucc, blx->curblock); + + list_append(&mystate.contBlock->Bsucc, blx->curblock); + list_append(&mystate.contBlock->Bsucc, mystate.breakBlock); + + if (body) + body->toIR(&mystate); + list_append(&blx->curblock->Bsucc, mystate.contBlock); + + block_next(blx, BCgoto, mystate.contBlock); + incUsage(irs, condition->loc); + block_appendexp(mystate.contBlock, condition->toElemDtor(&mystate)); + block_next(blx, BCiftrue, mystate.breakBlock); + +} + +/***************************************** + */ + +void ForStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + IRState mystate(irs,this); + mystate.breakBlock = block_calloc(blx); + mystate.contBlock = block_calloc(blx); + + if (init) + init->toIR(&mystate); + block *bpre = blx->curblock; + block_next(blx,BCgoto,NULL); + block *bcond = blx->curblock; + list_append(&bpre->Bsucc, bcond); + list_append(&mystate.contBlock->Bsucc, bcond); + if (condition) + { + incUsage(irs, condition->loc); + block_appendexp(bcond, condition->toElemDtor(&mystate)); + block_next(blx,BCiftrue,NULL); + list_append(&bcond->Bsucc, blx->curblock); + list_append(&bcond->Bsucc, mystate.breakBlock); + } + else + { /* No conditional, it's a straight goto + */ + block_next(blx,BCgoto,NULL); + list_append(&bcond->Bsucc, blx->curblock); + } + + if (body) + body->toIR(&mystate); + /* End of the body goes to the continue block + */ + list_append(&blx->curblock->Bsucc, mystate.contBlock); + block_next(blx, BCgoto, mystate.contBlock); + + if (increment) + { + incUsage(irs, increment->loc); + block_appendexp(mystate.contBlock, increment->toElemDtor(&mystate)); + } + + /* The 'break' block follows the for statement. + */ + block_next(blx,BCgoto, mystate.breakBlock); +} + + +/************************************** + */ + +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 +} + + +/************************************** + */ + +#if DMDV2 +void ForeachRangeStatement::toIR(IRState *irs) +{ + assert(0); +#if 0 + Type *tab; + elem *eaggr; + elem *elwr; + elem *eupr; + 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); + + incUsage(irs, lwr->loc); + elwr = lwr->toElem(irs); + + incUsage(irs, upr->loc); + eupr = upr->toElem(irs); + + /* Create skey, the index to the array. + * Initialize skey to elwr (foreach) or eupr (foreach_reverse). + */ + Symbol *skey = key->toSymbol(); + symbol_add(skey); + keytym = key->type->totym(); + + elem *ekey; + if (key->offset) // if key is member of a closure + { + assert(irs->sclosure); + ekey = el_var(irs->sclosure); + ekey = el_bin(OPadd, TYnptr, ekey, el_long(TYint, key->offset)); + ekey = el_una(OPind, keytym, ekey); + } + else + ekey = el_var(skey); + + elem *einit = (op == TOKforeach_reverse) ? eupr : elwr; + e = el_bin(OPeq, keytym, ekey, einit); // skey = einit; + block_appendexp(blx->curblock, e); + + /* Make a copy of the end condition, so it only + * gets evaluated once. + */ + elem *eend = (op == TOKforeach_reverse) ? elwr : eupr; + Symbol *send = symbol_genauto(eend); + e = el_bin(OPeq, eend->Ety, el_var(send), eend); + assert(tybasic(e->Ety) != TYstruct); + block_appendexp(blx->curblock, e); + + bpre = blx->curblock; + block_next(blx,BCgoto,NULL); + bcond = blx->curblock; + + if (op == TOKforeach_reverse) + { + // Construct (key > elwr) + e = el_bin(OPgt, TYint, el_copytree(ekey), el_var(send)); + } + else + { + // Construct (key < eupr) + e = el_bin(OPlt, TYint, el_copytree(ekey), el_var(send)); + } + + // The size of the increment + size_t sz = 1; + Type *tkeyb = key->type->toBasetype(); + if (tkeyb->ty == Tpointer) + sz = tkeyb->nextOf()->size(); + + bcond->Belem = e; + block_next(blx, BCiftrue, NULL); + + if (op == TOKforeach_reverse) + { + // Construct (skey -= 1) + e = el_bin(OPminass, keytym, el_copytree(ekey), el_long(keytym, sz)); + 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) + { + // Construct (skey += 1) + e = el_bin(OPaddass, keytym, el_copytree(ekey), el_long(keytym, sz)); + 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 +} +#endif + + +/**************************************** + */ + +void BreakStatement::toIR(IRState *irs) +{ + block *bbreak; + block *b; + Blockx *blx = irs->blx; + + bbreak = irs->getBreakBlock(ident); + assert(bbreak); + b = blx->curblock; + incUsage(irs, loc); + + // Adjust exception handler scope index if in different try blocks + if (b->Btry != bbreak->Btry) + { + //setScopeIndex(blx, b, bbreak->Btry ? bbreak->Btry->Bscope_index : -1); + } + + /* Nothing more than a 'goto' to the current break destination + */ + list_append(&b->Bsucc, bbreak); + block_next(blx, BCgoto, NULL); +} + +/************************************ + */ + +void ContinueStatement::toIR(IRState *irs) +{ + block *bcont; + block *b; + Blockx *blx = irs->blx; + + //printf("ContinueStatement::toIR() %p\n", this); + bcont = irs->getContBlock(ident); + assert(bcont); + b = blx->curblock; + incUsage(irs, loc); + + // Adjust exception handler scope index if in different try blocks + if (b->Btry != bcont->Btry) + { + //setScopeIndex(blx, b, bcont->Btry ? bcont->Btry->Bscope_index : -1); + } + + /* Nothing more than a 'goto' to the current continue destination + */ + list_append(&b->Bsucc, bcont); + block_next(blx, BCgoto, NULL); +} + +/************************************** + */ + +void el_setVolatile(elem *e) +{ + elem_debug(e); + while (1) + { + e->Ety |= mTYvolatile; + if (OTunary(e->Eoper)) + e = e->E1; + else if (OTbinary(e->Eoper)) + { el_setVolatile(e->E2); + e = e->E1; + } + else + break; + } +} + +void VolatileStatement::toIR(IRState *irs) +{ + block *b; + + if (statement) + { + Blockx *blx = irs->blx; + + block_goto(blx, BCgoto, NULL); + b = blx->curblock; + + statement->toIR(irs); + + block_goto(blx, BCgoto, NULL); + + // Mark the blocks generated as volatile + for (; b != blx->curblock; b = b->Bnext) + { b->Bflags |= BFLvolatile; + if (b->Belem) + el_setVolatile(b->Belem); + } + } +} + +/************************************** + */ + +void GotoStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + if (!label->statement) + { error("label %s is undefined", label->toChars()); + return; + } + if (tf != label->statement->tf) + error("cannot goto forward out of or into finally block"); + + block *bdest = labelToBlock(loc, blx, label, 1); + if (!bdest) + return; + block *b = blx->curblock; + incUsage(irs, loc); + + if (b->Btry != bdest->Btry) + { + // Check that bdest is in an enclosing try block + for (block *bt = b->Btry; bt != bdest->Btry; bt = bt->Btry) + { + if (!bt) + { + //printf("b->Btry = %p, bdest->Btry = %p\n", b->Btry, bdest->Btry); + error("cannot goto into try block"); + break; + } + } + } + + list_append(&b->Bsucc,bdest); + block_next(blx,BCgoto,NULL); +} + +void LabelStatement::toIR(IRState *irs) +{ + //printf("LabelStatement::toIR() %p, statement = %p\n", this, statement); + Blockx *blx = irs->blx; + block *bc = blx->curblock; + IRState mystate(irs,this); + mystate.ident = ident; + + if (lblock) + { + // At last, we know which try block this label is inside + lblock->Btry = blx->tryblock; + + /* Go through the forward references and check. + */ + if (fwdrefs) + { + for (size_t i = 0; i < fwdrefs->dim; i++) + { block *b = fwdrefs->tdata()[i]; + + if (b->Btry != lblock->Btry) + { + // Check that lblock is in an enclosing try block + for (block *bt = b->Btry; bt != lblock->Btry; bt = bt->Btry) + { + if (!bt) + { + //printf("b->Btry = %p, lblock->Btry = %p\n", b->Btry, lblock->Btry); + error("cannot goto into try block"); + break; + } + } + } + + } + delete fwdrefs; + fwdrefs = NULL; + } + } + else + lblock = block_calloc(blx); + block_next(blx,BCgoto,lblock); + list_append(&bc->Bsucc,blx->curblock); + if (statement) + statement->toIR(&mystate); +} + +/************************************** + */ + +void SwitchStatement::toIR(IRState *irs) +{ + int string; + Blockx *blx = irs->blx; + + //printf("SwitchStatement::toIR()\n"); + IRState mystate(irs,this); + + mystate.switchBlock = blx->curblock; + + /* Block for where "break" goes to + */ + mystate.breakBlock = block_calloc(blx); + + /* Block for where "default" goes to. + * If there is a default statement, then that is where default goes. + * If not, then do: + * default: break; + * by making the default block the same as the break block. + */ + mystate.defaultBlock = sdefault ? block_calloc(blx) : mystate.breakBlock; + + int numcases = 0; + if (cases) + numcases = cases->dim; + + incUsage(irs, loc); + elem *econd = condition->toElemDtor(&mystate); +#if DMDV2 + if (hasVars) + { /* Generate a sequence of if-then-else blocks for the cases. + */ + if (econd->Eoper != OPvar) + { + elem *e = exp2_copytotemp(econd); + block_appendexp(mystate.switchBlock, e); + econd = e->E2; + } + + for (int i = 0; i < numcases; i++) + { CaseStatement *cs = cases->tdata()[i]; + + elem *ecase = cs->exp->toElemDtor(&mystate); + elem *e = el_bin(OPeqeq, TYbool, el_copytree(econd), ecase); + block *b = blx->curblock; + block_appendexp(b, e); + block *bcase = block_calloc(blx); + cs->cblock = bcase; + block_next(blx, BCiftrue, NULL); + list_append(&b->Bsucc, bcase); + list_append(&b->Bsucc, blx->curblock); + } + + /* The final 'else' clause goes to the default + */ + block *b = blx->curblock; + block_next(blx, BCgoto, NULL); + list_append(&b->Bsucc, mystate.defaultBlock); + + body->toIR(&mystate); + + /* Have the end of the switch body fall through to the block + * following the switch statement. + */ + block_goto(blx, BCgoto, mystate.breakBlock); + return; + } +#endif + + if (condition->type->isString()) + { + // Number the cases so we can unscramble things after the sort() + for (int i = 0; i < numcases; i++) + { CaseStatement *cs = cases->tdata()[i]; + cs->index = i; + } + + cases->sort(); + + /* Create a sorted array of the case strings, and si + * will be the symbol for it. + */ + dt_t *dt = NULL; + Symbol *si = symbol_generate(SCstatic,type_fake(TYdarray)); +#if MACHOBJ + si->Sseg = DATA; +#endif + dtsize_t(&dt, numcases); + dtxoff(&dt, si, PTRSIZE * 2, TYnptr); + + for (int i = 0; i < numcases; i++) + { CaseStatement *cs = cases->tdata()[i]; + + if (cs->exp->op != TOKstring) + { error("case '%s' is not a string", cs->exp->toChars()); // BUG: this should be an assert + } + else + { + StringExp *se = (StringExp *)(cs->exp); + unsigned len = se->len; + dtsize_t(&dt, len); + dtabytes(&dt, TYnptr, 0, se->len * se->sz, (char *)se->string); + } + } + + si->Sdt = dt; + si->Sfl = FLdata; + outdata(si); + + /* Call: + * _d_switch_string(string[] si, string econd) + */ + elem *eparam = el_param(econd, el_var(si)); + switch (condition->type->nextOf()->ty) + { + case Tchar: + econd = el_bin(OPcall, TYint, el_var(rtlsym[RTLSYM_SWITCH_STRING]), eparam); + break; + case Twchar: + econd = el_bin(OPcall, TYint, el_var(rtlsym[RTLSYM_SWITCH_USTRING]), eparam); + break; + case Tdchar: // BUG: implement + econd = el_bin(OPcall, TYint, el_var(rtlsym[RTLSYM_SWITCH_DSTRING]), eparam); + break; + default: + assert(0); + } + elem_setLoc(econd, loc); + string = 1; + } + else + string = 0; + block_appendexp(mystate.switchBlock, econd); + block_next(blx,BCswitch,NULL); + + // Corresponding free is in block_free + targ_llong *pu = (targ_llong *) ::malloc(sizeof(*pu) * (numcases + 1)); + mystate.switchBlock->BS.Bswitch = pu; + /* First pair is the number of cases, and the default block + */ + *pu++ = numcases; + list_append(&mystate.switchBlock->Bsucc, mystate.defaultBlock); + + /* Fill in the first entry in each pair, which is the case value. + * CaseStatement::toIR() will fill in + * the second entry for each pair with the block. + */ + for (int i = 0; i < numcases; i++) + { + CaseStatement *cs = cases->tdata()[i]; + if (string) + { + pu[cs->index] = i; + } + else + { + pu[i] = cs->exp->toInteger(); + } + } + + body->toIR(&mystate); + + /* Have the end of the switch body fall through to the block + * following the switch statement. + */ + block_goto(blx, BCgoto, mystate.breakBlock); +} + +void CaseStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + block *bcase = blx->curblock; + if (!cblock) + cblock = block_calloc(blx); + block_next(blx,BCgoto,cblock); + block *bsw = irs->getSwitchBlock(); + if (bsw->BC == BCswitch) + list_append(&bsw->Bsucc,cblock); // second entry in pair + list_append(&bcase->Bsucc,cblock); + if (blx->tryblock != bsw->Btry) + error("case cannot be in different try block level from switch"); + incUsage(irs, loc); + if (statement) + statement->toIR(irs); +} + +void DefaultStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + block *bcase = blx->curblock; + block *bdefault = irs->getDefaultBlock(); + block_next(blx,BCgoto,bdefault); + list_append(&bcase->Bsucc,blx->curblock); + if (blx->tryblock != irs->getSwitchBlock()->Btry) + error("default cannot be in different try block level from switch"); + incUsage(irs, loc); + if (statement) + statement->toIR(irs); +} + +void GotoDefaultStatement::toIR(IRState *irs) +{ + block *b; + Blockx *blx = irs->blx; + block *bdest = irs->getDefaultBlock(); + + b = blx->curblock; + + // The rest is equivalent to GotoStatement + + // Adjust exception handler scope index if in different try blocks + if (b->Btry != bdest->Btry) + { + // Check that bdest is in an enclosing try block + for (block *bt = b->Btry; bt != bdest->Btry; bt = bt->Btry) + { + if (!bt) + { + //printf("b->Btry = %p, bdest->Btry = %p\n", b->Btry, bdest->Btry); + error("cannot goto into try block"); + break; + } + } + + //setScopeIndex(blx, b, bdest->Btry ? bdest->Btry->Bscope_index : -1); + } + + list_append(&b->Bsucc,bdest); + incUsage(irs, loc); + block_next(blx,BCgoto,NULL); +} + +void GotoCaseStatement::toIR(IRState *irs) +{ + block *b; + Blockx *blx = irs->blx; + block *bdest = cs->cblock; + + if (!bdest) + { + bdest = block_calloc(blx); + cs->cblock = bdest; + } + + b = blx->curblock; + + // The rest is equivalent to GotoStatement + + // Adjust exception handler scope index if in different try blocks + if (b->Btry != bdest->Btry) + { + // Check that bdest is in an enclosing try block + for (block *bt = b->Btry; bt != bdest->Btry; bt = bt->Btry) + { + if (!bt) + { + //printf("b->Btry = %p, bdest->Btry = %p\n", b->Btry, bdest->Btry); + error("cannot goto into try block"); + break; + } + } + + //setScopeIndex(blx, b, bdest->Btry ? bdest->Btry->Bscope_index : -1); + } + + list_append(&b->Bsucc,bdest); + incUsage(irs, loc); + block_next(blx,BCgoto,NULL); +} + +void SwitchErrorStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + //printf("SwitchErrorStatement::toIR()\n"); + + elem *efilename = el_ptr(blx->module->toSymbol()); + elem *elinnum = el_long(TYint, loc.linnum); + elem *e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DSWITCHERR]), el_param(elinnum, efilename)); + block_appendexp(blx->curblock, e); +} + +/************************************** + */ + +void ReturnStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + incUsage(irs, loc); + if (exp) + { elem *e; + + FuncDeclaration *func = irs->getFunc(); + assert(func); + assert(func->type->ty == Tfunction); + TypeFunction *tf = (TypeFunction *)(func->type); + + enum RET retmethod = tf->retStyle(); + if (retmethod == RETstack) + { + elem *es; + + /* If returning struct literal, write result + * directly into return value + */ + if (exp->op == TOKstructliteral) + { StructLiteralExp *se = (StructLiteralExp *)exp; + char save[sizeof(StructLiteralExp)]; + memcpy(save, se, sizeof(StructLiteralExp)); + se->sym = irs->shidden; + se->soffset = 0; + se->fillHoles = 1; + e = exp->toElemDtor(irs); + memcpy(se, save, sizeof(StructLiteralExp)); + + } + else + e = exp->toElemDtor(irs); + assert(e); + + if (exp->op == TOKstructliteral || + (func->nrvo_can && func->nrvo_var)) + { + // Return value via hidden pointer passed as parameter + // Write exp; return shidden; + es = e; + } + else + { + // Return value via hidden pointer passed as parameter + // Write *shidden=exp; return shidden; + int op; + tym_t ety; + + ety = e->Ety; + es = el_una(OPind,ety,el_var(irs->shidden)); + op = (tybasic(ety) == TYstruct) ? OPstreq : OPeq; + es = el_bin(op, ety, es, e); + if (op == OPstreq) + es->ET = exp->type->toCtype(); +#if DMDV2 + /* Call postBlit() on *shidden + */ + Type *tb = exp->type->toBasetype(); + //if (tb->ty == Tstruct) exp->dump(0); + if ((exp->op == TOKvar || exp->op == TOKdotvar || exp->op == TOKstar || exp->op == TOKthis) && + tb->ty == Tstruct) + { StructDeclaration *sd = ((TypeStruct *)tb)->sym; + if (sd->postblit) + { FuncDeclaration *fd = sd->postblit; + if (fd->storage_class & STCdisable) + { + fd->toParent()->error(loc, "is not copyable because it is annotated with @disable"); + } + elem *ec = el_var(irs->shidden); + ec = callfunc(loc, irs, 1, Type::tvoid, ec, tb->pointerTo(), fd, fd->type, NULL, NULL); + es = el_bin(OPcomma, ec->Ety, es, ec); + } + +#if 0 + /* It has been moved, so disable destructor + */ + if (exp->op == TOKvar) + { VarExp *ve = (VarExp *)exp; + VarDeclaration *v = ve->var->isVarDeclaration(); + if (v && v->rundtor) + { + elem *er = el_var(v->rundtor->toSymbol()); + er = el_bin(OPeq, TYint, er, el_long(TYint, 0)); + es = el_bin(OPcomma, TYint, es, er); + } + } +#endif + } +#endif + } + e = el_var(irs->shidden); + e = el_bin(OPcomma, e->Ety, es, e); + } +#if DMDV2 + else if (tf->isref) + { // Reference return, so convert to a pointer + Expression *ae = exp->addressOf(NULL); + e = ae->toElemDtor(irs); + } +#endif + else + { + e = exp->toElemDtor(irs); + assert(e); + } + + elem_setLoc(e, loc); + block_appendexp(blx->curblock, e); + block_next(blx, BCretexp, NULL); + } + else + block_next(blx, BCret, NULL); +} + +/************************************** + */ + +void ExpStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + //printf("ExpStatement::toIR(), exp = %s\n", exp ? exp->toChars() : ""); + incUsage(irs, loc); + if (exp) + block_appendexp(blx->curblock,exp->toElemDtor(irs)); +} + +/************************************** + */ + +void DtorExpStatement::toIR(IRState *irs) +{ + //printf("DtorExpStatement::toIR(), exp = %s\n", exp ? exp->toChars() : ""); + + FuncDeclaration *fd = irs->getFunc(); + assert(fd); + if (fd->nrvo_can && fd->nrvo_var == var) + /* Do not call destructor, because var is returned as the nrvo variable. + * This is done at this stage because nrvo can be turned off at a + * very late stage in semantic analysis. + */ + ; + else + { + ExpStatement::toIR(irs); + } +} + +/************************************** + */ + +void CompoundStatement::toIR(IRState *irs) +{ + if (statements) + { + size_t dim = statements->dim; + for (size_t i = 0 ; i < dim ; i++) + { + Statement *s = statements->tdata()[i]; + if (s != NULL) + { + s->toIR(irs); + } + } + } +} + + +/************************************** + */ + +void UnrolledLoopStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + + IRState mystate(irs, this); + mystate.breakBlock = block_calloc(blx); + + block *bpre = blx->curblock; + block_next(blx, BCgoto, NULL); + + block *bdo = blx->curblock; + list_append(&bpre->Bsucc, bdo); + + block *bdox; + + size_t dim = statements->dim; + for (size_t i = 0 ; i < dim ; i++) + { + Statement *s = statements->tdata()[i]; + if (s != NULL) + { + mystate.contBlock = block_calloc(blx); + + s->toIR(&mystate); + + bdox = blx->curblock; + block_next(blx, BCgoto, mystate.contBlock); + list_append(&bdox->Bsucc, mystate.contBlock); + } + } + + bdox = blx->curblock; + block_next(blx, BCgoto, mystate.breakBlock); + list_append(&bdox->Bsucc, mystate.breakBlock); +} + + +/************************************** + */ + +void ScopeStatement::toIR(IRState *irs) +{ + if (statement) + { + Blockx *blx = irs->blx; + IRState mystate(irs,this); + + if (mystate.prev->ident) + mystate.ident = mystate.prev->ident; + + statement->toIR(&mystate); + + if (mystate.breakBlock) + block_goto(blx,BCgoto,mystate.breakBlock); + } +} + +/*************************************** + */ + +void WithStatement::toIR(IRState *irs) +{ + Symbol *sp; + elem *e; + elem *ei; + ExpInitializer *ie; + Blockx *blx = irs->blx; + + //printf("WithStatement::toIR()\n"); + if (exp->op == TOKimport || exp->op == TOKtype) + { + } + else + { + // Declare with handle + sp = wthis->toSymbol(); + symbol_add(sp); + + // Perform initialization of with handle + ie = wthis->init->isExpInitializer(); + assert(ie); + ei = ie->exp->toElemDtor(irs); + e = el_var(sp); + e = el_bin(OPeq,e->Ety, e, ei); + elem_setLoc(e, loc); + incUsage(irs, loc); + block_appendexp(blx->curblock,e); + } + // Execute with block + if (body) + body->toIR(irs); +} + + +/*************************************** + */ + +void ThrowStatement::toIR(IRState *irs) +{ + // throw(exp) + + Blockx *blx = irs->blx; + + incUsage(irs, loc); + elem *e = exp->toElemDtor(irs); + e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_THROWC]),e); + block_appendexp(blx->curblock, e); +} + +/*************************************** + * Builds the following: + * _try + * block + * jcatch + * handler + * A try-catch statement. + */ + +void TryCatchStatement::toIR(IRState *irs) +{ + Blockx *blx = irs->blx; + +#if SEH + nteh_declarvars(blx); +#endif + + IRState mystate(irs, this); + + block *tryblock = block_goto(blx,BCgoto,NULL); + + int previndex = blx->scope_index; + tryblock->Blast_index = previndex; + blx->scope_index = tryblock->Bscope_index = blx->next_index++; + + // Set the current scope index + setScopeIndex(blx,tryblock,tryblock->Bscope_index); + + // This is the catch variable + tryblock->jcatchvar = symbol_genauto(type_fake(mTYvolatile | TYnptr)); + + blx->tryblock = tryblock; + block *breakblock = block_calloc(blx); + block_goto(blx,BC_try,NULL); + if (body) + { + body->toIR(&mystate); + } + blx->tryblock = tryblock->Btry; + + // break block goes here + block_goto(blx, BCgoto, breakblock); + + setScopeIndex(blx,blx->curblock, previndex); + blx->scope_index = previndex; + + // create new break block that follows all the catches + breakblock = block_calloc(blx); + + list_append(&blx->curblock->Bsucc, breakblock); + block_next(blx,BCgoto,NULL); + + assert(catches); + for (size_t i = 0 ; i < catches->dim; i++) + { + Catch *cs = catches->tdata()[i]; + if (cs->var) + cs->var->csym = tryblock->jcatchvar; + block *bcatch = blx->curblock; + if (cs->type) + bcatch->Bcatchtype = cs->type->toBasetype()->toSymbol(); + list_append(&tryblock->Bsucc,bcatch); + block_goto(blx,BCjcatch,NULL); + if (cs->handler != NULL) + { + IRState catchState(irs, this); + cs->handler->toIR(&catchState); + } + list_append(&blx->curblock->Bsucc, breakblock); + block_next(blx, BCgoto, NULL); + } + + block_next(blx,(enum BC)blx->curblock->BC, breakblock); +} + +/**************************************** + * A try-finally statement. + * Builds the following: + * _try + * block + * _finally + * finalbody + * _ret + */ + +void TryFinallyStatement::toIR(IRState *irs) +{ + //printf("TryFinallyStatement::toIR()\n"); + + Blockx *blx = irs->blx; + +#if SEH + nteh_declarvars(blx); +#endif + + block *tryblock = block_goto(blx, BCgoto, NULL); + + int previndex = blx->scope_index; + tryblock->Blast_index = previndex; + tryblock->Bscope_index = blx->next_index++; + blx->scope_index = tryblock->Bscope_index; + + // Current scope index + setScopeIndex(blx,tryblock,tryblock->Bscope_index); + + blx->tryblock = tryblock; + block_goto(blx,BC_try,NULL); + + IRState bodyirs(irs, this); + block *breakblock = block_calloc(blx); + block *contblock = block_calloc(blx); + + if (body) + body->toIR(&bodyirs); + blx->tryblock = tryblock->Btry; // back to previous tryblock + + setScopeIndex(blx,blx->curblock,previndex); + blx->scope_index = previndex; + + block_goto(blx,BCgoto, breakblock); + block *finallyblock = block_goto(blx,BCgoto,contblock); + + list_append(&tryblock->Bsucc,finallyblock); + + block_goto(blx,BC_finally,NULL); + + IRState finallyState(irs, this); + breakblock = block_calloc(blx); + contblock = block_calloc(blx); + + setScopeIndex(blx, blx->curblock, previndex); + if (finalbody) + finalbody->toIR(&finallyState); + block_goto(blx, BCgoto, contblock); + block_goto(blx, BCgoto, breakblock); + + block *retblock = blx->curblock; + block_next(blx,BC_ret,NULL); + + list_append(&finallyblock->Bsucc, blx->curblock); + list_append(&retblock->Bsucc, blx->curblock); +} + +/**************************************** + */ + +void SynchronizedStatement::toIR(IRState *irs) +{ + assert(0); +} + + +/**************************************** + */ + +void AsmStatement::toIR(IRState *irs) +{ + block *bpre; + block *basm; + Declaration *d; + Symbol *s; + Blockx *blx = irs->blx; + + //printf("AsmStatement::toIR(asmcode = %x)\n", asmcode); + bpre = blx->curblock; + block_next(blx,BCgoto,NULL); + basm = blx->curblock; + list_append(&bpre->Bsucc, basm); + basm->Bcode = asmcode; + basm->Balign = asmalign; +#if 0 + if (label) + { block *b; + + b = labelToBlock(loc, blx, label); + printf("AsmStatement::toIR() %p\n", b); + if (b) + list_append(&basm->Bsucc, b); + } +#endif + // Loop through each instruction, fixing Dsymbols into Symbol's + for (code *c = asmcode; c; c = c->next) + { LabelDsymbol *label; + block *b; + + switch (c->IFL1) + { + case FLblockoff: + case FLblock: + // FLblock and FLblockoff have LabelDsymbol's - convert to blocks + label = c->IEVlsym1; + b = labelToBlock(loc, blx, label); + list_append(&basm->Bsucc, b); + c->IEV1.Vblock = b; + break; + + case FLdsymbol: + case FLfunc: + s = c->IEVdsym1->toSymbol(); + if (s->Sclass == SCauto && s->Ssymnum == -1) + symbol_add(s); + c->IEVsym1 = s; + c->IFL1 = s->Sfl ? s->Sfl : FLauto; + break; + } + + // Repeat for second operand + switch (c->IFL2) + { + case FLblockoff: + case FLblock: + label = c->IEVlsym2; + b = labelToBlock(loc, blx, label); + list_append(&basm->Bsucc, b); + c->IEV2.Vblock = b; + break; + + case FLdsymbol: + case FLfunc: + d = c->IEVdsym2; + s = d->toSymbol(); + if (s->Sclass == SCauto && s->Ssymnum == -1) + symbol_add(s); + c->IEVsym2 = s; + c->IFL2 = s->Sfl ? s->Sfl : FLauto; + if (d->isDataseg()) + s->Sflags |= SFLlivexit; + break; + } + //c->print(); + } + + basm->bIasmrefparam = refparam; // are parameters reference? + basm->usIasmregs = regs; // registers modified + + block_next(blx,BCasm, NULL); + list_prepend(&basm->Bsucc, blx->curblock); + + if (naked) + { + blx->funcsym->Stype->Tty |= mTYnaked; + } +} + +/**************************************** + */ + +void ImportStatement::toIR(IRState *irs) +{ +} + + + diff --git a/scope.c b/scope.c new file mode 100644 index 00000000..44215108 --- /dev/null +++ b/scope.c @@ -0,0 +1,399 @@ + +// Copyright (c) 1999-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "speller.h" + +#include "mars.h" +#include "init.h" +#include "identifier.h" +#include "scope.h" +#include "attrib.h" +#include "dsymbol.h" +#include "declaration.h" +#include "aggregate.h" +#include "module.h" +#include "id.h" +#include "lexer.h" + +Scope *Scope::freelist = NULL; + +void *Scope::operator new(size_t size) +{ + if (freelist) + { + Scope *s = freelist; + freelist = s->enclosing; + //printf("freelist %p\n", s); + assert(s->flags & SCOPEfree); + s->flags &= ~SCOPEfree; + return s; + } + + void *p = ::operator new(size); + //printf("new %p\n", p); + return p; +} + +Scope::Scope() +{ // Create root scope + + //printf("Scope::Scope() %p\n", this); + this->module = NULL; + this->scopesym = NULL; + this->sd = NULL; + this->enclosing = NULL; + this->parent = NULL; + this->sw = NULL; + this->tf = NULL; + this->tinst = NULL; + this->sbreak = NULL; + this->scontinue = NULL; + this->fes = NULL; + this->structalign = global.structalign; + this->func = NULL; + this->slabel = NULL; + this->linkage = LINKd; + this->protection = PROTpublic; + this->explicitProtection = 0; + this->stc = 0; + this->offset = 0; + this->inunion = 0; + this->incontract = 0; + this->nofree = 0; + this->noctor = 0; + this->noaccesscheck = 0; + this->mustsemantic = 0; + this->intypeof = 0; + this->parameterSpecialization = 0; + this->callSuper = 0; + this->flags = 0; + this->anonAgg = NULL; + this->lastdc = NULL; + this->lastoffset = 0; + this->docbuf = NULL; +} + +Scope::Scope(Scope *enclosing) +{ + //printf("Scope::Scope(enclosing = %p) %p\n", enclosing, this); + assert(!(enclosing->flags & SCOPEfree)); + this->module = enclosing->module; + this->func = enclosing->func; + this->parent = enclosing->parent; + this->scopesym = NULL; + this->sd = NULL; + this->sw = enclosing->sw; + this->tf = enclosing->tf; + this->tinst = enclosing->tinst; + this->sbreak = enclosing->sbreak; + this->scontinue = enclosing->scontinue; + this->fes = enclosing->fes; + this->structalign = enclosing->structalign; + this->enclosing = enclosing; +#ifdef DEBUG + if (enclosing->enclosing) + assert(!(enclosing->enclosing->flags & SCOPEfree)); + if (this == enclosing->enclosing) + { + printf("this = %p, enclosing = %p, enclosing->enclosing = %p\n", this, enclosing, enclosing->enclosing); + } + assert(this != enclosing->enclosing); +#endif + this->slabel = NULL; + this->linkage = enclosing->linkage; + this->protection = enclosing->protection; + this->explicitProtection = enclosing->explicitProtection; + this->stc = enclosing->stc; + this->offset = 0; + this->inunion = enclosing->inunion; + this->incontract = enclosing->incontract; + this->nofree = 0; + this->noctor = enclosing->noctor; + this->noaccesscheck = enclosing->noaccesscheck; + this->mustsemantic = enclosing->mustsemantic; + this->intypeof = enclosing->intypeof; + this->parameterSpecialization = enclosing->parameterSpecialization; + this->callSuper = enclosing->callSuper; + this->flags = 0; + this->anonAgg = NULL; + this->lastdc = NULL; + this->lastoffset = 0; + this->docbuf = enclosing->docbuf; + assert(this != enclosing); +} + +Scope *Scope::createGlobal(Module *module) +{ + Scope *sc; + + sc = new Scope(); + sc->module = module; + sc->scopesym = new ScopeDsymbol(); + sc->scopesym->symtab = new DsymbolTable(); + + // Add top level package as member of this global scope + Dsymbol *m = module; + while (m->parent) + m = m->parent; + m->addMember(NULL, sc->scopesym, 1); + m->parent = NULL; // got changed by addMember() + + // Create the module scope underneath the global scope + sc = sc->push(module); + sc->parent = module; + return sc; +} + +Scope *Scope::push() +{ + //printf("Scope::push()\n"); + Scope *s = new Scope(this); + assert(this != s); + return s; +} + +Scope *Scope::push(ScopeDsymbol *ss) +{ + //printf("Scope::push(%s)\n", ss->toChars()); + Scope *s = push(); + s->scopesym = ss; + return s; +} + +Scope *Scope::pop() +{ + //printf("Scope::pop() %p nofree = %d\n", this, nofree); + Scope *enc = enclosing; + + if (enclosing) + enclosing->callSuper |= callSuper; + + if (!nofree) + { enclosing = freelist; + freelist = this; + flags |= SCOPEfree; + } + + return enc; +} + +void Scope::mergeCallSuper(Loc loc, unsigned cs) +{ + // This does a primitive flow analysis to support the restrictions + // regarding when and how constructors can appear. + // It merges the results of two paths. + // The two paths are callSuper and cs; the result is merged into callSuper. + + if (cs != callSuper) + { int a; + int b; + + callSuper |= cs & (CSXany_ctor | CSXlabel); + if (cs & CSXreturn) + { + } + else if (callSuper & CSXreturn) + { + callSuper = cs | (callSuper & (CSXany_ctor | CSXlabel)); + } + else + { + a = (cs & (CSXthis_ctor | CSXsuper_ctor)) != 0; + b = (callSuper & (CSXthis_ctor | CSXsuper_ctor)) != 0; + if (a != b) + error(loc, "one path skips constructor"); + callSuper |= cs; + } + } +} + +Dsymbol *Scope::search(Loc loc, Identifier *ident, Dsymbol **pscopesym) +{ Dsymbol *s; + Scope *sc; + + //printf("Scope::search(%p, '%s')\n", this, ident->toChars()); + if (ident == Id::empty) + { + // Look for module scope + for (sc = this; sc; sc = sc->enclosing) + { + assert(sc != sc->enclosing); + if (sc->scopesym) + { + s = sc->scopesym->isModule(); + if (s) + { + //printf("\tfound %s.%s\n", s->parent ? s->parent->toChars() : "", s->toChars()); + if (pscopesym) + *pscopesym = sc->scopesym; + return s; + } + } + } + return NULL; + } + + for (sc = this; sc; sc = sc->enclosing) + { + assert(sc != sc->enclosing); + if (sc->scopesym) + { + //printf("\tlooking in scopesym '%s', kind = '%s'\n", sc->scopesym->toChars(), sc->scopesym->kind()); + s = sc->scopesym->search(loc, ident, 0); + if (s) + { + if ((global.params.warnings || + global.params.Dversion > 1) && + ident == Id::length && + sc->scopesym->isArrayScopeSymbol() && + sc->enclosing && + sc->enclosing->search(loc, ident, NULL)) + { + warning(s->loc, "array 'length' hides other 'length' name in outer scope"); + } + + //printf("\tfound %s.%s, kind = '%s'\n", s->parent ? s->parent->toChars() : "", s->toChars(), s->kind()); + if (pscopesym) + *pscopesym = sc->scopesym; + return s; + } + } + } + + return NULL; +} + +Dsymbol *Scope::insert(Dsymbol *s) +{ Scope *sc; + + for (sc = this; sc; sc = sc->enclosing) + { + //printf("\tsc = %p\n", sc); + if (sc->scopesym) + { + //printf("\t\tsc->scopesym = %p\n", sc->scopesym); + if (!sc->scopesym->symtab) + sc->scopesym->symtab = new DsymbolTable(); + return sc->scopesym->symtabInsert(s); + } + } + assert(0); + return NULL; +} + +/******************************************** + * Search enclosing scopes for ClassDeclaration. + */ + +ClassDeclaration *Scope::getClassScope() +{ Scope *sc; + + for (sc = this; sc; sc = sc->enclosing) + { + ClassDeclaration *cd; + + if (sc->scopesym) + { + cd = sc->scopesym->isClassDeclaration(); + if (cd) + return cd; + } + } + return NULL; +} + +/******************************************** + * Search enclosing scopes for ClassDeclaration. + */ + +AggregateDeclaration *Scope::getStructClassScope() +{ Scope *sc; + + for (sc = this; sc; sc = sc->enclosing) + { + AggregateDeclaration *ad; + + if (sc->scopesym) + { + ad = sc->scopesym->isClassDeclaration(); + if (ad) + return ad; + else + { ad = sc->scopesym->isStructDeclaration(); + if (ad) + return ad; + } + } + } + return NULL; +} + +/******************************************* + * For TemplateDeclarations, we need to remember the Scope + * where it was declared. So mark the Scope as not + * to be free'd. + */ + +void Scope::setNoFree() +{ Scope *sc; + //int i = 0; + + //printf("Scope::setNoFree(this = %p)\n", this); + for (sc = this; sc; sc = sc->enclosing) + { + //printf("\tsc = %p\n", sc); + sc->nofree = 1; + + assert(!(flags & SCOPEfree)); + //assert(sc != sc->enclosing); + //assert(!sc->enclosing || sc != sc->enclosing->enclosing); + //if (++i == 10) + //assert(0); + } +} + + +/************************************************ + * Given the failed search attempt, try to find + * one with a close spelling. + */ + +void *scope_search_fp(void *arg, const char *seed) +{ + //printf("scope_search_fp('%s')\n", seed); + + /* If not in the lexer's string table, it certainly isn't in the symbol table. + * Doing this first is a lot faster. + */ + size_t len = strlen(seed); + if (!len) + return NULL; + StringValue *sv = Lexer::stringtable.lookup(seed, len); + if (!sv) + return NULL; + Identifier *id = (Identifier *)sv->ptrvalue; + assert(id); + + Scope *sc = (Scope *)arg; + Module::clearCache(); + Dsymbol *s = sc->search(0, id, NULL); + return s; +} + +Dsymbol *Scope::search_correct(Identifier *ident) +{ + if (global.gag) + return NULL; // don't do it for speculative compiles; too time consuming + + return (Dsymbol *)speller(ident->toChars(), &scope_search_fp, this, idchars); +} diff --git a/scope.h b/scope.h new file mode 100644 index 00000000..d8c371f2 --- /dev/null +++ b/scope.h @@ -0,0 +1,122 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_SCOPE_H +#define DMD_SCOPE_H + +#ifdef __DMC__ +#pragma once +#endif + +struct Dsymbol; +struct ScopeDsymbol; +struct Identifier; +struct Module; +struct Statement; +struct SwitchStatement; +struct TryFinallyStatement; +struct LabelStatement; +struct ForeachStatement; +struct ClassDeclaration; +struct AggregateDeclaration; +struct AnonymousAggregateDeclaration; +struct FuncDeclaration; +struct DocComment; +struct TemplateInstance; + +#if __GNUC__ +// Requires a full definition for PROT and LINK +#include "dsymbol.h" // PROT +#include "mars.h" // LINK +#else +enum LINK; +enum PROT; +#endif + +struct Scope +{ + Scope *enclosing; // enclosing Scope + + Module *module; // Root module + ScopeDsymbol *scopesym; // current symbol + ScopeDsymbol *sd; // if in static if, and declaring new symbols, + // sd gets the addMember() + FuncDeclaration *func; // function we are in + Dsymbol *parent; // parent to use + LabelStatement *slabel; // enclosing labelled statement + SwitchStatement *sw; // enclosing switch statement + TryFinallyStatement *tf; // enclosing try finally statement + TemplateInstance *tinst; // enclosing template instance + Statement *sbreak; // enclosing statement that supports "break" + Statement *scontinue; // enclosing statement that supports "continue" + ForeachStatement *fes; // if nested function for ForeachStatement, this is it + unsigned offset; // next offset to use in aggregate + int inunion; // we're processing members of a union + int incontract; // we're inside contract code + int nofree; // set if shouldn't free it + int noctor; // set if constructor calls aren't allowed + int intypeof; // in typeof(exp) + int parameterSpecialization; // if in template parameter specialization + int noaccesscheck; // don't do access checks + int mustsemantic; // cannot defer semantic() + + unsigned callSuper; // primitive flow analysis for constructors +#define CSXthis_ctor 1 // called this() +#define CSXsuper_ctor 2 // called super() +#define CSXthis 4 // referenced this +#define CSXsuper 8 // referenced super +#define CSXlabel 0x10 // seen a label +#define CSXreturn 0x20 // seen a return statement +#define CSXany_ctor 0x40 // either this() or super() was called + + unsigned structalign; // alignment for struct members + enum LINK linkage; // linkage for external functions + + enum PROT protection; // protection for class members + int explicitProtection; // set if in an explicit protection attribute + + StorageClass stc; // storage class + + unsigned flags; +#define SCOPEctor 1 // constructor type +#define SCOPEstaticif 2 // inside static if +#define SCOPEfree 4 // is on free list +#define SCOPEstaticassert 8 // inside static assert +#define SCOPEdebug 0x10 // inside debug conditional + + AnonymousAggregateDeclaration *anonAgg; // for temporary analysis + + DocComment *lastdc; // documentation comment for last symbol at this scope + unsigned lastoffset; // offset in docbuf of where to insert next dec + OutBuffer *docbuf; // buffer for documentation output + + static Scope *freelist; + static void *operator new(size_t sz); + static Scope *createGlobal(Module *module); + + Scope(); + Scope(Module *module); + Scope(Scope *enclosing); + + Scope *push(); + Scope *push(ScopeDsymbol *ss); + Scope *pop(); + + void mergeCallSuper(Loc loc, unsigned cs); + + Dsymbol *search(Loc loc, Identifier *ident, Dsymbol **pscopesym); + Dsymbol *search_correct(Identifier *ident); + Dsymbol *insert(Dsymbol *s); + + ClassDeclaration *getClassScope(); + AggregateDeclaration *getStructClassScope(); + void setNoFree(); +}; + +#endif /* DMD_SCOPE_H */ diff --git a/sideeffect.c b/sideeffect.c new file mode 100644 index 00000000..a80f874e --- /dev/null +++ b/sideeffect.c @@ -0,0 +1,250 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "mars.h" +#include "init.h" +#include "expression.h" +#include "template.h" +#include "statement.h" +#include "mtype.h" +#include "utf.h" +#include "declaration.h" +#include "aggregate.h" +#include "scope.h" +#include "attrib.h" + +int lambdaHasSideEffect(Expression *e, void *param); + +/******************************************** + * Determine if Expression has any side effects. + */ + +bool Expression::hasSideEffect() +{ + bool has = FALSE; + apply(&lambdaHasSideEffect, &has); + return has; +} + +int lambdaHasSideEffect(Expression *e, void *param) +{ + bool *phas = (bool *)param; + switch (e->op) + { + // Sort the cases by most frequently used first + case TOKassign: + case TOKplusplus: + case TOKminusminus: + case TOKdeclaration: + case TOKconstruct: + case TOKblit: + case TOKaddass: + case TOKminass: + case TOKcatass: + case TOKmulass: + case TOKdivass: + case TOKmodass: + case TOKshlass: + case TOKshrass: + case TOKushrass: + case TOKandass: + case TOKorass: + case TOKxorass: + case TOKpowass: + case TOKin: + case TOKremove: + case TOKassert: + case TOKhalt: + case TOKdelete: + case TOKnew: + case TOKnewanonclass: + *phas = TRUE; + break; + + case TOKcall: + { CallExp *ce = (CallExp *)e; + + /* Calling a function or delegate that is pure nothrow + * has no side effects. + */ + if (ce->e1->type) + { + Type *t = ce->e1->type->toBasetype(); + if ((t->ty == Tfunction && ((TypeFunction *)t)->purity > PUREweak && + ((TypeFunction *)t)->isnothrow) + || + (t->ty == Tdelegate && ((TypeFunction *)((TypeDelegate *)t)->next)->purity > PUREweak && + ((TypeFunction *)((TypeDelegate *)t)->next)->isnothrow) + ) + { + } + else + *phas = TRUE; + } + break; + } + + case TOKcast: + { CastExp *ce = (CastExp *)e; + + /* if: + * cast(classtype)func() // because it may throw + */ + if (ce->to->ty == Tclass && ce->e1->op == TOKcall && ce->e1->type->ty == Tclass) + *phas = TRUE; + break; + } + + default: + break; + } + return *phas; // stop walking if we determine this expression has side effects +} + + +/*********************************** + * The result of this expression will be discarded. + * Complain if the operation has no side effects (and hence is meaningless). + */ +void Expression::discardValue() +{ + bool has = FALSE; + lambdaHasSideEffect(this, &has); + if (!has) + { + switch (op) + { + case TOKcast: + { CastExp *ce = (CastExp *)this; + if (ce->to->equals(Type::tvoid)) + { /* + * Don't complain about an expression with no effect if it was cast to void + */ + ce->e1->useValue(); + break; + } + goto Ldefault; // complain + } + + case TOKerror: + break; + + case TOKcall: + /* Don't complain about calling functions with no effect, + * because purity and nothrow are inferred, and because some of the + * runtime library depends on it. Needs more investigation. + */ + break; + + case TOKimport: + error("%s has no effect", toChars()); + break; + + case TOKandand: + { AndAndExp *aae = (AndAndExp *)this; + aae->e1->useValue(); + aae->e2->discardValue(); + break; + } + + case TOKoror: + { OrOrExp *ooe = (OrOrExp *)this; + ooe->e1->useValue(); + ooe->e2->discardValue(); + break; + } + + case TOKquestion: + { CondExp *ce = (CondExp *)this; + ce->econd->useValue(); + ce->e1->discardValue(); + ce->e2->discardValue(); + break; + } + + case TOKcomma: + { CommaExp *ce = (CommaExp *)this; + + /* Check for compiler-generated code of the form auto __tmp, e, __tmp; + * In such cases, only check e for side effect (it's OK for __tmp to have + * no side effect). + * See Bugzilla 4231 for discussion + */ + CommaExp* firstComma = ce; + while (firstComma->e1->op == TOKcomma) + firstComma = (CommaExp *)firstComma->e1; + if (firstComma->e1->op == TOKdeclaration && + ce->e2->op == TOKvar && + ((DeclarationExp *)firstComma->e1)->declaration == ((VarExp*)ce->e2)->var) + { + ce->e1->useValue(); + break; + } + // Don't check e1 until we cast(void) the a,b code generation + //ce->e1->discardValue(); + ce->e2->discardValue(); + break; + } + + case TOKtuple: + /* Pass without complaint if any of the tuple elements have side effects. + * Ideally any tuple elements with no side effects should raise an error, + * this needs more investigation as to what is the right thing to do. + */ + if (!hasSideEffect()) + goto Ldefault; + break; + + default: + Ldefault: + error("%s has no effect in expression (%s)", + Token::toChars(op), toChars()); + break; + } + } + else + { + useValue(); + } +} + +/* This isn't used yet because the only way an expression has an unused sub-expression + * is with the CommaExp, and that currently generates messages from rewrites into comma + * expressions. Needs more investigation. + */ +void Expression::useValue() +{ +#if 0 + // Disabled because need to cast(void) the a,b code generation + void *p; + apply(&lambdaUseValue, &p); +#endif +} + +#if 0 +int lambdaUseValue(Expression *e, void *param) +{ + switch (e->op) + { + case TOKcomma: + { CommaExp *ce = (CommaExp *)e; + discardValue(ce->E1); + break; + } + + default: + break; + } + return 0; +} +#endif diff --git a/statement.c b/statement.c new file mode 100644 index 00000000..bc8a55c4 --- /dev/null +++ b/statement.c @@ -0,0 +1,5100 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "rmem.h" + +#include "statement.h" +#include "expression.h" +#include "cond.h" +#include "init.h" +#include "staticassert.h" +#include "mtype.h" +#include "scope.h" +#include "declaration.h" +#include "aggregate.h" +#include "id.h" +#include "hdrgen.h" +#include "parse.h" +#include "template.h" +#include "attrib.h" + +extern int os_critsecsize32(); +extern int os_critsecsize64(); + +/******************************** Statement ***************************/ + +Statement::Statement(Loc loc) + : loc(loc) +{ + // If this is an in{} contract scope statement (skip for determining + // inlineStatus of a function body for header content) + incontract = 0; +} + +Statement *Statement::syntaxCopy() +{ + assert(0); + return NULL; +} + +void Statement::print() +{ + fprintf(stdmsg, "%s\n", toChars()); + fflush(stdmsg); +} + +char *Statement::toChars() +{ OutBuffer *buf; + HdrGenState hgs; + + buf = new OutBuffer(); + toCBuffer(buf, &hgs); + return buf->toChars(); +} + +void Statement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("Statement::toCBuffer()"); + buf->writenl(); +} + +Statement *Statement::semantic(Scope *sc) +{ + return this; +} + +Statement *Statement::semanticNoScope(Scope *sc) +{ + //printf("Statement::semanticNoScope() %s\n", toChars()); + Statement *s = this; + if (!s->isCompoundStatement() && !s->isScopeStatement()) + { + s = new CompoundStatement(loc, this); // so scopeCode() gets called + } + s = s->semantic(sc); + return s; +} + +// Same as semanticNoScope(), but do create a new scope + +Statement *Statement::semanticScope(Scope *sc, Statement *sbreak, Statement *scontinue) +{ + Scope *scd = sc->push(); + if (sbreak) + scd->sbreak = sbreak; + if (scontinue) + scd->scontinue = scontinue; + Statement *s = semanticNoScope(scd); + scd->pop(); + return s; +} + +void Statement::error(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + ::verror(loc, format, ap); + va_end( ap ); +} + +void Statement::warning(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + ::vwarning(loc, format, ap); + va_end( ap ); +} + +int Statement::hasBreak() +{ + //printf("Statement::hasBreak()\n"); + return FALSE; +} + +int Statement::hasContinue() +{ + return FALSE; +} + +// TRUE if statement uses exception handling + +int Statement::usesEH() +{ + return FALSE; +} + +/* Only valid after semantic analysis + * If 'mustNotThrow' is true, generate an error if it throws + */ +int Statement::blockExit(bool mustNotThrow) +{ + printf("Statement::blockExit(%p)\n", this); + printf("%s\n", toChars()); + assert(0); + return BEany; +} + +// TRUE if statement 'comes from' somewhere else, like a goto + +int Statement::comeFrom() +{ + //printf("Statement::comeFrom()\n"); + return FALSE; +} + +// Return TRUE if statement has no code in it +int Statement::isEmpty() +{ + //printf("Statement::isEmpty()\n"); + return FALSE; +} + +Statement *Statement::last() +{ + return this; +} + +/**************************************** + * If this statement has code that needs to run in a finally clause + * at the end of the current scope, return that code in the form of + * a Statement. + * Output: + * *sentry code executed upon entry to the scope + * *sexception code executed upon exit from the scope via exception + * *sfinally code executed in finally block + */ + +Statement *Statement::scopeCode(Scope *sc, Statement **sentry, Statement **sexception, Statement **sfinally) +{ + //printf("Statement::scopeCode()\n"); + //print(); + *sentry = NULL; + *sexception = NULL; + *sfinally = NULL; + return this; +} + +/********************************* + * Flatten out the scope by presenting the statement + * as an array of statements. + * Returns NULL if no flattening necessary. + */ + +Statements *Statement::flatten(Scope *sc) +{ + return NULL; +} + + +/******************************** PeelStatement ***************************/ + +PeelStatement::PeelStatement(Statement *s) + : Statement(s->loc) +{ + this->s = s; +} + +Statement *PeelStatement::semantic(Scope *sc) +{ + /* "peel" off this wrapper, and don't run semantic() + * on the result. + */ + return s; +} + +/******************************** ExpStatement ***************************/ + +ExpStatement::ExpStatement(Loc loc, Expression *exp) + : Statement(loc) +{ + this->exp = exp; +} + +ExpStatement::ExpStatement(Loc loc, Dsymbol *declaration) + : Statement(loc) +{ + this->exp = new DeclarationExp(loc, declaration); +} + +Statement *ExpStatement::syntaxCopy() +{ + Expression *e = exp ? exp->syntaxCopy() : NULL; + ExpStatement *es = new ExpStatement(loc, e); + return es; +} + +void ExpStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (exp) + { exp->toCBuffer(buf, hgs); + if (exp->op != TOKdeclaration) + { buf->writeByte(';'); + if (!hgs->FLinit.init) + buf->writenl(); + } + } + else + { + buf->writeByte(';'); + if (!hgs->FLinit.init) + buf->writenl(); + } +} + +Statement *ExpStatement::semantic(Scope *sc) +{ + if (exp) + { + //printf("ExpStatement::semantic() %s\n", exp->toChars()); + +#if 0 // Doesn't work because of difficulty dealing with things like a.b.c!(args).Foo!(args) + // See if this should be rewritten as a TemplateMixin + if (exp->op == TOKdeclaration) + { DeclarationExp *de = (DeclarationExp *)exp; + Dsymbol *s = de->declaration; + + printf("s: %s %s\n", s->kind(), s->toChars()); + VarDeclaration *v = s->isVarDeclaration(); + if (v) + { + printf("%s, %d\n", v->type->toChars(), v->type->ty); + } + } +#endif + + exp = exp->semantic(sc); + exp = exp->addDtorHook(sc); + exp = resolveProperties(sc, exp); + exp->discardValue(); + exp = exp->optimize(0); + } + return this; +} + +int ExpStatement::blockExit(bool mustNotThrow) +{ int result = BEfallthru; + + if (exp) + { + if (exp->op == TOKhalt) + return BEhalt; + if (exp->op == TOKassert) + { AssertExp *a = (AssertExp *)exp; + + if (a->e1->isBool(FALSE)) // if it's an assert(0) + return BEhalt; + } + if (exp->canThrow(mustNotThrow)) + result |= BEthrow; + } + return result; +} + +int ExpStatement::isEmpty() +{ + return exp == NULL; +} + +Statement *ExpStatement::scopeCode(Scope *sc, Statement **sentry, Statement **sexception, Statement **sfinally) +{ + //printf("ExpStatement::scopeCode()\n"); + //print(); + + *sentry = NULL; + *sexception = NULL; + *sfinally = NULL; + + if (exp) + { + if (exp->op == TOKdeclaration) + { + DeclarationExp *de = (DeclarationExp *)(exp); + VarDeclaration *v = de->declaration->isVarDeclaration(); + if (v && !v->noscope && !v->isDataseg()) + { + Expression *e = v->edtor; + if (e) + { + //printf("dtor is: "); e->print(); +#if 0 + if (v->type->toBasetype()->ty == Tstruct) + { /* Need a 'gate' to turn on/off destruction, + * in case v gets moved elsewhere. + */ + Identifier *id = Lexer::uniqueId("__runDtor"); + ExpInitializer *ie = new ExpInitializer(loc, new IntegerExp(1)); + VarDeclaration *rd = new VarDeclaration(loc, Type::tint32, id, ie); + *sentry = new ExpStatement(loc, rd); + v->rundtor = rd; + + /* Rewrite e as: + * rundtor && e + */ + Expression *ve = new VarExp(loc, v->rundtor); + e = new AndAndExp(loc, ve, e); + e->type = Type::tbool; + } +#endif + *sfinally = new DtorExpStatement(loc, e, v); + } + v->noscope = 1; // don't add in dtor again + } + } + } + return this; +} + + +/******************************** DtorExpStatement ***************************/ + +DtorExpStatement::DtorExpStatement(Loc loc, Expression *exp, VarDeclaration *v) + : ExpStatement(loc, exp) +{ + this->var = v; +} + +Statement *DtorExpStatement::syntaxCopy() +{ + Expression *e = exp ? exp->syntaxCopy() : NULL; + DtorExpStatement *es = new DtorExpStatement(loc, e, var); + return es; +} + +/******************************** CompileStatement ***************************/ + +CompileStatement::CompileStatement(Loc loc, Expression *exp) + : Statement(loc) +{ + this->exp = exp; +} + +Statement *CompileStatement::syntaxCopy() +{ + Expression *e = exp->syntaxCopy(); + CompileStatement *es = new CompileStatement(loc, e); + return es; +} + +void CompileStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("mixin("); + exp->toCBuffer(buf, hgs); + buf->writestring(");"); + if (!hgs->FLinit.init) + buf->writenl(); +} + +Statements *CompileStatement::flatten(Scope *sc) +{ + //printf("CompileStatement::flatten() %s\n", exp->toChars()); + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + exp = exp->optimize(WANTvalue | WANTinterpret); + if (exp->op == TOKerror) + return NULL; + StringExp *se = exp->toString(); + if (!se) + { error("argument to mixin must be a string, not (%s)", exp->toChars()); + return NULL; + } + se = se->toUTF8(sc); + Parser p(sc->module, (unsigned char *)se->string, se->len, 0); + p.loc = loc; + p.nextToken(); + + Statements *a = new Statements(); + while (p.token.value != TOKeof) + { + Statement *s = p.parseStatement(PSsemi | PScurlyscope); + if (s) // if no parsing errors + a->push(s); + } + return a; +} + +Statement *CompileStatement::semantic(Scope *sc) +{ + //printf("CompileStatement::semantic() %s\n", exp->toChars()); + Statements *a = flatten(sc); + if (!a) + return NULL; + Statement *s = new CompoundStatement(loc, a); + return s->semantic(sc); +} + +int CompileStatement::blockExit(bool mustNotThrow) +{ + assert(global.errors); + return BEfallthru; +} + + +/******************************** CompoundStatement ***************************/ + +CompoundStatement::CompoundStatement(Loc loc, Statements *s) + : Statement(loc) +{ + statements = s; +} + +CompoundStatement::CompoundStatement(Loc loc, Statement *s1, Statement *s2) + : Statement(loc) +{ + statements = new Statements(); + statements->reserve(2); + statements->push(s1); + statements->push(s2); +} + +CompoundStatement::CompoundStatement(Loc loc, Statement *s1) + : Statement(loc) +{ + statements = new Statements(); + statements->push(s1); +} + +Statement *CompoundStatement::syntaxCopy() +{ + Statements *a = new Statements(); + a->setDim(statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + s = s->syntaxCopy(); + (*a)[i] = s; + } + CompoundStatement *cs = new CompoundStatement(loc, a); + return cs; +} + + +Statement *CompoundStatement::semantic(Scope *sc) +{ Statement *s; + + //printf("CompoundStatement::semantic(this = %p, sc = %p)\n", this, sc); + +#if 0 + for (size_t i = 0; i < statements->dim; i++) + { + s = (*statements)[i]; + if (s) + printf("[%d]: %s", i, s->toChars()); + } +#endif + + for (size_t i = 0; i < statements->dim; ) + { + s = (*statements)[i]; + if (s) + { Statements *a = s->flatten(sc); + + if (a) + { + statements->remove(i); + statements->insert(i, a); + continue; + } + s = s->semantic(sc); + (*statements)[i] = s; + if (s) + { + Statement *sentry; + Statement *sexception; + Statement *sfinally; + + (*statements)[i] = s->scopeCode(sc, &sentry, &sexception, &sfinally); + if (sentry) + { + sentry = sentry->semantic(sc); + statements->insert(i, sentry); + i++; + } + if (sexception) + sexception = sexception->semantic(sc); + if (sexception) + { + if (i + 1 == statements->dim && !sfinally) + { + } + else + { + /* Rewrite: + * s; s1; s2; + * As: + * s; + * try { s1; s2; } + * catch (Object __o) + * { sexception; throw __o; } + */ + Statements *a = new Statements(); + for (size_t j = i + 1; j < statements->dim; j++) + { + a->push((*statements)[j]); + } + Statement *body = new CompoundStatement(0, a); + body = new ScopeStatement(0, body); + + Identifier *id = Lexer::uniqueId("__o"); + + Statement *handler = sexception; + if (sexception->blockExit(FALSE) & BEfallthru) + { handler = new ThrowStatement(0, new IdentifierExp(0, id)); + handler = new CompoundStatement(0, sexception, handler); + } + + Catches *catches = new Catches(); + Catch *ctch = new Catch(0, NULL, id, handler); + catches->push(ctch); + s = new TryCatchStatement(0, body, catches); + + if (sfinally) + s = new TryFinallyStatement(0, s, sfinally); + s = s->semantic(sc); + statements->setDim(i + 1); + statements->push(s); + break; + } + } + else if (sfinally) + { + if (0 && i + 1 == statements->dim) + { + statements->push(sfinally); + } + else + { + /* Rewrite: + * s; s1; s2; + * As: + * s; try { s1; s2; } finally { sfinally; } + */ + Statements *a = new Statements(); + for (size_t j = i + 1; j < statements->dim; j++) + { + a->push((*statements)[j]); + } + Statement *body = new CompoundStatement(0, a); + s = new TryFinallyStatement(0, body, sfinally); + s = s->semantic(sc); + statements->setDim(i + 1); + statements->push(s); + break; + } + } + } + } + i++; + } + if (statements->dim == 1) + { + return (*statements)[0]; + } + return this; +} + +Statements *CompoundStatement::flatten(Scope *sc) +{ + return statements; +} + +ReturnStatement *CompoundStatement::isReturnStatement() +{ + ReturnStatement *rs = NULL; + + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + rs = s->isReturnStatement(); + if (rs) + break; + } + } + return rs; +} + +Statement *CompoundStatement::last() +{ + Statement *s = NULL; + + for (size_t i = statements->dim; i; --i) + { s = (*statements)[i - 1]; + if (s) + { + s = s->last(); + if (s) + break; + } + } + return s; +} + +void CompoundStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + s->toCBuffer(buf, hgs); + } +} + +int CompoundStatement::usesEH() +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s && s->usesEH()) + return TRUE; + } + return FALSE; +} + +int CompoundStatement::blockExit(bool mustNotThrow) +{ + //printf("CompoundStatement::blockExit(%p) %d\n", this, statements->dim); + int result = BEfallthru; + Statement *slast = NULL; + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + //printf("result = x%x\n", result); + //printf("%s\n", s->toChars()); + if (global.params.warnings && result & BEfallthru && slast) + { + slast = slast->last(); + if (slast && (slast->isCaseStatement() || slast->isDefaultStatement()) && + (s->isCaseStatement() || s->isDefaultStatement())) + { + // Allow if last case/default was empty + CaseStatement *sc = slast->isCaseStatement(); + DefaultStatement *sd = slast->isDefaultStatement(); + if (sc && sc->statement->isEmpty()) + ; + else if (sd && sd->statement->isEmpty()) + ; + else + s->error("switch case fallthrough - use 'goto %s;' if intended", + s->isCaseStatement() ? "case" : "default"); + } + } + + if (!(result & BEfallthru) && !s->comeFrom()) + { + if (s->blockExit(mustNotThrow) != BEhalt && !s->isEmpty()) + s->warning("statement is not reachable"); + } + else + { + result &= ~BEfallthru; + result |= s->blockExit(mustNotThrow); + } + slast = s; + } + } + return result; +} + +int CompoundStatement::comeFrom() +{ int comefrom = FALSE; + + //printf("CompoundStatement::comeFrom()\n"); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + + if (!s) + continue; + + comefrom |= s->comeFrom(); + } + return comefrom; +} + +int CompoundStatement::isEmpty() +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s && !s->isEmpty()) + return FALSE; + } + return TRUE; +} + + +/******************************** CompoundDeclarationStatement ***************************/ + +CompoundDeclarationStatement::CompoundDeclarationStatement(Loc loc, Statements *s) + : CompoundStatement(loc, s) +{ + statements = s; +} + +Statement *CompoundDeclarationStatement::syntaxCopy() +{ + Statements *a = new Statements(); + a->setDim(statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + s = s->syntaxCopy(); + (*a)[i] = s; + } + CompoundDeclarationStatement *cs = new CompoundDeclarationStatement(loc, a); + return cs; +} + +void CompoundDeclarationStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + int nwritten = 0; + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + ExpStatement *ds; + if (s && + (ds = s->isExpStatement()) != NULL && + ds->exp->op == TOKdeclaration) + { + DeclarationExp *de = (DeclarationExp *)ds->exp; + Declaration *d = de->declaration->isDeclaration(); + assert(d); + VarDeclaration *v = d->isVarDeclaration(); + if (v) + { + /* This essentially copies the part of VarDeclaration::toCBuffer() + * that does not print the type. + * Should refactor this. + */ + if (nwritten) + { + buf->writeByte(','); + buf->writestring(v->ident->toChars()); + } + else + { + StorageClassDeclaration::stcToCBuffer(buf, v->storage_class); + if (v->type) + v->type->toCBuffer(buf, v->ident, hgs); + else + buf->writestring(v->ident->toChars()); + } + + if (v->init) + { buf->writestring(" = "); +#if DMDV2 + ExpInitializer *ie = v->init->isExpInitializer(); + if (ie && (ie->exp->op == TOKconstruct || ie->exp->op == TOKblit)) + ((AssignExp *)ie->exp)->e2->toCBuffer(buf, hgs); + else +#endif + v->init->toCBuffer(buf, hgs); + } + } + else + d->toCBuffer(buf, hgs); + nwritten++; + } + } + buf->writeByte(';'); + if (!hgs->FLinit.init) + buf->writenl(); +} + +/**************************** UnrolledLoopStatement ***************************/ + +UnrolledLoopStatement::UnrolledLoopStatement(Loc loc, Statements *s) + : Statement(loc) +{ + statements = s; +} + +Statement *UnrolledLoopStatement::syntaxCopy() +{ + Statements *a = new Statements(); + a->setDim(statements->dim); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + s = s->syntaxCopy(); + (*a)[i] = s; + } + UnrolledLoopStatement *cs = new UnrolledLoopStatement(loc, a); + return cs; +} + + +Statement *UnrolledLoopStatement::semantic(Scope *sc) +{ + //printf("UnrolledLoopStatement::semantic(this = %p, sc = %p)\n", this, sc); + + sc->noctor++; + Scope *scd = sc->push(); + scd->sbreak = this; + scd->scontinue = this; + + for (size_t i = 0; i < statements->dim; i++) + { + Statement *s = (*statements)[i]; + if (s) + { + //printf("[%d]: %s\n", i, s->toChars()); + s = s->semantic(scd); + (*statements)[i] = s; + } + } + + scd->pop(); + sc->noctor--; + return this; +} + +void UnrolledLoopStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("unrolled {"); + buf->writenl(); + + for (size_t i = 0; i < statements->dim; i++) + { Statement *s; + + s = (*statements)[i]; + if (s) + s->toCBuffer(buf, hgs); + } + + buf->writeByte('}'); + buf->writenl(); +} + +int UnrolledLoopStatement::hasBreak() +{ + return TRUE; +} + +int UnrolledLoopStatement::hasContinue() +{ + return TRUE; +} + +int UnrolledLoopStatement::usesEH() +{ + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s && s->usesEH()) + return TRUE; + } + return FALSE; +} + +int UnrolledLoopStatement::blockExit(bool mustNotThrow) +{ + int result = BEfallthru; + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + if (s) + { + int r = s->blockExit(mustNotThrow); + result |= r & ~(BEbreak | BEcontinue); + } + } + return result; +} + + +int UnrolledLoopStatement::comeFrom() +{ int comefrom = FALSE; + + //printf("UnrolledLoopStatement::comeFrom()\n"); + for (size_t i = 0; i < statements->dim; i++) + { Statement *s = (*statements)[i]; + + if (!s) + continue; + + comefrom |= s->comeFrom(); + } + return comefrom; +} + + +/******************************** ScopeStatement ***************************/ + +ScopeStatement::ScopeStatement(Loc loc, Statement *s) + : Statement(loc) +{ + this->statement = s; +} + +Statement *ScopeStatement::syntaxCopy() +{ + Statement *s; + + s = statement ? statement->syntaxCopy() : NULL; + s = new ScopeStatement(loc, s); + return s; +} + + +Statement *ScopeStatement::semantic(Scope *sc) +{ ScopeDsymbol *sym; + + //printf("ScopeStatement::semantic(sc = %p)\n", sc); + if (statement) + { Statements *a; + + sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + a = statement->flatten(sc); + if (a) + { + statement = new CompoundStatement(loc, a); + } + + statement = statement->semantic(sc); + if (statement) + { + Statement *sentry; + Statement *sexception; + Statement *sfinally; + + statement = statement->scopeCode(sc, &sentry, &sexception, &sfinally); + assert(!sentry); + assert(!sexception); + if (sfinally) + { + //printf("adding sfinally\n"); + sfinally = sfinally->semantic(sc); + statement = new CompoundStatement(loc, statement, sfinally); + } + } + + sc->pop(); + } + return this; +} + +int ScopeStatement::hasBreak() +{ + //printf("ScopeStatement::hasBreak() %s\n", toChars()); + return statement ? statement->hasBreak() : FALSE; +} + +int ScopeStatement::hasContinue() +{ + return statement ? statement->hasContinue() : FALSE; +} + +int ScopeStatement::usesEH() +{ + return statement ? statement->usesEH() : FALSE; +} + +int ScopeStatement::blockExit(bool mustNotThrow) +{ + //printf("ScopeStatement::blockExit(%p)\n", statement); + return statement ? statement->blockExit(mustNotThrow) : BEfallthru; +} + + +int ScopeStatement::comeFrom() +{ + //printf("ScopeStatement::comeFrom()\n"); + return statement ? statement->comeFrom() : FALSE; +} + +int ScopeStatement::isEmpty() +{ + //printf("ScopeStatement::isEmpty() %d\n", statement ? statement->isEmpty() : TRUE); + return statement ? statement->isEmpty() : TRUE; +} + +void ScopeStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writeByte('{'); + buf->writenl(); + + if (statement) + statement->toCBuffer(buf, hgs); + + buf->writeByte('}'); + buf->writenl(); +} + +/******************************** WhileStatement ***************************/ + +WhileStatement::WhileStatement(Loc loc, Expression *c, Statement *b) + : Statement(loc) +{ + condition = c; + body = b; +} + +Statement *WhileStatement::syntaxCopy() +{ + WhileStatement *s = new WhileStatement(loc, condition->syntaxCopy(), body ? body->syntaxCopy() : NULL); + return s; +} + + +Statement *WhileStatement::semantic(Scope *sc) +{ + /* Rewrite as a for(;condition;) loop + */ + + Statement *s = new ForStatement(loc, NULL, condition, NULL, body); + s = s->semantic(sc); + return s; +} + +int WhileStatement::hasBreak() +{ + return TRUE; +} + +int WhileStatement::hasContinue() +{ + return TRUE; +} + +int WhileStatement::usesEH() +{ + assert(0); + return body ? body->usesEH() : 0; +} + +int WhileStatement::blockExit(bool mustNotThrow) +{ + assert(0); + //printf("WhileStatement::blockExit(%p)\n", this); + + int result = BEnone; + if (condition->canThrow(mustNotThrow)) + result |= BEthrow; + if (condition->isBool(TRUE)) + { + if (body) + { result |= body->blockExit(mustNotThrow); + if (result & BEbreak) + result |= BEfallthru; + } + } + else if (condition->isBool(FALSE)) + { + result |= BEfallthru; + } + else + { + if (body) + result |= body->blockExit(mustNotThrow); + result |= BEfallthru; + } + result &= ~(BEbreak | BEcontinue); + return result; +} + + +int WhileStatement::comeFrom() +{ + assert(0); + if (body) + return body->comeFrom(); + return FALSE; +} + +void WhileStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("while ("); + condition->toCBuffer(buf, hgs); + buf->writebyte(')'); + buf->writenl(); + if (body) + body->toCBuffer(buf, hgs); +} + +/******************************** DoStatement ***************************/ + +DoStatement::DoStatement(Loc loc, Statement *b, Expression *c) + : Statement(loc) +{ + body = b; + condition = c; +} + +Statement *DoStatement::syntaxCopy() +{ + DoStatement *s = new DoStatement(loc, body ? body->syntaxCopy() : NULL, condition->syntaxCopy()); + return s; +} + + +Statement *DoStatement::semantic(Scope *sc) +{ + sc->noctor++; + if (body) + body = body->semanticScope(sc, this, this); + sc->noctor--; + condition = condition->semantic(sc); + condition = resolveProperties(sc, condition); + condition = condition->optimize(WANTvalue); + + condition = condition->checkToBoolean(sc); + + return this; +} + +int DoStatement::hasBreak() +{ + return TRUE; +} + +int DoStatement::hasContinue() +{ + return TRUE; +} + +int DoStatement::usesEH() +{ + return body ? body->usesEH() : 0; +} + +int DoStatement::blockExit(bool mustNotThrow) +{ int result; + + if (body) + { result = body->blockExit(mustNotThrow); + if (result == BEbreak) + return BEfallthru; + if (result & BEcontinue) + result |= BEfallthru; + } + else + result = BEfallthru; + if (result & BEfallthru) + { + if (condition->canThrow(mustNotThrow)) + result |= BEthrow; + if (!(result & BEbreak) && condition->isBool(TRUE)) + result &= ~BEfallthru; + } + result &= ~(BEbreak | BEcontinue); + return result; +} + + +int DoStatement::comeFrom() +{ + if (body) + return body->comeFrom(); + return FALSE; +} + +void DoStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("do"); + buf->writenl(); + if (body) + body->toCBuffer(buf, hgs); + buf->writestring("while ("); + condition->toCBuffer(buf, hgs); + buf->writestring(");"); +} + +/******************************** ForStatement ***************************/ + +ForStatement::ForStatement(Loc loc, Statement *init, Expression *condition, Expression *increment, Statement *body) + : Statement(loc) +{ + this->init = init; + this->condition = condition; + this->increment = increment; + this->body = body; +} + +Statement *ForStatement::syntaxCopy() +{ + Statement *i = NULL; + if (init) + i = init->syntaxCopy(); + Expression *c = NULL; + if (condition) + c = condition->syntaxCopy(); + Expression *inc = NULL; + if (increment) + inc = increment->syntaxCopy(); + ForStatement *s = new ForStatement(loc, i, c, inc, body->syntaxCopy()); + return s; +} + +Statement *ForStatement::semantic(Scope *sc) +{ + ScopeDsymbol *sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + sc = sc->push(sym); + if (init) + init = init->semantic(sc); + sc->noctor++; + if (condition) + { + condition = condition->semantic(sc); + condition = resolveProperties(sc, condition); + condition = condition->optimize(WANTvalue); + condition = condition->checkToBoolean(sc); + } + if (increment) + { increment = increment->semantic(sc); + increment = resolveProperties(sc, increment); + increment = increment->optimize(0); + } + + sc->sbreak = this; + sc->scontinue = this; + if (body) + body = body->semanticNoScope(sc); + sc->noctor--; + + sc->pop(); + return this; +} + +Statement *ForStatement::scopeCode(Scope *sc, Statement **sentry, Statement **sexception, Statement **sfinally) +{ + //printf("ForStatement::scopeCode()\n"); + //print(); + if (init) + init = init->scopeCode(sc, sentry, sexception, sfinally); + else + Statement::scopeCode(sc, sentry, sexception, sfinally); + return this; +} + +int ForStatement::hasBreak() +{ + //printf("ForStatement::hasBreak()\n"); + return TRUE; +} + +int ForStatement::hasContinue() +{ + return TRUE; +} + +int ForStatement::usesEH() +{ + return (init && init->usesEH()) || body->usesEH(); +} + +int ForStatement::blockExit(bool mustNotThrow) +{ int result = BEfallthru; + + if (init) + { result = init->blockExit(mustNotThrow); + if (!(result & BEfallthru)) + return result; + } + if (condition) + { if (condition->canThrow(mustNotThrow)) + result |= BEthrow; + if (condition->isBool(TRUE)) + result &= ~BEfallthru; + else if (condition->isBool(FALSE)) + return result; + } + else + result &= ~BEfallthru; // the body must do the exiting + if (body) + { int r = body->blockExit(mustNotThrow); + if (r & (BEbreak | BEgoto)) + result |= BEfallthru; + result |= r & ~(BEfallthru | BEbreak | BEcontinue); + } + if (increment && increment->canThrow(mustNotThrow)) + result |= BEthrow; + return result; +} + + +int ForStatement::comeFrom() +{ + //printf("ForStatement::comeFrom()\n"); + if (body) + { int result = body->comeFrom(); + //printf("result = %d\n", result); + return result; + } + return FALSE; +} + +void ForStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("for ("); + if (init) + { + hgs->FLinit.init++; + init->toCBuffer(buf, hgs); + hgs->FLinit.init--; + } + else + buf->writebyte(';'); + if (condition) + { buf->writebyte(' '); + condition->toCBuffer(buf, hgs); + } + buf->writebyte(';'); + if (increment) + { buf->writebyte(' '); + increment->toCBuffer(buf, hgs); + } + buf->writebyte(')'); + buf->writenl(); + buf->writebyte('{'); + buf->writenl(); + body->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); +} + +/******************************** ForeachStatement ***************************/ + +ForeachStatement::ForeachStatement(Loc loc, enum TOK op, Parameters *arguments, + Expression *aggr, Statement *body) + : Statement(loc) +{ + this->op = op; + this->arguments = arguments; + this->aggr = aggr; + this->body = body; + + this->key = NULL; + this->value = NULL; + + this->func = NULL; + + this->cases = NULL; + this->gotos = NULL; +} + +Statement *ForeachStatement::syntaxCopy() +{ + Parameters *args = Parameter::arraySyntaxCopy(arguments); + Expression *exp = aggr->syntaxCopy(); + ForeachStatement *s = new ForeachStatement(loc, op, args, exp, + body ? body->syntaxCopy() : NULL); + return s; +} + +Statement *ForeachStatement::semantic(Scope *sc) +{ + //printf("ForeachStatement::semantic() %p\n", this); + ScopeDsymbol *sym; + Statement *s = this; + size_t dim = arguments->dim; + TypeAArray *taa = NULL; + Dsymbol *sapply = NULL; + + Type *tn = NULL; + Type *tnv = NULL; + + func = sc->func; + if (func->fes) + func = func->fes->func; + + if (!inferAggregate(sc, sapply)) + { + error("invalid foreach aggregate %s", aggr->toChars()); + return this; + } + + /* Check for inference errors + */ + if (!inferApplyArgTypes(sc, sapply)) + { + //printf("dim = %d, arguments->dim = %d\n", dim, arguments->dim); + error("cannot uniquely infer foreach argument types"); + return this; + } + + Type *tab = aggr->type->toBasetype(); + + if (tab->ty == Ttuple) // don't generate new scope for tuple loops + { + if (dim < 1 || dim > 2) + { + error("only one (value) or two (key,value) arguments for tuple foreach"); + return s; + } + + TypeTuple *tuple = (TypeTuple *)tab; + Statements *statements = new Statements(); + //printf("aggr: op = %d, %s\n", aggr->op, aggr->toChars()); + size_t n; + TupleExp *te = NULL; + Expression *prelude = NULL; + if (aggr->op == TOKtuple) // expression tuple + { te = (TupleExp *)aggr; + n = te->exps->dim; + + if (te->exps->dim > 0 && (*te->exps)[0]->op == TOKdotvar && + ((DotVarExp *)(*te->exps)[0])->e1->isTemp()) + { + CommaExp *ce = (CommaExp *)((DotVarExp *)(*te->exps)[0])->e1; + + prelude = ce->e1; + ((DotVarExp *)(*te->exps)[0])->e1 = ce->e2; + } + } + else if (aggr->op == TOKtype) // type tuple + { + n = Parameter::dim(tuple->arguments); + } + else + assert(0); + for (size_t j = 0; j < n; j++) + { size_t k = (op == TOKforeach) ? j : n - 1 - j; + Expression *e; + Type *t; + if (te) + e = (*te->exps)[k]; + else + t = Parameter::getNth(tuple->arguments, k)->type; + Parameter *arg = (*arguments)[0]; + Statements *st = new Statements(); + + if (dim == 2) + { // Declare key + if (arg->storageClass & (STCout | STCref | STClazy)) + error("no storage class for key %s", arg->ident->toChars()); + arg->type = arg->type->semantic(loc, sc); + TY keyty = arg->type->ty; + if (keyty != Tint32 && keyty != Tuns32) + { + if (global.params.is64bit) + { + if (keyty != Tint64 && keyty != Tuns64) + error("foreach: key type must be int or uint, long or ulong, not %s", arg->type->toChars()); + } + else + error("foreach: key type must be int or uint, not %s", arg->type->toChars()); + } + Initializer *ie = new ExpInitializer(0, new IntegerExp(k)); + VarDeclaration *var = new VarDeclaration(loc, arg->type, arg->ident, ie); + var->storage_class |= STCmanifest; + DeclarationExp *de = new DeclarationExp(loc, var); + st->push(new ExpStatement(loc, de)); + arg = (*arguments)[1]; // value + } + // Declare value + if (arg->storageClass & (STCout | STClazy) || + arg->storageClass & STCref && !te) + error("no storage class for value %s", arg->ident->toChars()); + Dsymbol *var; + if (te) + { Type *tb = e->type->toBasetype(); + Dsymbol *s = NULL; + if ((tb->ty == Tfunction || tb->ty == Tsarray) && e->op == TOKvar) + s = ((VarExp *)e)->var; + else if (e->op == TOKtemplate) + s =((TemplateExp *)e)->td; + else if (e->op == TOKimport) + s =((ScopeExp *)e)->sds; + + if (s) + { + var = new AliasDeclaration(loc, arg->ident, s); + if (arg->storageClass & STCref) + error("symbol %s cannot be ref", s->toChars()); + } + else + { + arg->type = e->type; + Initializer *ie = new ExpInitializer(0, e); + VarDeclaration *v = new VarDeclaration(loc, arg->type, arg->ident, ie); + if (arg->storageClass & STCref) + v->storage_class |= STCref | STCforeach; + if (e->isConst() || e->op == TOKstring) + { if (v->storage_class & STCref) + error("constant value %s cannot be ref", ie->toChars()); + else + v->storage_class |= STCmanifest; + } + var = v; + } + } + else + { + var = new AliasDeclaration(loc, arg->ident, t); + } + DeclarationExp *de = new DeclarationExp(loc, var); + st->push(new ExpStatement(loc, de)); + + st->push(body->syntaxCopy()); + s = new CompoundStatement(loc, st); + s = new ScopeStatement(loc, s); + statements->push(s); + } + + s = new UnrolledLoopStatement(loc, statements); + if (prelude) + s = new CompoundStatement(loc, + new ExpStatement(prelude->loc, prelude), s); + s = s->semantic(sc); + return s; + } + + sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + sc->noctor++; + +Lagain: + switch (tab->ty) + { + case Tarray: + case Tsarray: + if (!checkForArgTypes()) + return this; + + if (dim < 1 || dim > 2) + { + error("only one or two arguments for array foreach"); + break; + } + + /* Look for special case of parsing char types out of char type + * array. + */ + tn = tab->nextOf()->toBasetype(); + if (tn->ty == Tchar || tn->ty == Twchar || tn->ty == Tdchar) + { Parameter *arg; + + int i = (dim == 1) ? 0 : 1; // index of value + arg = (*arguments)[i]; + arg->type = arg->type->semantic(loc, sc); + tnv = arg->type->toBasetype(); + if (tnv->ty != tn->ty && + (tnv->ty == Tchar || tnv->ty == Twchar || tnv->ty == Tdchar)) + { + if (arg->storageClass & STCref) + error("foreach: value of UTF conversion cannot be ref"); + if (dim == 2) + { arg = (*arguments)[0]; + if (arg->storageClass & STCref) + error("foreach: key cannot be ref"); + } + goto Lapply; + } + } + + for (size_t i = 0; i < dim; i++) + { // Declare args + Parameter *arg = (*arguments)[i]; + Type *argtype = arg->type->semantic(loc, sc); + VarDeclaration *var; + + var = new VarDeclaration(loc, argtype, arg->ident, NULL); + var->storage_class |= STCforeach; + var->storage_class |= arg->storageClass & (STCin | STCout | STCref | STC_TYPECTOR); + if (var->storage_class & (STCref | STCout)) + var->storage_class |= STCnodtor; + if (dim == 2 && i == 0) + { key = var; + //var->storage_class |= STCfinal; + } + else + { + value = var; + /* Reference to immutable data should be marked as const + */ + if (var->storage_class & STCref && !tn->isMutable()) + { + var->storage_class |= STCconst; + } + } +#if 0 + DeclarationExp *de = new DeclarationExp(loc, var); + de->semantic(sc); +#endif + } + +#if 1 + { + /* Convert to a ForStatement + * foreach (key, value; a) body => + * for (T[] tmp = a[], size_t key; key < tmp.length; ++key) + * { T value = tmp[k]; body } + * + * foreach_reverse (key, value; a) body => + * for (T[] tmp = a[], size_t key = tmp.length; key--; ) + * { T value = tmp[k]; body } + */ + Identifier *id = Lexer::uniqueId("__aggr"); + ExpInitializer *ie = new ExpInitializer(loc, new SliceExp(loc, aggr, NULL, NULL)); + VarDeclaration *tmp = new VarDeclaration(loc, tab->nextOf()->arrayOf(), id, ie); + + Expression *tmp_length = new DotIdExp(loc, new VarExp(loc, tmp), Id::length); + + if (!key) + { + Identifier *idkey = Lexer::uniqueId("__key"); + key = new VarDeclaration(loc, Type::tsize_t, idkey, NULL); + } + if (op == TOKforeach_reverse) + key->init = new ExpInitializer(loc, tmp_length); + else + key->init = new ExpInitializer(loc, new IntegerExp(0)); + + Statements *cs = new Statements(); + cs->push(new ExpStatement(loc, tmp)); + cs->push(new ExpStatement(loc, key)); + Statement *forinit = new CompoundDeclarationStatement(loc, cs); + + Expression *cond; + if (op == TOKforeach_reverse) + // key-- + cond = new PostExp(TOKminusminus, loc, new VarExp(loc, key)); + else + // key < tmp.length + cond = new CmpExp(TOKlt, loc, new VarExp(loc, key), tmp_length); + + Expression *increment = NULL; + if (op == TOKforeach) + // key += 1 + increment = new AddAssignExp(loc, new VarExp(loc, key), new IntegerExp(1)); + + // T value = tmp[key]; + value->init = new ExpInitializer(loc, new IndexExp(loc, new VarExp(loc, tmp), new VarExp(loc, key))); + Statement *ds = new ExpStatement(loc, value); + + body = new CompoundStatement(loc, ds, body); + + s = new ForStatement(loc, forinit, cond, increment, body); + s = s->semantic(sc); + break; + } +#else + if (tab->nextOf()->implicitConvTo(value->type) < MATCHconst) + { + if (aggr->op == TOKstring) + aggr = aggr->implicitCastTo(sc, value->type->arrayOf()); + else + error("foreach: %s is not an array of %s", + tab->toChars(), value->type->toChars()); + } + + if (key) + { + if (key->type->ty != Tint32 && key->type->ty != Tuns32) + { + if (global.params.is64bit) + { + if (key->type->ty != Tint64 && key->type->ty != Tuns64) + error("foreach: key type must be int or uint, long or ulong, not %s", key->type->toChars()); + } + else + error("foreach: key type must be int or uint, not %s", key->type->toChars()); + } + + if (key->storage_class & (STCout | STCref)) + error("foreach: key cannot be out or ref"); + } + + sc->sbreak = this; + sc->scontinue = this; + body = body->semantic(sc); + break; +#endif + + case Taarray: + if (!checkForArgTypes()) + return this; + + taa = (TypeAArray *)tab; + if (dim < 1 || dim > 2) + { + error("only one or two arguments for associative array foreach"); + break; + } +#if SARRAYVALUE + /* This only works if Key or Value is a static array. + */ + tab = taa->getImpl()->type; + goto Lagain; +#else + if (op == TOKforeach_reverse) + { + error("no reverse iteration on associative arrays"); + } + goto Lapply; +#endif + case Tclass: + case Tstruct: +#if DMDV2 + /* Prefer using opApply, if it exists + */ + if (sapply) + goto Lapply; + + { /* Look for range iteration, i.e. the properties + * .empty, .next, .retreat, .head and .rear + * foreach (e; aggr) { ... } + * translates to: + * for (auto __r = aggr[]; !__r.empty; __r.next) + * { auto e = __r.head; + * ... + * } + */ + AggregateDeclaration *ad = (tab->ty == Tclass) + ? (AggregateDeclaration *)((TypeClass *)tab)->sym + : (AggregateDeclaration *)((TypeStruct *)tab)->sym; + Identifier *idhead; + Identifier *idnext; + if (op == TOKforeach) + { idhead = Id::Ffront; + idnext = Id::FpopFront; + } + else + { idhead = Id::Fback; + idnext = Id::FpopBack; + } + Dsymbol *shead = search_function(ad, idhead); + if (!shead) + goto Lapply; + + /* Generate a temporary __r and initialize it with the aggregate. + */ + Identifier *id = Identifier::generateId("__r"); + VarDeclaration *r = new VarDeclaration(loc, NULL, id, new ExpInitializer(loc, aggr)); + Statement *init = new ExpStatement(loc, r); + + // !__r.empty + Expression *e = new VarExp(loc, r); + e = new DotIdExp(loc, e, Id::Fempty); + Expression *condition = new NotExp(loc, e); + + // __r.next + e = new VarExp(loc, r); + Expression *increment = new CallExp(loc, new DotIdExp(loc, e, idnext)); + + /* Declaration statement for e: + * auto e = __r.idhead; + */ + e = new VarExp(loc, r); + Expression *einit = new DotIdExp(loc, e, idhead); + Statement *makeargs, *forbody; + if (dim == 1) + { + Parameter *arg = (*arguments)[0]; + VarDeclaration *ve = new VarDeclaration(loc, arg->type, arg->ident, new ExpInitializer(loc, einit)); + ve->storage_class |= STCforeach; + ve->storage_class |= arg->storageClass & (STCin | STCout | STCref | STC_TYPECTOR); + + DeclarationExp *de = new DeclarationExp(loc, ve); + makeargs = new ExpStatement(loc, de); + } + else + { + Identifier *id = Lexer::uniqueId("__front"); + ExpInitializer *ei = new ExpInitializer(loc, einit); + VarDeclaration *vd = new VarDeclaration(loc, NULL, id, ei); + vd->storage_class |= STCctfe | STCref | STCforeach; + + Expression *de = new DeclarationExp(loc, vd); + makeargs = new ExpStatement(loc, de); + + Expression *ve = new VarExp(loc, vd); + ve->type = shead->isDeclaration()->type; + if (ve->type->toBasetype()->ty == Tfunction) + ve->type = ve->type->toBasetype()->nextOf(); + if (!ve->type || ve->type->ty == Terror) + goto Lrangeerr; + + // Resolve inout qualifier of front type + ve->type = ve->type->substWildTo(tab->mod); + + Expressions *exps = new Expressions(); + exps->push(ve); + int pos = 0; + while (exps->dim < dim) + { + pos = expandAliasThisTuples(exps, pos); + if (pos == -1) + break; + } + if (exps->dim != dim) + goto Lrangeerr; + + for (size_t i = 0; i < dim; i++) + { + Parameter *arg = (*arguments)[i]; + Expression *exp = (*exps)[i]; + #if 0 + printf("[%d] arg = %s %s, exp = %s %s\n", i, + arg->type ? arg->type->toChars() : "?", arg->ident->toChars(), + exp->type->toChars(), exp->toChars()); + #endif + if (arg->type && !exp->implicitConvTo(arg->type)) + goto Lrangeerr; + if (!arg->type) + arg->type = exp->type; + + VarDeclaration *var = new VarDeclaration(loc, arg->type, arg->ident, new ExpInitializer(loc, exp)); + var->storage_class |= STCctfe | STCref | STCforeach; + DeclarationExp *de = new DeclarationExp(loc, var); + makeargs = new CompoundStatement(loc, makeargs, new ExpStatement(loc, de)); + } + + } + + forbody = new CompoundStatement(loc, + makeargs, this->body); + + s = new ForStatement(loc, init, condition, increment, forbody); +#if 0 + printf("init: %s\n", init->toChars()); + printf("condition: %s\n", condition->toChars()); + printf("increment: %s\n", increment->toChars()); + printf("body: %s\n", forbody->toChars()); +#endif + s = s->semantic(sc); + break; + + Lrangeerr: + error("cannot infer argument types"); + break; + } +#endif + case Tdelegate: + Lapply: + { + Expression *ec; + Expression *e; + + if (!checkForArgTypes()) + { body = body->semanticNoScope(sc); + return this; + } + + Type *tret = func->type->nextOf(); + + // Need a variable to hold value from any return statements in body. + if (!sc->func->vresult && tret && tret != Type::tvoid) + { + VarDeclaration *v = new VarDeclaration(loc, tret, Id::result, NULL); + v->noscope = 1; + v->semantic(sc); + if (!sc->insert(v)) + assert(0); + v->parent = sc->func; + sc->func->vresult = v; + } + + TypeFunction *tfld = NULL; + if (sapply) + { FuncDeclaration *fdapply = sapply->isFuncDeclaration(); + if (fdapply) + { assert(fdapply->type && fdapply->type->ty == Tfunction); + tfld = (TypeFunction *)fdapply->type->semantic(loc, sc); + goto Lget; + } + else if (tab->ty == Tdelegate) + { + tfld = (TypeFunction *)tab->nextOf(); + Lget: + //printf("tfld = %s\n", tfld->toChars()); + if (tfld->parameters->dim == 1) + { + Parameter *p = Parameter::getNth(tfld->parameters, 0); + if (p->type && p->type->ty == Tdelegate) + { Type *t = p->type->semantic(loc, sc); + assert(t->ty == Tdelegate); + tfld = (TypeFunction *)t->nextOf(); + } + } + } + } + + /* Turn body into the function literal: + * int delegate(ref T arg) { body } + */ + Parameters *args = new Parameters(); + for (size_t i = 0; i < dim; i++) + { Parameter *arg = (*arguments)[i]; + StorageClass stc = STCref; + Identifier *id; + + arg->type = arg->type->semantic(loc, sc); + if (tfld) + { Parameter *prm = Parameter::getNth(tfld->parameters, i); + //printf("\tprm = %s%s\n", (prm->storageClass&STCref?"ref ":""), prm->ident->toChars()); + stc = prm->storageClass & STCref; + id = arg->ident; // argument copy is not need. + if ((arg->storageClass & STCref) != stc) + { if (!stc) + error("foreach: cannot make %s ref", arg->ident->toChars()); + goto LcopyArg; + } + } + else if (arg->storageClass & STCref) + { // default delegate parameters are marked as ref, then + // argument copy is not need. + id = arg->ident; + } + else + { // Make a copy of the ref argument so it isn't + // a reference. + LcopyArg: + id = Lexer::uniqueId("__applyArg", i); + + Initializer *ie = new ExpInitializer(0, new IdentifierExp(0, id)); + VarDeclaration *v = new VarDeclaration(0, arg->type, arg->ident, ie); + s = new ExpStatement(0, v); + body = new CompoundStatement(loc, s, body); + } + args->push(new Parameter(stc, arg->type, id, NULL)); + } + tfld = new TypeFunction(args, Type::tint32, 0, LINKd); + cases = new Statements(); + gotos = new CompoundStatements(); + FuncLiteralDeclaration *fld = new FuncLiteralDeclaration(loc, 0, tfld, TOKdelegate, this); + fld->fbody = body; + Expression *flde = new FuncExp(loc, fld); + flde = flde->semantic(sc); + fld->tookAddressOf = 0; + + // Resolve any forward referenced goto's + for (size_t i = 0; i < gotos->dim; i++) + { CompoundStatement *cs = (*gotos)[i]; + GotoStatement *gs = (GotoStatement *)(*cs->statements)[0]; + + if (!gs->label->statement) + { // 'Promote' it to this scope, and replace with a return + cases->push(gs); + s = new ReturnStatement(0, new IntegerExp(cases->dim + 1)); + (*cs->statements)[0] = s; + } + } + + if (taa) + { + // Check types + Parameter *arg = (*arguments)[0]; + if (dim == 2) + { + if (arg->storageClass & STCref) + error("foreach: index cannot be ref"); + if (!arg->type->equals(taa->index)) + error("foreach: index must be type %s, not %s", taa->index->toChars(), arg->type->toChars()); + arg = (*arguments)[1]; + } + if (!arg->type->equals(taa->nextOf())) + error("foreach: value must be type %s, not %s", taa->nextOf()->toChars(), arg->type->toChars()); + + /* Call: + * _aaApply(aggr, keysize, flde) + */ + FuncDeclaration *fdapply; + if (dim == 2) + fdapply = FuncDeclaration::genCfunc(Type::tindex, "_aaApply2"); + else + fdapply = FuncDeclaration::genCfunc(Type::tindex, "_aaApply"); + ec = new VarExp(0, fdapply); + Expressions *exps = new Expressions(); + exps->push(aggr); + size_t keysize = taa->index->size(); + keysize = (keysize + (PTRSIZE-1)) & ~(PTRSIZE-1); + exps->push(new IntegerExp(0, keysize, Type::tsize_t)); + exps->push(flde); + e = new CallExp(loc, ec, exps); + e->type = Type::tindex; // don't run semantic() on e + } + else if (tab->ty == Tarray || tab->ty == Tsarray) + { + /* Call: + * _aApply(aggr, flde) + */ + static char fntab[9][3] = + { "cc","cw","cd", + "wc","cc","wd", + "dc","dw","dd" + }; + char fdname[7+1+2+ sizeof(dim)*3 + 1]; + int flag; + + switch (tn->ty) + { + case Tchar: flag = 0; break; + case Twchar: flag = 3; break; + case Tdchar: flag = 6; break; + default: assert(0); + } + switch (tnv->ty) + { + case Tchar: flag += 0; break; + case Twchar: flag += 1; break; + case Tdchar: flag += 2; break; + default: assert(0); + } + const char *r = (op == TOKforeach_reverse) ? "R" : ""; + int j = sprintf(fdname, "_aApply%s%.*s%zd", r, 2, fntab[flag], dim); + assert(j < sizeof(fdname)); + FuncDeclaration *fdapply = FuncDeclaration::genCfunc(Type::tindex, fdname); + + ec = new VarExp(0, fdapply); + Expressions *exps = new Expressions(); + if (tab->ty == Tsarray) + aggr = aggr->castTo(sc, tn->arrayOf()); + exps->push(aggr); + exps->push(flde); + e = new CallExp(loc, ec, exps); + e->type = Type::tindex; // don't run semantic() on e + } + else if (tab->ty == Tdelegate) + { + /* Call: + * aggr(flde) + */ + Expressions *exps = new Expressions(); + exps->push(flde); + if (aggr->op == TOKdelegate && + ((DelegateExp *)aggr)->func->isNested()) + // See Bugzilla 3560 + e = new CallExp(loc, ((DelegateExp *)aggr)->e1, exps); + else + e = new CallExp(loc, aggr, exps); + e = e->semantic(sc); + if (e->type != Type::tint32) + error("opApply() function for %s must return an int", tab->toChars()); + } + else + { + assert(tab->ty == Tstruct || tab->ty == Tclass); + Expressions *exps = new Expressions(); + assert(sapply); +#if 0 + TemplateDeclaration *td; + if (sapply && + (td = sapply->isTemplateDeclaration()) != NULL) + { /* Call: + * aggr.apply!(fld)() + */ + Objects *tiargs = new Objects(); + tiargs->push(fld); + ec = new DotTemplateInstanceExp(loc, aggr, sapply->ident, tiargs); + } + else +#endif + { + /* Call: + * aggr.apply(flde) + */ + ec = new DotIdExp(loc, aggr, sapply->ident); + exps->push(flde); + } + e = new CallExp(loc, ec, exps); + e = e->semantic(sc); + if (e->type != Type::tint32) + error("opApply() function for %s must return an int", tab->toChars()); + } + + if (!cases->dim) + // Easy case, a clean exit from the loop + s = new ExpStatement(loc, e); + else + { // Construct a switch statement around the return value + // of the apply function. + Statements *a = new Statements(); + + // default: break; takes care of cases 0 and 1 + s = new BreakStatement(0, NULL); + s = new DefaultStatement(0, s); + a->push(s); + + // cases 2... + for (size_t i = 0; i < cases->dim; i++) + { + s = (*cases)[i]; + s = new CaseStatement(0, new IntegerExp(i + 2), s); + a->push(s); + } + + s = new CompoundStatement(loc, a); + s = new SwitchStatement(loc, e, s, FALSE); + } + s = s->semantic(sc); + break; + } + case Terror: + s = NULL; + break; + + default: + error("foreach: %s is not an aggregate type", aggr->type->toChars()); + s = NULL; // error recovery + break; + } + sc->noctor--; + sc->pop(); + return s; +} + +bool ForeachStatement::checkForArgTypes() +{ bool result = TRUE; + + for (size_t i = 0; i < arguments->dim; i++) + { Parameter *arg = (*arguments)[i]; + if (!arg->type) + { + error("cannot infer type for %s", arg->ident->toChars()); + arg->type = Type::terror; + result = FALSE; + } + } + return result; +} + +int ForeachStatement::hasBreak() +{ + return TRUE; +} + +int ForeachStatement::hasContinue() +{ + return TRUE; +} + +int ForeachStatement::usesEH() +{ + return body->usesEH(); +} + +int ForeachStatement::blockExit(bool mustNotThrow) +{ int result = BEfallthru; + + if (aggr->canThrow(mustNotThrow)) + result |= BEthrow; + + if (body) + { + result |= body->blockExit(mustNotThrow) & ~(BEbreak | BEcontinue); + } + return result; +} + + +int ForeachStatement::comeFrom() +{ + if (body) + return body->comeFrom(); + return FALSE; +} + +void ForeachStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(op)); + buf->writestring(" ("); + for (size_t i = 0; i < arguments->dim; i++) + { + Parameter *a = (*arguments)[i]; + if (i) + buf->writestring(", "); + if (a->storageClass & STCref) + buf->writestring((global.params.Dversion == 1) + ? (char*)"inout " : (char*)"ref "); + if (a->type) + a->type->toCBuffer(buf, a->ident, hgs); + else + buf->writestring(a->ident->toChars()); + } + buf->writestring("; "); + aggr->toCBuffer(buf, hgs); + buf->writebyte(')'); + buf->writenl(); + buf->writebyte('{'); + buf->writenl(); + if (body) + body->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); +} + +/**************************** ForeachRangeStatement ***************************/ + +#if DMDV2 + +ForeachRangeStatement::ForeachRangeStatement(Loc loc, enum TOK op, Parameter *arg, + Expression *lwr, Expression *upr, Statement *body) + : Statement(loc) +{ + this->op = op; + this->arg = arg; + this->lwr = lwr; + this->upr = upr; + this->body = body; + + this->key = NULL; +} + +Statement *ForeachRangeStatement::syntaxCopy() +{ + ForeachRangeStatement *s = new ForeachRangeStatement(loc, op, + arg->syntaxCopy(), + lwr->syntaxCopy(), + upr->syntaxCopy(), + body ? body->syntaxCopy() : NULL); + return s; +} + +Statement *ForeachRangeStatement::semantic(Scope *sc) +{ + //printf("ForeachRangeStatement::semantic() %p\n", this); + Statement *s = this; + + lwr = lwr->semantic(sc); + lwr = resolveProperties(sc, lwr); + lwr = lwr->optimize(WANTvalue); + if (!lwr->type) + { + error("invalid range lower bound %s", lwr->toChars()); + return this; + } + + upr = upr->semantic(sc); + upr = resolveProperties(sc, upr); + upr = upr->optimize(WANTvalue); + if (!upr->type) + { + error("invalid range upper bound %s", upr->toChars()); + return this; + } + + if (arg->type) + { + arg->type = arg->type->semantic(loc, sc); + lwr = lwr->implicitCastTo(sc, arg->type); + upr = upr->implicitCastTo(sc, arg->type); + } + else + { + /* Must infer types from lwr and upr + */ + Type *tlwr = lwr->type->toBasetype(); + if (tlwr->ty == Tstruct || tlwr->ty == Tclass) + { + /* Just picking the first really isn't good enough. + */ + arg->type = lwr->type->mutableOf(); + } + else + { + AddExp ea(loc, lwr, upr); + Expression *e = ea.typeCombine(sc); + arg->type = ea.type->mutableOf(); + lwr = ea.e1; + upr = ea.e2; + } + } +#if 1 + /* Convert to a for loop: + * foreach (key; lwr .. upr) => + * for (auto key = lwr, auto tmp = upr; key < tmp; ++key) + * + * foreach_reverse (key; lwr .. upr) => + * for (auto tmp = lwr, auto key = upr; key-- > tmp;) + */ + + ExpInitializer *ie = new ExpInitializer(loc, (op == TOKforeach) ? lwr : upr); + key = new VarDeclaration(loc, arg->type, arg->ident, ie); + + Identifier *id = Lexer::uniqueId("__limit"); + ie = new ExpInitializer(loc, (op == TOKforeach) ? upr : lwr); + VarDeclaration *tmp = new VarDeclaration(loc, arg->type, id, ie); + + Statements *cs = new Statements(); + // Keep order of evaluation as lwr, then upr + if (op == TOKforeach) + { + cs->push(new ExpStatement(loc, key)); + cs->push(new ExpStatement(loc, tmp)); + } + else + { + cs->push(new ExpStatement(loc, tmp)); + cs->push(new ExpStatement(loc, key)); + } + Statement *forinit = new CompoundDeclarationStatement(loc, cs); + + Expression *cond; + if (op == TOKforeach_reverse) + { + cond = new PostExp(TOKminusminus, loc, new VarExp(loc, key)); + if (arg->type->isscalar()) + // key-- > tmp + cond = new CmpExp(TOKgt, loc, cond, new VarExp(loc, tmp)); + else + // key-- != tmp + cond = new EqualExp(TOKnotequal, loc, cond, new VarExp(loc, tmp)); + } + else + { + if (arg->type->isscalar()) + // key < tmp + cond = new CmpExp(TOKlt, loc, new VarExp(loc, key), new VarExp(loc, tmp)); + else + // key != tmp + cond = new EqualExp(TOKnotequal, loc, new VarExp(loc, key), new VarExp(loc, tmp)); + } + + Expression *increment = NULL; + if (op == TOKforeach) + // key += 1 + //increment = new AddAssignExp(loc, new VarExp(loc, key), new IntegerExp(1)); + increment = new PreExp(TOKpreplusplus, loc, new VarExp(loc, key)); + + ForStatement *fs = new ForStatement(loc, forinit, cond, increment, body); + s = fs->semantic(sc); + return s; +#else + if (!arg->type->isscalar()) + error("%s is not a scalar type", arg->type->toChars()); + + sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + sc->noctor++; + + key = new VarDeclaration(loc, arg->type, arg->ident, NULL); + DeclarationExp *de = new DeclarationExp(loc, key); + de->semantic(sc); + + if (key->storage_class) + error("foreach range: key cannot have storage class"); + + sc->sbreak = this; + sc->scontinue = this; + body = body->semantic(sc); + + sc->noctor--; + sc->pop(); + return s; +#endif +} + +int ForeachRangeStatement::hasBreak() +{ + return TRUE; +} + +int ForeachRangeStatement::hasContinue() +{ + return TRUE; +} + +int ForeachRangeStatement::usesEH() +{ + assert(0); + return body->usesEH(); +} + +int ForeachRangeStatement::blockExit(bool mustNotThrow) +{ + assert(0); + int result = BEfallthru; + + if (lwr && lwr->canThrow(mustNotThrow)) + result |= BEthrow; + else if (upr && upr->canThrow(mustNotThrow)) + result |= BEthrow; + + if (body) + { + result |= body->blockExit(mustNotThrow) & ~(BEbreak | BEcontinue); + } + return result; +} + + +int ForeachRangeStatement::comeFrom() +{ + assert(0); + if (body) + return body->comeFrom(); + return FALSE; +} + +void ForeachRangeStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(op)); + buf->writestring(" ("); + + if (arg->type) + arg->type->toCBuffer(buf, arg->ident, hgs); + else + buf->writestring(arg->ident->toChars()); + + buf->writestring("; "); + lwr->toCBuffer(buf, hgs); + buf->writestring(" .. "); + upr->toCBuffer(buf, hgs); + buf->writebyte(')'); + buf->writenl(); + buf->writebyte('{'); + buf->writenl(); + if (body) + body->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); +} + +#endif + +/******************************** IfStatement ***************************/ + +IfStatement::IfStatement(Loc loc, Parameter *arg, Expression *condition, Statement *ifbody, Statement *elsebody) + : Statement(loc) +{ + this->arg = arg; + this->condition = condition; + this->ifbody = ifbody; + this->elsebody = elsebody; + this->match = NULL; +} + +Statement *IfStatement::syntaxCopy() +{ + Statement *i = NULL; + if (ifbody) + i = ifbody->syntaxCopy(); + + Statement *e = NULL; + if (elsebody) + e = elsebody->syntaxCopy(); + + Parameter *a = arg ? arg->syntaxCopy() : NULL; + IfStatement *s = new IfStatement(loc, a, condition->syntaxCopy(), i, e); + return s; +} + +Statement *IfStatement::semantic(Scope *sc) +{ + // Evaluate at runtime + unsigned cs0 = sc->callSuper; + unsigned cs1; + + Scope *scd; + if (arg) + { /* Declare arg, which we will set to be the + * result of condition. + */ + ScopeDsymbol *sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + scd = sc->push(sym); + + match = new VarDeclaration(loc, arg->type, arg->ident, new ExpInitializer(loc, condition)); + match->parent = sc->func; + + DeclarationExp *de = new DeclarationExp(loc, match); + VarExp *ve = new VarExp(0, match); + condition = new CommaExp(loc, de, ve); + condition = condition->semantic(scd); + + if (match->edtor) + { + Statement *sdtor = new ExpStatement(loc, match->edtor); + sdtor = new OnScopeStatement(loc, TOKon_scope_exit, sdtor); + ifbody = new CompoundStatement(loc, sdtor, ifbody); + match->noscope = 1; + } + } + else + { + condition = condition->semantic(sc); + condition = condition->addDtorHook(sc); + condition = resolveProperties(sc, condition); + scd = sc->push(); + } + + // Convert to boolean after declaring arg so this works: + // if (S arg = S()) {} + // where S is a struct that defines opCast!bool. + condition = condition->checkToBoolean(sc); + + // If we can short-circuit evaluate the if statement, don't do the + // semantic analysis of the skipped code. + // This feature allows a limited form of conditional compilation. + condition = condition->optimize(WANTflags); + ifbody = ifbody->semanticNoScope(scd); + scd->pop(); + + cs1 = sc->callSuper; + sc->callSuper = cs0; + if (elsebody) + elsebody = elsebody->semanticScope(sc, NULL, NULL); + sc->mergeCallSuper(loc, cs1); + + return this; +} + +int IfStatement::usesEH() +{ + return (ifbody && ifbody->usesEH()) || (elsebody && elsebody->usesEH()); +} + +int IfStatement::blockExit(bool mustNotThrow) +{ + //printf("IfStatement::blockExit(%p)\n", this); + + int result = BEnone; + if (condition->canThrow(mustNotThrow)) + result |= BEthrow; + if (condition->isBool(TRUE)) + { + if (ifbody) + result |= ifbody->blockExit(mustNotThrow); + else + result |= BEfallthru; + } + else if (condition->isBool(FALSE)) + { + if (elsebody) + result |= elsebody->blockExit(mustNotThrow); + else + result |= BEfallthru; + } + else + { + if (ifbody) + result |= ifbody->blockExit(mustNotThrow); + else + result |= BEfallthru; + if (elsebody) + result |= elsebody->blockExit(mustNotThrow); + else + result |= BEfallthru; + } + //printf("IfStatement::blockExit(%p) = x%x\n", this, result); + return result; +} + + +void IfStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("if ("); + if (arg) + { + if (arg->type) + arg->type->toCBuffer(buf, arg->ident, hgs); + else + { buf->writestring("auto "); + buf->writestring(arg->ident->toChars()); + } + buf->writestring(" = "); + } + condition->toCBuffer(buf, hgs); + buf->writebyte(')'); + buf->writenl(); + ifbody->toCBuffer(buf, hgs); + if (elsebody) + { buf->writestring("else"); + buf->writenl(); + elsebody->toCBuffer(buf, hgs); + } +} + +/******************************** ConditionalStatement ***************************/ + +ConditionalStatement::ConditionalStatement(Loc loc, Condition *condition, Statement *ifbody, Statement *elsebody) + : Statement(loc) +{ + this->condition = condition; + this->ifbody = ifbody; + this->elsebody = elsebody; +} + +Statement *ConditionalStatement::syntaxCopy() +{ + Statement *e = NULL; + if (elsebody) + e = elsebody->syntaxCopy(); + ConditionalStatement *s = new ConditionalStatement(loc, + condition->syntaxCopy(), ifbody->syntaxCopy(), e); + return s; +} + +Statement *ConditionalStatement::semantic(Scope *sc) +{ + //printf("ConditionalStatement::semantic()\n"); + + // If we can short-circuit evaluate the if statement, don't do the + // semantic analysis of the skipped code. + // This feature allows a limited form of conditional compilation. + if (condition->include(sc, NULL)) + { + DebugCondition *dc = condition->isDebugCondition(); + if (dc) + { + sc = sc->push(); + sc->flags |= SCOPEdebug; + ifbody = ifbody->semantic(sc); + sc->pop(); + } + else + ifbody = ifbody->semantic(sc); + return ifbody; + } + else + { + if (elsebody) + elsebody = elsebody->semantic(sc); + return elsebody; + } +} + +Statements *ConditionalStatement::flatten(Scope *sc) +{ + Statement *s; + + //printf("ConditionalStatement::flatten()\n"); + if (condition->include(sc, NULL)) + { + DebugCondition *dc = condition->isDebugCondition(); + if (dc) + s = new DebugStatement(loc, ifbody); + else + s = ifbody; + } + else + s = elsebody; + + Statements *a = new Statements(); + a->push(s); + return a; +} + +int ConditionalStatement::usesEH() +{ + return (ifbody && ifbody->usesEH()) || (elsebody && elsebody->usesEH()); +} + +int ConditionalStatement::blockExit(bool mustNotThrow) +{ + int result = ifbody->blockExit(mustNotThrow); + if (elsebody) + result |= elsebody->blockExit(mustNotThrow); + return result; +} + +void ConditionalStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + condition->toCBuffer(buf, hgs); + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + if (ifbody) + ifbody->toCBuffer(buf, hgs); + buf->writeByte('}'); + buf->writenl(); + if (elsebody) + { + buf->writestring("else"); + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + elsebody->toCBuffer(buf, hgs); + buf->writeByte('}'); + buf->writenl(); + } + buf->writenl(); +} + + +/******************************** PragmaStatement ***************************/ + +PragmaStatement::PragmaStatement(Loc loc, Identifier *ident, Expressions *args, Statement *body) + : Statement(loc) +{ + this->ident = ident; + this->args = args; + this->body = body; +} + +Statement *PragmaStatement::syntaxCopy() +{ + Statement *b = NULL; + if (body) + b = body->syntaxCopy(); + PragmaStatement *s = new PragmaStatement(loc, + ident, Expression::arraySyntaxCopy(args), b); + return s; +} + +Statement *PragmaStatement::semantic(Scope *sc) +{ // Should be merged with PragmaDeclaration + //printf("PragmaStatement::semantic() %s\n", toChars()); + //printf("body = %p\n", body); + if (ident == Id::msg) + { + if (args) + { + for (size_t i = 0; i < args->dim; i++) + { + Expression *e = (*args)[i]; + + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + StringExp *se = e->toString(); + if (se) + { + fprintf(stdmsg, "%.*s", (int)se->len, (char *)se->string); + } + else + fprintf(stdmsg, "%s", e->toChars()); + } + fprintf(stdmsg, "\n"); + } + } + else if (ident == Id::lib) + { +#if 1 + /* Should this be allowed? + */ + error("pragma(lib) not allowed as statement"); +#else + if (!args || args->dim != 1) + error("string expected for library name"); + else + { + Expression *e = (*args)[0]; + + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + (*args)[0] = e; + StringExp *se = e->toString(); + if (!se) + error("string expected for library name, not '%s'", e->toChars()); + else if (global.params.verbose) + { + char *name = (char *)mem.malloc(se->len + 1); + memcpy(name, se->string, se->len); + name[se->len] = 0; + printf("library %s\n", name); + mem.free(name); + } + } +#endif + } +#if DMDV2 + else if (ident == Id::startaddress) + { + if (!args || args->dim != 1) + error("function name expected for start address"); + else + { + Expression *e = (*args)[0]; + e = e->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + (*args)[0] = e; + Dsymbol *sa = getDsymbol(e); + if (!sa || !sa->isFuncDeclaration()) + error("function name expected for start address, not '%s'", e->toChars()); + if (body) + { + body = body->semantic(sc); + } + return this; + } + } +#endif + else + error("unrecognized pragma(%s)", ident->toChars()); + + if (body) + { + body = body->semantic(sc); + } + return body; +} + +int PragmaStatement::usesEH() +{ + return body && body->usesEH(); +} + +int PragmaStatement::blockExit(bool mustNotThrow) +{ + int result = BEfallthru; +#if 0 // currently, no code is generated for Pragma's, so it's just fallthru + if (arrayExpressionCanThrow(args)) + result |= BEthrow; + if (body) + result |= body->blockExit(mustNotThrow); +#endif + return result; +} + + +void PragmaStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("pragma ("); + buf->writestring(ident->toChars()); + if (args && args->dim) + { + buf->writestring(", "); + argsToCBuffer(buf, args, hgs); + } + buf->writeByte(')'); + if (body) + { + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + + body->toCBuffer(buf, hgs); + + buf->writeByte('}'); + buf->writenl(); + } + else + { + buf->writeByte(';'); + buf->writenl(); + } +} + + +/******************************** StaticAssertStatement ***************************/ + +StaticAssertStatement::StaticAssertStatement(StaticAssert *sa) + : Statement(sa->loc) +{ + this->sa = sa; +} + +Statement *StaticAssertStatement::syntaxCopy() +{ + StaticAssertStatement *s = new StaticAssertStatement((StaticAssert *)sa->syntaxCopy(NULL)); + return s; +} + +Statement *StaticAssertStatement::semantic(Scope *sc) +{ + sa->semantic2(sc); + return NULL; +} + +int StaticAssertStatement::blockExit(bool mustNotThrow) +{ + return BEfallthru; +} + +void StaticAssertStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + sa->toCBuffer(buf, hgs); +} + + +/******************************** SwitchStatement ***************************/ + +SwitchStatement::SwitchStatement(Loc loc, Expression *c, Statement *b, bool isFinal) + : Statement(loc) +{ + this->condition = c; + this->body = b; + this->isFinal = isFinal; + sdefault = NULL; + tf = NULL; + cases = NULL; + hasNoDefault = 0; + hasVars = 0; +} + +Statement *SwitchStatement::syntaxCopy() +{ + SwitchStatement *s = new SwitchStatement(loc, + condition->syntaxCopy(), body->syntaxCopy(), isFinal); + return s; +} + +Statement *SwitchStatement::semantic(Scope *sc) +{ + //printf("SwitchStatement::semantic(%p)\n", this); + tf = sc->tf; + assert(!cases); // ensure semantic() is only run once + condition = condition->semantic(sc); + condition = resolveProperties(sc, condition); + if (condition->type->isString()) + { + // If it's not an array, cast it to one + if (condition->type->ty != Tarray) + { + condition = condition->implicitCastTo(sc, condition->type->nextOf()->arrayOf()); + } + condition->type = condition->type->constOf(); + } + else + { condition = condition->integralPromotions(sc); + condition->checkIntegral(); + } + condition = condition->optimize(WANTvalue); + + sc = sc->push(); + sc->sbreak = this; + sc->sw = this; + + cases = new CaseStatements(); + sc->noctor++; // BUG: should use Scope::mergeCallSuper() for each case instead + body = body->semantic(sc); + sc->noctor--; + + // Resolve any goto case's with exp + for (size_t i = 0; i < gotoCases.dim; i++) + { + GotoCaseStatement *gcs = gotoCases[i]; + + if (!gcs->exp) + { + gcs->error("no case statement following goto case;"); + break; + } + + for (Scope *scx = sc; scx; scx = scx->enclosing) + { + if (!scx->sw) + continue; + for (size_t j = 0; j < scx->sw->cases->dim; j++) + { + CaseStatement *cs = (*scx->sw->cases)[j]; + + if (cs->exp->equals(gcs->exp)) + { + gcs->cs = cs; + goto Lfoundcase; + } + } + } + gcs->error("case %s not found", gcs->exp->toChars()); + + Lfoundcase: + ; + } + + bool needswitcherror = FALSE; +#if DMDV2 + if (isFinal) + { Type *t = condition->type; + while (t->ty == Ttypedef) + { // Don't use toBasetype() because that will skip past enums + t = ((TypeTypedef *)t)->sym->basetype; + } + if (condition->type->ty == Tenum) + { TypeEnum *te = (TypeEnum *)condition->type; + EnumDeclaration *ed = te->toDsymbol(sc)->isEnumDeclaration(); + assert(ed); + size_t dim = ed->members->dim; + for (size_t i = 0; i < dim; i++) + { + EnumMember *em = (*ed->members)[i]->isEnumMember(); + if (em) + { + for (size_t j = 0; j < cases->dim; j++) + { CaseStatement *cs = (*cases)[j]; + if (cs->exp->equals(em->value)) + goto L1; + } + error("enum member %s not represented in final switch", em->toChars()); + } + L1: + ; + } + } + else + needswitcherror = TRUE; + } +#endif + + if (!sc->sw->sdefault && (!isFinal || needswitcherror)) + { hasNoDefault = 1; + + if (!global.params.useDeprecated && !isFinal) + error("non-final switch statement without a default is deprecated"); + + // Generate runtime error if the default is hit + Statements *a = new Statements(); + CompoundStatement *cs; + Statement *s; + + if (global.params.useSwitchError) + s = new SwitchErrorStatement(loc); + else + { Expression *e = new HaltExp(loc); + s = new ExpStatement(loc, e); + } + + a->reserve(2); + sc->sw->sdefault = new DefaultStatement(loc, s); + a->push(sc->sw->sdefault); + a->push(body); + cs = new CompoundStatement(loc, a); + body = cs; + } + + sc->pop(); + return this; +} + +int SwitchStatement::hasBreak() +{ + return TRUE; +} + +int SwitchStatement::usesEH() +{ + return body ? body->usesEH() : 0; +} + +int SwitchStatement::blockExit(bool mustNotThrow) +{ int result = BEnone; + if (condition->canThrow(mustNotThrow)) + result |= BEthrow; + + if (body) + { result |= body->blockExit(mustNotThrow); + if (result & BEbreak) + { result |= BEfallthru; + result &= ~BEbreak; + } + } + else + result |= BEfallthru; + + return result; +} + + +void SwitchStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(isFinal ? "final switch (" : "switch ("); + condition->toCBuffer(buf, hgs); + buf->writebyte(')'); + buf->writenl(); + if (body) + { + if (!body->isScopeStatement()) + { buf->writebyte('{'); + buf->writenl(); + body->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); + } + else + { + body->toCBuffer(buf, hgs); + } + } +} + +/******************************** CaseStatement ***************************/ + +CaseStatement::CaseStatement(Loc loc, Expression *exp, Statement *s) + : Statement(loc) +{ + this->exp = exp; + this->statement = s; + index = 0; + cblock = NULL; +} + +Statement *CaseStatement::syntaxCopy() +{ + CaseStatement *s = new CaseStatement(loc, exp->syntaxCopy(), statement->syntaxCopy()); + return s; +} + +Statement *CaseStatement::semantic(Scope *sc) +{ SwitchStatement *sw = sc->sw; + + //printf("CaseStatement::semantic() %s\n", toChars()); + exp = exp->semantic(sc); + if (sw) + { + exp = exp->implicitCastTo(sc, sw->condition->type); + exp = exp->optimize(WANTvalue); + + /* This is where variables are allowed as case expressions. + */ + if (exp->op == TOKvar) + { VarExp *ve = (VarExp *)exp; + VarDeclaration *v = ve->var->isVarDeclaration(); + Type *t = exp->type->toBasetype(); + if (v && (t->isintegral() || t->ty == Tclass)) + { /* Flag that we need to do special code generation + * for this, i.e. generate a sequence of if-then-else + */ + sw->hasVars = 1; + if (sw->isFinal) + error("case variables not allowed in final switch statements"); + goto L1; + } + } + else + exp = exp->optimize(WANTvalue | WANTinterpret); + + if (exp->op != TOKstring && exp->op != TOKint64 && exp->op != TOKerror) + { + error("case must be a string or an integral constant, not %s", exp->toChars()); + exp = new IntegerExp(0); + } + + L1: + for (size_t i = 0; i < sw->cases->dim; i++) + { + CaseStatement *cs = (*sw->cases)[i]; + + //printf("comparing '%s' with '%s'\n", exp->toChars(), cs->exp->toChars()); + if (cs->exp->equals(exp)) + { error("duplicate case %s in switch statement", exp->toChars()); + break; + } + } + + sw->cases->push(this); + + // Resolve any goto case's with no exp to this case statement + for (size_t i = 0; i < sw->gotoCases.dim; i++) + { + GotoCaseStatement *gcs = sw->gotoCases[i]; + + if (!gcs->exp) + { + gcs->cs = this; + sw->gotoCases.remove(i); // remove from array + } + } + + if (sc->sw->tf != sc->tf) + error("switch and case are in different finally blocks"); + } + else + error("case not in switch statement"); + statement = statement->semantic(sc); + return this; +} + +int CaseStatement::compare(Object *obj) +{ + // Sort cases so we can do an efficient lookup + CaseStatement *cs2 = (CaseStatement *)(obj); + + return exp->compare(cs2->exp); +} + +int CaseStatement::usesEH() +{ + return statement->usesEH(); +} + +int CaseStatement::blockExit(bool mustNotThrow) +{ + return statement->blockExit(mustNotThrow); +} + + +int CaseStatement::comeFrom() +{ + return TRUE; +} + +void CaseStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("case "); + exp->toCBuffer(buf, hgs); + buf->writebyte(':'); + buf->writenl(); + statement->toCBuffer(buf, hgs); +} + +/******************************** CaseRangeStatement ***************************/ + +#if DMDV2 + +CaseRangeStatement::CaseRangeStatement(Loc loc, Expression *first, + Expression *last, Statement *s) + : Statement(loc) +{ + this->first = first; + this->last = last; + this->statement = s; +} + +Statement *CaseRangeStatement::syntaxCopy() +{ + CaseRangeStatement *s = new CaseRangeStatement(loc, + first->syntaxCopy(), last->syntaxCopy(), statement->syntaxCopy()); + return s; +} + +Statement *CaseRangeStatement::semantic(Scope *sc) +{ SwitchStatement *sw = sc->sw; + + //printf("CaseRangeStatement::semantic() %s\n", toChars()); + if (sw->isFinal) + error("case ranges not allowed in final switch"); + + first = first->semantic(sc); + first = first->implicitCastTo(sc, sw->condition->type); + first = first->optimize(WANTvalue | WANTinterpret); + + + last = last->semantic(sc); + last = last->implicitCastTo(sc, sw->condition->type); + last = last->optimize(WANTvalue | WANTinterpret); + + if (first->op == TOKerror || last->op == TOKerror) + return statement ? statement->semantic(sc) : NULL; + + uinteger_t fval = first->toInteger(); + uinteger_t lval = last->toInteger(); + + + if ( (first->type->isunsigned() && fval > lval) || + (!first->type->isunsigned() && (sinteger_t)fval > (sinteger_t)lval)) + { + error("first case %s is greater than last case %s", + first->toChars(), last->toChars()); + lval = fval; + } + + if (lval - fval > 256) + { error("had %llu cases which is more than 256 cases in case range", lval - fval); + lval = fval + 256; + } + + /* This works by replacing the CaseRange with an array of Case's. + * + * case a: .. case b: s; + * => + * case a: + * [...] + * case b: + * s; + */ + + Statements *statements = new Statements(); + for (uinteger_t i = fval; i != lval + 1; i++) + { + Statement *s = statement; + if (i != lval) // if not last case + s = new ExpStatement(loc, (Expression *)NULL); + Expression *e = new IntegerExp(loc, i, first->type); + Statement *cs = new CaseStatement(loc, e, s); + statements->push(cs); + } + Statement *s = new CompoundStatement(loc, statements); + s = s->semantic(sc); + return s; +} + +void CaseRangeStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("case "); + first->toCBuffer(buf, hgs); + buf->writestring(": .. case "); + last->toCBuffer(buf, hgs); + buf->writebyte(':'); + buf->writenl(); + statement->toCBuffer(buf, hgs); +} + +#endif + +/******************************** DefaultStatement ***************************/ + +DefaultStatement::DefaultStatement(Loc loc, Statement *s) + : Statement(loc) +{ + this->statement = s; +#if IN_GCC ++ cblock = NULL; +#endif +} + +Statement *DefaultStatement::syntaxCopy() +{ + DefaultStatement *s = new DefaultStatement(loc, statement->syntaxCopy()); + return s; +} + +Statement *DefaultStatement::semantic(Scope *sc) +{ + //printf("DefaultStatement::semantic()\n"); + if (sc->sw) + { + if (sc->sw->sdefault) + { + error("switch statement already has a default"); + } + sc->sw->sdefault = this; + + if (sc->sw->tf != sc->tf) + error("switch and default are in different finally blocks"); + + if (sc->sw->isFinal) + error("default statement not allowed in final switch statement"); + } + else + error("default not in switch statement"); + statement = statement->semantic(sc); + return this; +} + +int DefaultStatement::usesEH() +{ + return statement->usesEH(); +} + +int DefaultStatement::blockExit(bool mustNotThrow) +{ + return statement->blockExit(mustNotThrow); +} + + +int DefaultStatement::comeFrom() +{ + return TRUE; +} + +void DefaultStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("default:\n"); + statement->toCBuffer(buf, hgs); +} + +/******************************** GotoDefaultStatement ***************************/ + +GotoDefaultStatement::GotoDefaultStatement(Loc loc) + : Statement(loc) +{ + sw = NULL; +} + +Statement *GotoDefaultStatement::syntaxCopy() +{ + GotoDefaultStatement *s = new GotoDefaultStatement(loc); + return s; +} + +Statement *GotoDefaultStatement::semantic(Scope *sc) +{ + sw = sc->sw; + if (!sw) + error("goto default not in switch statement"); + return this; +} + +int GotoDefaultStatement::blockExit(bool mustNotThrow) +{ + return BEgoto; +} + + +void GotoDefaultStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("goto default;\n"); +} + +/******************************** GotoCaseStatement ***************************/ + +GotoCaseStatement::GotoCaseStatement(Loc loc, Expression *exp) + : Statement(loc) +{ + cs = NULL; + this->exp = exp; +} + +Statement *GotoCaseStatement::syntaxCopy() +{ + Expression *e = exp ? exp->syntaxCopy() : NULL; + GotoCaseStatement *s = new GotoCaseStatement(loc, e); + return s; +} + +Statement *GotoCaseStatement::semantic(Scope *sc) +{ + if (exp) + exp = exp->semantic(sc); + + if (!sc->sw) + error("goto case not in switch statement"); + else + { + sc->sw->gotoCases.push(this); + if (exp) + { + exp = exp->implicitCastTo(sc, sc->sw->condition->type); + exp = exp->optimize(WANTvalue); + } + } + return this; +} + +int GotoCaseStatement::blockExit(bool mustNotThrow) +{ + return BEgoto; +} + + +void GotoCaseStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("goto case"); + if (exp) + { buf->writebyte(' '); + exp->toCBuffer(buf, hgs); + } + buf->writebyte(';'); + buf->writenl(); +} + +/******************************** SwitchErrorStatement ***************************/ + +SwitchErrorStatement::SwitchErrorStatement(Loc loc) + : Statement(loc) +{ +} + +int SwitchErrorStatement::blockExit(bool mustNotThrow) +{ + // Switch errors are non-recoverable + return BEhalt; +} + + +void SwitchErrorStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("SwitchErrorStatement::toCBuffer()"); + buf->writenl(); +} + +/******************************** ReturnStatement ***************************/ + +ReturnStatement::ReturnStatement(Loc loc, Expression *exp) + : Statement(loc) +{ + this->exp = exp; +} + +Statement *ReturnStatement::syntaxCopy() +{ + Expression *e = NULL; + if (exp) + e = exp->syntaxCopy(); + ReturnStatement *s = new ReturnStatement(loc, e); + return s; +} + +Statement *ReturnStatement::semantic(Scope *sc) +{ + //printf("ReturnStatement::semantic() %s\n", toChars()); + + FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + Scope *scx = sc; + int implicit0 = 0; + Expression *eorg = NULL; + + if (fd->fes) + fd = fd->fes->func; // fd is now function enclosing foreach + + Type *tret = fd->type->nextOf(); + if (fd->tintro) + /* We'll be implicitly casting the return expression to tintro + */ + tret = fd->tintro->nextOf(); + Type *tbret = NULL; + + if (tret) + tbret = tret->toBasetype(); + + // main() returns 0, even if it returns void + if (!exp && (!tbret || tbret->ty == Tvoid) && fd->isMain()) + { implicit0 = 1; + exp = new IntegerExp(0); + } + + if (sc->incontract || scx->incontract) + error("return statements cannot be in contracts"); + if (sc->tf || scx->tf) + error("return statements cannot be in finally, scope(exit) or scope(success) bodies"); + + if (fd->isCtorDeclaration()) + { + // Constructors implicitly do: + // return this; + if (exp && exp->op != TOKthis) + error("cannot return expression from constructor"); + exp = new ThisExp(0); + exp->type = tret; + } + + if (!exp) + fd->nrvo_can = 0; + + if (exp) + { + fd->hasReturnExp |= 1; + + if (exp->op == TOKfunction && tbret) + ((FuncExp *)exp)->setType(tbret); + + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + if (!((TypeFunction *)fd->type)->isref) + exp = exp->optimize(WANTvalue); + + if (fd->nrvo_can && exp->op == TOKvar) + { VarExp *ve = (VarExp *)exp; + VarDeclaration *v = ve->var->isVarDeclaration(); + + if (((TypeFunction *)fd->type)->isref) + // Function returns a reference + fd->nrvo_can = 0; + else if (!v || v->isOut() || v->isRef()) + fd->nrvo_can = 0; +// else if (tbret->ty == Tstruct && ((TypeStruct *)tbret)->sym->dtor) +// // Struct being returned has destructors +// fd->nrvo_can = 0; + else if (fd->nrvo_var == NULL) + { if (!v->isDataseg() && !v->isParameter() && v->toParent2() == fd) + { //printf("Setting nrvo to %s\n", v->toChars()); + fd->nrvo_var = v; + } + else + fd->nrvo_can = 0; + } + else if (fd->nrvo_var != v) + fd->nrvo_can = 0; + } + else + fd->nrvo_can = 0; + + if (fd->inferRetType) + { TypeFunction *tf = (TypeFunction *)fd->type; + assert(tf->ty == Tfunction); + Type *tfret = tf->nextOf(); + if (tfret) + { + if (tfret != Type::terror) + { + if (!exp->type->equals(tfret)) + { + int m1 = exp->type->implicitConvTo(tfret); + int m2 = tfret->implicitConvTo(exp->type); + //printf("exp->type = %s m2<-->m1 tret %s\n", exp->type->toChars(), tfret->toChars()); + //printf("m1 = %d, m2 = %d\n", m1, m2); + + if (m1 && m2) + ; + else if (!m1 && m2) + tf->next = exp->type; + else if (m1 && !m2) + ; + else + error("mismatched function return type inference of %s and %s", + exp->type->toChars(), tfret->toChars()); + } + } + + /* The "refness" is determined by the first return statement, + * not all of them. This means: + * return 3; return x; // ok, x can be a value + * return x; return 3; // error, 3 is not an lvalue + */ + } + else + { + if (tf->isref) + { /* Determine "refness" of function return: + * if it's an lvalue, return by ref, else return by value + */ + if (exp->isLvalue()) + { + /* Return by ref + * (but first ensure it doesn't fail the "check for + * escaping reference" test) + */ + unsigned errors = global.startGagging(); + exp->checkEscapeRef(); + if (global.endGagging(errors)) + { tf->isref = FALSE; // return by value + } + } + else + tf->isref = FALSE; // return by value + } + tf->next = exp->type; + //fd->type = tf->semantic(loc, sc); // Removed with 6902 + if (!fd->tintro) + { tret = fd->type->nextOf(); + tbret = tret->toBasetype(); + } + } + if (fd->returnLabel) + eorg = exp; + } + else if (tbret->ty != Tvoid) + { + if (fd->isPureBypassingInference() == PUREstrong && + !exp->type->implicitConvTo(tret) && + exp->type->invariantOf()->implicitConvTo(tret)) + { + exp = exp->castTo(sc, exp->type->invariantOf()); + } + if (fd->tintro) + exp = exp->implicitCastTo(sc, fd->type->nextOf()); + + // eorg isn't casted to tret (== fd->tintro->nextOf()) + if (fd->returnLabel) + eorg = exp->copy(); + exp = exp->implicitCastTo(sc, tret); + + if (!((TypeFunction *)fd->type)->isref) + exp = exp->optimize(WANTvalue); + } + } + else if (fd->inferRetType) + { + if (fd->type->nextOf()) + { + if (fd->type->nextOf()->ty != Tvoid) + error("mismatched function return type inference of void and %s", + fd->type->nextOf()->toChars()); + } + else + { + ((TypeFunction *)fd->type)->next = Type::tvoid; + //fd->type = fd->type->semantic(loc, sc); // Remove with7321, same as 6902 + if (!fd->tintro) + { tret = Type::tvoid; + tbret = tret; + } + } + } + else if (tbret->ty != Tvoid) // if non-void return + error("return expression expected"); + + if (sc->fes) + { + Statement *s; + + if (exp && !implicit0) + { + exp = exp->implicitCastTo(sc, tret); + } + if (!exp || exp->op == TOKint64 || exp->op == TOKfloat64 || + exp->op == TOKimaginary80 || exp->op == TOKcomplex80 || + exp->op == TOKthis || exp->op == TOKsuper || exp->op == TOKnull || + exp->op == TOKstring) + { + sc->fes->cases->push(this); + // Construct: return cases->dim+1; + s = new ReturnStatement(0, new IntegerExp(sc->fes->cases->dim + 1)); + } + else if (fd->type->nextOf()->toBasetype() == Type::tvoid) + { + s = new ReturnStatement(0, NULL); + sc->fes->cases->push(s); + + // Construct: { exp; return cases->dim + 1; } + Statement *s1 = new ExpStatement(loc, exp); + Statement *s2 = new ReturnStatement(0, new IntegerExp(sc->fes->cases->dim + 1)); + s = new CompoundStatement(loc, s1, s2); + } + else + { + // Construct: return vresult; + if (!fd->vresult) + { // Declare vresult + VarDeclaration *v = new VarDeclaration(loc, tret, Id::result, NULL); + v->noscope = 1; + v->storage_class |= STCresult; + v->semantic(scx); + if (!scx->insert(v)) + assert(0); + v->parent = fd; + fd->vresult = v; + } + + s = new ReturnStatement(0, new VarExp(0, fd->vresult)); + sc->fes->cases->push(s); + + // Construct: { vresult = exp; return cases->dim + 1; } + exp = new ConstructExp(loc, new VarExp(0, fd->vresult), exp); + exp = exp->semantic(sc); + Statement *s1 = new ExpStatement(loc, exp); + Statement *s2 = new ReturnStatement(0, new IntegerExp(sc->fes->cases->dim + 1)); + s = new CompoundStatement(loc, s1, s2); + } + return s; + } + + if (exp) + { + if (((TypeFunction *)fd->type)->isref && !fd->isCtorDeclaration()) + { // Function returns a reference + if (tret->isMutable()) + exp = exp->modifiableLvalue(sc, exp); + else + exp = exp->toLvalue(sc, exp); + + exp->checkEscapeRef(); + } + else + { + //exp->dump(0); + //exp->print(); + exp->checkEscape(); + } + + if (fd->returnLabel && tbret->ty != Tvoid) + { + assert(fd->vresult); + VarExp *v = new VarExp(0, fd->vresult); + + assert(eorg); + exp = new ConstructExp(loc, v, eorg); + exp = exp->semantic(sc); + } + } + + /* BUG: need to issue an error on: + * this + * { if (x) return; + * super(); + * } + */ + + if (sc->callSuper & CSXany_ctor && + !(sc->callSuper & (CSXthis_ctor | CSXsuper_ctor))) + error("return without calling constructor"); + + sc->callSuper |= CSXreturn; + + // See if all returns are instead to be replaced with a goto returnLabel; + if (fd->returnLabel) + { + GotoStatement *gs = new GotoStatement(loc, Id::returnLabel); + + gs->label = fd->returnLabel; + if (exp) + { /* Replace: return exp; + * with: exp; goto returnLabel; + */ + Statement *s = new ExpStatement(0, exp); + return new CompoundStatement(loc, s, gs); + } + return gs; + } + + if (exp && tbret->ty == Tvoid && !implicit0) + { + /* Replace: + * return exp; + * with: + * exp; return; + */ + Statement *s = new ExpStatement(loc, exp); + s = s->semantic(sc); + + if (exp->type->ty != Tvoid) + { + error("cannot return non-void from void function"); + } + + exp = NULL; + return new CompoundStatement(loc, s, this); + } + + if (exp) + { if (exp->op == TOKcall) + valueNoDtor(exp); + else + { + Expression *e = exp->isTemp(); + if (e) + exp = e; // don't need temporary + } + } + + return this; +} + +int ReturnStatement::blockExit(bool mustNotThrow) +{ int result = BEreturn; + + if (exp && exp->canThrow(mustNotThrow)) + result |= BEthrow; + return result; +} + + +void ReturnStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("return "); + if (exp) + exp->toCBuffer(buf, hgs); + buf->writeByte(';'); + buf->writenl(); +} + +/******************************** BreakStatement ***************************/ + +BreakStatement::BreakStatement(Loc loc, Identifier *ident) + : Statement(loc) +{ + this->ident = ident; +} + +Statement *BreakStatement::syntaxCopy() +{ + BreakStatement *s = new BreakStatement(loc, ident); + return s; +} + +Statement *BreakStatement::semantic(Scope *sc) +{ + //printf("BreakStatement::semantic()\n"); + // If: + // break Identifier; + if (ident) + { + Scope *scx; + FuncDeclaration *thisfunc = sc->func; + + for (scx = sc; scx; scx = scx->enclosing) + { + LabelStatement *ls; + + if (scx->func != thisfunc) // if in enclosing function + { + if (sc->fes) // if this is the body of a foreach + { + /* Post this statement to the fes, and replace + * it with a return value that caller will put into + * a switch. Caller will figure out where the break + * label actually is. + * Case numbers start with 2, not 0, as 0 is continue + * and 1 is break. + */ + Statement *s; + sc->fes->cases->push(this); + s = new ReturnStatement(0, new IntegerExp(sc->fes->cases->dim + 1)); + return s; + } + break; // can't break to it + } + + ls = scx->slabel; + if (ls && ls->ident == ident) + { + Statement *s = ls->statement; + + if (!s->hasBreak()) + error("label '%s' has no break", ident->toChars()); + if (ls->tf != sc->tf) + error("cannot break out of finally block"); + return this; + } + } + error("enclosing label '%s' for break not found", ident->toChars()); + } + else if (!sc->sbreak) + { + if (sc->fes) + { Statement *s; + + // Replace break; with return 1; + s = new ReturnStatement(0, new IntegerExp(1)); + return s; + } + error("break is not inside a loop or switch"); + } + return this; +} + +int BreakStatement::blockExit(bool mustNotThrow) +{ + //printf("BreakStatement::blockExit(%p) = x%x\n", this, ident ? BEgoto : BEbreak); + return ident ? BEgoto : BEbreak; +} + + +void BreakStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("break"); + if (ident) + { buf->writebyte(' '); + buf->writestring(ident->toChars()); + } + buf->writebyte(';'); + buf->writenl(); +} + +/******************************** ContinueStatement ***************************/ + +ContinueStatement::ContinueStatement(Loc loc, Identifier *ident) + : Statement(loc) +{ + this->ident = ident; +} + +Statement *ContinueStatement::syntaxCopy() +{ + ContinueStatement *s = new ContinueStatement(loc, ident); + return s; +} + +Statement *ContinueStatement::semantic(Scope *sc) +{ + //printf("ContinueStatement::semantic() %p\n", this); + if (ident) + { + Scope *scx; + FuncDeclaration *thisfunc = sc->func; + + for (scx = sc; scx; scx = scx->enclosing) + { + LabelStatement *ls; + + if (scx->func != thisfunc) // if in enclosing function + { + if (sc->fes) // if this is the body of a foreach + { + for (; scx; scx = scx->enclosing) + { + ls = scx->slabel; + if (ls && ls->ident == ident && ls->statement == sc->fes) + { + // Replace continue ident; with return 0; + return new ReturnStatement(0, new IntegerExp(0)); + } + } + + /* Post this statement to the fes, and replace + * it with a return value that caller will put into + * a switch. Caller will figure out where the break + * label actually is. + * Case numbers start with 2, not 0, as 0 is continue + * and 1 is break. + */ + Statement *s; + sc->fes->cases->push(this); + s = new ReturnStatement(0, new IntegerExp(sc->fes->cases->dim + 1)); + return s; + } + break; // can't continue to it + } + + ls = scx->slabel; + if (ls && ls->ident == ident) + { + Statement *s = ls->statement; + + if (!s->hasContinue()) + error("label '%s' has no continue", ident->toChars()); + if (ls->tf != sc->tf) + error("cannot continue out of finally block"); + return this; + } + } + error("enclosing label '%s' for continue not found", ident->toChars()); + } + else if (!sc->scontinue) + { + if (sc->fes) + { Statement *s; + + // Replace continue; with return 0; + s = new ReturnStatement(0, new IntegerExp(0)); + return s; + } + error("continue is not inside a loop"); + } + return this; +} + +int ContinueStatement::blockExit(bool mustNotThrow) +{ + return ident ? BEgoto : BEcontinue; +} + + +void ContinueStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("continue"); + if (ident) + { buf->writebyte(' '); + buf->writestring(ident->toChars()); + } + buf->writebyte(';'); + buf->writenl(); +} + +/******************************** SynchronizedStatement ***************************/ + +SynchronizedStatement::SynchronizedStatement(Loc loc, Expression *exp, Statement *body) + : Statement(loc) +{ + this->exp = exp; + this->body = body; + this->esync = NULL; +} + +SynchronizedStatement::SynchronizedStatement(Loc loc, elem *esync, Statement *body) + : Statement(loc) +{ + this->exp = NULL; + this->body = body; + this->esync = esync; +} + +Statement *SynchronizedStatement::syntaxCopy() +{ + Expression *e = exp ? exp->syntaxCopy() : NULL; + SynchronizedStatement *s = new SynchronizedStatement(loc, e, body ? body->syntaxCopy() : NULL); + return s; +} + +Statement *SynchronizedStatement::semantic(Scope *sc) +{ + if (exp) + { + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + ClassDeclaration *cd = exp->type->isClassHandle(); + if (!cd) + error("can only synchronize on class objects, not '%s'", exp->type->toChars()); + else if (cd->isInterfaceDeclaration()) + { /* Cast the interface to an object, as the object has the monitor, + * not the interface. + */ + Type *t = new TypeIdentifier(0, Id::Object); + + t = t->semantic(0, sc); + exp = new CastExp(loc, exp, t); + exp = exp->semantic(sc); + } + +#if 1 + /* Rewrite as: + * auto tmp = exp; + * _d_monitorenter(tmp); + * try { body } finally { _d_monitorexit(tmp); } + */ + Identifier *id = Lexer::uniqueId("__sync"); + ExpInitializer *ie = new ExpInitializer(loc, exp); + VarDeclaration *tmp = new VarDeclaration(loc, exp->type, id, ie); + + Statements *cs = new Statements(); + cs->push(new ExpStatement(loc, tmp)); + + FuncDeclaration *fdenter = FuncDeclaration::genCfunc(Type::tvoid, Id::monitorenter); + Expression *e = new CallExp(loc, new VarExp(loc, fdenter), new VarExp(loc, tmp)); + e->type = Type::tvoid; // do not run semantic on e + cs->push(new ExpStatement(loc, e)); + + FuncDeclaration *fdexit = FuncDeclaration::genCfunc(Type::tvoid, Id::monitorexit); + e = new CallExp(loc, new VarExp(loc, fdexit), new VarExp(loc, tmp)); + e->type = Type::tvoid; // do not run semantic on e + Statement *s = new ExpStatement(loc, e); + s = new TryFinallyStatement(loc, body, s); + cs->push(s); + + s = new CompoundStatement(loc, cs); + return s->semantic(sc); +#endif + } +#if 1 + else + { /* Generate our own critical section, then rewrite as: + * __gshared byte[CriticalSection.sizeof] critsec; + * _d_criticalenter(critsec.ptr); + * try { body } finally { _d_criticalexit(critsec.ptr); } + */ + Identifier *id = Lexer::uniqueId("__critsec"); + Type *t = new TypeSArray(Type::tint8, new IntegerExp(PTRSIZE + (global.params.is64bit ? os_critsecsize64() : os_critsecsize32()))); + VarDeclaration *tmp = new VarDeclaration(loc, t, id, NULL); + tmp->storage_class |= STCgshared | STCstatic; + + Statements *cs = new Statements(); + cs->push(new ExpStatement(loc, tmp)); + + FuncDeclaration *fdenter = FuncDeclaration::genCfunc(Type::tvoid, Id::criticalenter); + Expression *e = new DotIdExp(loc, new VarExp(loc, tmp), Id::ptr); + e = e->semantic(sc); + e = new CallExp(loc, new VarExp(loc, fdenter), e); + e->type = Type::tvoid; // do not run semantic on e + cs->push(new ExpStatement(loc, e)); + + FuncDeclaration *fdexit = FuncDeclaration::genCfunc(Type::tvoid, Id::criticalexit); + e = new DotIdExp(loc, new VarExp(loc, tmp), Id::ptr); + e = e->semantic(sc); + e = new CallExp(loc, new VarExp(loc, fdexit), e); + e->type = Type::tvoid; // do not run semantic on e + Statement *s = new ExpStatement(loc, e); + s = new TryFinallyStatement(loc, body, s); + cs->push(s); + + s = new CompoundStatement(loc, cs); + return s->semantic(sc); + } +#endif + if (body) + body = body->semantic(sc); + return this; +} + +int SynchronizedStatement::hasBreak() +{ + return FALSE; //TRUE; +} + +int SynchronizedStatement::hasContinue() +{ + return FALSE; //TRUE; +} + +int SynchronizedStatement::usesEH() +{ + return TRUE; +} + +int SynchronizedStatement::blockExit(bool mustNotThrow) +{ + return body ? body->blockExit(mustNotThrow) : BEfallthru; +} + + +void SynchronizedStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("synchronized"); + if (exp) + { buf->writebyte('('); + exp->toCBuffer(buf, hgs); + buf->writebyte(')'); + } + if (body) + { + buf->writebyte(' '); + body->toCBuffer(buf, hgs); + } +} + +/******************************** WithStatement ***************************/ + +WithStatement::WithStatement(Loc loc, Expression *exp, Statement *body) + : Statement(loc) +{ + this->exp = exp; + this->body = body; + wthis = NULL; +} + +Statement *WithStatement::syntaxCopy() +{ + WithStatement *s = new WithStatement(loc, exp->syntaxCopy(), body ? body->syntaxCopy() : NULL); + return s; +} + +Statement *WithStatement::semantic(Scope *sc) +{ ScopeDsymbol *sym; + Initializer *init; + + //printf("WithStatement::semantic()\n"); + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + if (exp->op == TOKerror) + return NULL; + if (exp->op == TOKimport) + { ScopeExp *es = (ScopeExp *)exp; + + sym = es->sds; + } + else if (exp->op == TOKtype) + { TypeExp *es = (TypeExp *)exp; + + Dsymbol *s = es->type->toDsymbol(sc); + sym = s ? s->isScopeDsymbol() : NULL; + if (!sym) + { error("with type %s has no members", es->toChars()); + if (body) + body = body->semantic(sc); + return this; + } + } + else + { Type *t = exp->type; + + assert(t); + t = t->toBasetype(); + if (t->isClassHandle()) + { + init = new ExpInitializer(loc, exp); + wthis = new VarDeclaration(loc, exp->type, Id::withSym, init); + wthis->semantic(sc); + + sym = new WithScopeSymbol(this); + sym->parent = sc->scopesym; + } + else if (t->ty == Tstruct) + { + Expression *e = exp->addressOf(sc); + init = new ExpInitializer(loc, e); + wthis = new VarDeclaration(loc, e->type, Id::withSym, init); + wthis->semantic(sc); + sym = new WithScopeSymbol(this); + sym->parent = sc->scopesym; + } + else + { error("with expressions must be class objects, not '%s'", exp->type->toChars()); + return NULL; + } + } + sc = sc->push(sym); + + if (body) + body = body->semantic(sc); + + sc->pop(); + + return this; +} + +void WithStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("with ("); + exp->toCBuffer(buf, hgs); + buf->writestring(")\n"); + if (body) + body->toCBuffer(buf, hgs); +} + +int WithStatement::usesEH() +{ + return body ? body->usesEH() : 0; +} + +int WithStatement::blockExit(bool mustNotThrow) +{ + int result = BEnone; + if (exp->canThrow(mustNotThrow)) + result = BEthrow; + if (body) + result |= body->blockExit(mustNotThrow); + else + result |= BEfallthru; + return result; +} + + +/******************************** TryCatchStatement ***************************/ + +TryCatchStatement::TryCatchStatement(Loc loc, Statement *body, Catches *catches) + : Statement(loc) +{ + this->body = body; + this->catches = catches; +} + +Statement *TryCatchStatement::syntaxCopy() +{ + Catches *a = new Catches(); + a->setDim(catches->dim); + for (size_t i = 0; i < a->dim; i++) + { Catch *c; + + c = (*catches)[i]; + c = c->syntaxCopy(); + (*a)[i] = c; + } + TryCatchStatement *s = new TryCatchStatement(loc, body->syntaxCopy(), a); + return s; +} + +Statement *TryCatchStatement::semantic(Scope *sc) +{ + body = body->semanticScope(sc, NULL /*this*/, NULL); + + /* Even if body is NULL, still do semantic analysis on catches + */ + for (size_t i = 0; i < catches->dim; i++) + { Catch *c = (*catches)[i]; + c->semantic(sc); + + // Determine if current catch 'hides' any previous catches + for (size_t j = 0; j < i; j++) + { Catch *cj = (*catches)[j]; + char *si = c->loc.toChars(); + char *sj = cj->loc.toChars(); + + if (c->type->toBasetype()->implicitConvTo(cj->type->toBasetype())) + error("catch at %s hides catch at %s", sj, si); + } + } + + if (!body || body->isEmpty()) + { + return NULL; + } + return this; +} + +int TryCatchStatement::hasBreak() +{ + return FALSE; //TRUE; +} + +int TryCatchStatement::usesEH() +{ + return TRUE; +} + +int TryCatchStatement::blockExit(bool mustNotThrow) +{ + assert(body); + int result = body->blockExit(false); + + int catchresult = 0; + for (size_t i = 0; i < catches->dim; i++) + { + Catch *c = (*catches)[i]; + if (c->type == Type::terror) + continue; + + catchresult |= c->blockExit(mustNotThrow); + + /* If we're catching Object, then there is no throwing + */ + Identifier *id = c->type->toBasetype()->isClassHandle()->ident; + if (id == Id::Object || id == Id::Throwable || id == Id::Exception) + { + result &= ~BEthrow; + } + } + if (mustNotThrow && (result & BEthrow)) + { + body->blockExit(mustNotThrow); // now explain why this is nothrow + } + return result | catchresult; +} + + +void TryCatchStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("try"); + buf->writenl(); + if (body) + body->toCBuffer(buf, hgs); + for (size_t i = 0; i < catches->dim; i++) + { + Catch *c = (*catches)[i]; + c->toCBuffer(buf, hgs); + } +} + +/******************************** Catch ***************************/ + +Catch::Catch(Loc loc, Type *t, Identifier *id, Statement *handler) +{ + //printf("Catch(%s, loc = %s)\n", id->toChars(), loc.toChars()); + this->loc = loc; + this->type = t; + this->ident = id; + this->handler = handler; + var = NULL; + internalCatch = false; +} + +Catch *Catch::syntaxCopy() +{ + Catch *c = new Catch(loc, + (type ? type->syntaxCopy() : NULL), + ident, + (handler ? handler->syntaxCopy() : NULL)); + c->internalCatch = internalCatch; + return c; +} + +void Catch::semantic(Scope *sc) +{ ScopeDsymbol *sym; + + //printf("Catch::semantic(%s)\n", ident->toChars()); + +#ifndef IN_GCC + if (sc->tf) + { + /* This is because the _d_local_unwind() gets the stack munged + * up on this. The workaround is to place any try-catches into + * a separate function, and call that. + * To fix, have the compiler automatically convert the finally + * body into a nested function. + */ + error(loc, "cannot put catch statement inside finally block"); + } +#endif + + sym = new ScopeDsymbol(); + sym->parent = sc->scopesym; + sc = sc->push(sym); + + if (!type) + type = new TypeIdentifier(0, Id::Throwable); + type = type->semantic(loc, sc); + ClassDeclaration *cd = type->toBasetype()->isClassHandle(); + if (!cd || ((cd != ClassDeclaration::throwable) && !ClassDeclaration::throwable->isBaseOf(cd, NULL))) + { + if (type != Type::terror) + { error(loc, "can only catch class objects derived from Throwable, not '%s'", type->toChars()); + type = Type::terror; + } + } + else if (sc->func && + !sc->intypeof && + !internalCatch && + cd != ClassDeclaration::exception && + !ClassDeclaration::exception->isBaseOf(cd, NULL) && + sc->func->setUnsafe()) + { + error(loc, "can only catch class objects derived from Exception in @safe code, not '%s'", type->toChars()); + type = Type::terror; + } + else if (ident) + { + var = new VarDeclaration(loc, type, ident, NULL); + var->parent = sc->parent; + sc->insert(var); + } + handler = handler->semantic(sc); + + sc->pop(); +} + +int Catch::blockExit(bool mustNotThrow) +{ + return handler ? handler->blockExit(mustNotThrow) : BEfallthru; +} + +void Catch::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("catch"); + if (type) + { buf->writebyte('('); + type->toCBuffer(buf, ident, hgs); + buf->writebyte(')'); + } + buf->writenl(); + buf->writebyte('{'); + buf->writenl(); + if (handler) + handler->toCBuffer(buf, hgs); + buf->writebyte('}'); + buf->writenl(); +} + +/****************************** TryFinallyStatement ***************************/ + +TryFinallyStatement::TryFinallyStatement(Loc loc, Statement *body, Statement *finalbody) + : Statement(loc) +{ + this->body = body; + this->finalbody = finalbody; +} + +Statement *TryFinallyStatement::syntaxCopy() +{ + TryFinallyStatement *s = new TryFinallyStatement(loc, + body->syntaxCopy(), finalbody->syntaxCopy()); + return s; +} + +Statement *TryFinallyStatement::semantic(Scope *sc) +{ + //printf("TryFinallyStatement::semantic()\n"); + body = body->semantic(sc); + sc = sc->push(); + sc->tf = this; + sc->sbreak = NULL; + sc->scontinue = NULL; // no break or continue out of finally block + finalbody = finalbody->semanticNoScope(sc); + sc->pop(); + if (!body) + return finalbody; + if (!finalbody) + return body; + if (body->blockExit(false) == BEfallthru) + { Statement *s = new CompoundStatement(loc, body, finalbody); + return s; + } + return this; +} + +void TryFinallyStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("try\n{\n"); + body->toCBuffer(buf, hgs); + buf->printf("}\nfinally\n{\n"); + finalbody->toCBuffer(buf, hgs); + buf->writeByte('}'); + buf->writenl(); +} + +int TryFinallyStatement::hasBreak() +{ + return FALSE; //TRUE; +} + +int TryFinallyStatement::hasContinue() +{ + return FALSE; //TRUE; +} + +int TryFinallyStatement::usesEH() +{ + return TRUE; +} + +int TryFinallyStatement::blockExit(bool mustNotThrow) +{ + if (body) + return body->blockExit(mustNotThrow); + return BEfallthru; +} + + +/****************************** OnScopeStatement ***************************/ + +OnScopeStatement::OnScopeStatement(Loc loc, TOK tok, Statement *statement) + : Statement(loc) +{ + this->tok = tok; + this->statement = statement; +} + +Statement *OnScopeStatement::syntaxCopy() +{ + OnScopeStatement *s = new OnScopeStatement(loc, + tok, statement->syntaxCopy()); + return s; +} + +Statement *OnScopeStatement::semantic(Scope *sc) +{ + /* semantic is called on results of scopeCode() */ + return this; +} + +int OnScopeStatement::blockExit(bool mustNotThrow) +{ // At this point, this statement is just an empty placeholder + return BEfallthru; +} + +void OnScopeStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(Token::toChars(tok)); + buf->writebyte(' '); + statement->toCBuffer(buf, hgs); +} + +int OnScopeStatement::usesEH() +{ + return 1; +} + +Statement *OnScopeStatement::scopeCode(Scope *sc, Statement **sentry, Statement **sexception, Statement **sfinally) +{ + //printf("OnScopeStatement::scopeCode()\n"); + //print(); + *sentry = NULL; + *sexception = NULL; + *sfinally = NULL; + switch (tok) + { + case TOKon_scope_exit: + *sfinally = statement; + break; + + case TOKon_scope_failure: + *sexception = statement; + break; + + case TOKon_scope_success: + { + /* Create: + * sentry: bool x = false; + * sexception: x = true; + * sfinally: if (!x) statement; + */ + Identifier *id = Lexer::uniqueId("__os"); + + ExpInitializer *ie = new ExpInitializer(loc, new IntegerExp(0, 0, Type::tbool)); + VarDeclaration *v = new VarDeclaration(loc, Type::tbool, id, ie); + *sentry = new ExpStatement(loc, v); + + Expression *e = new IntegerExp(0, 1, Type::tbool); + e = new AssignExp(0, new VarExp(0, v), e); + *sexception = new ExpStatement(0, e); + + e = new VarExp(0, v); + e = new NotExp(0, e); + *sfinally = new IfStatement(0, NULL, e, statement, NULL); + + break; + } + + default: + assert(0); + } + return NULL; +} + +/******************************** ThrowStatement ***************************/ + +ThrowStatement::ThrowStatement(Loc loc, Expression *exp) + : Statement(loc) +{ + this->exp = exp; +} + +Statement *ThrowStatement::syntaxCopy() +{ + ThrowStatement *s = new ThrowStatement(loc, exp->syntaxCopy()); + return s; +} + +Statement *ThrowStatement::semantic(Scope *sc) +{ + //printf("ThrowStatement::semantic()\n"); + + FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + fd->hasReturnExp |= 2; + +#if DMDV1 + // See bugzilla 3388. Should this be or not? + if (sc->incontract) + error("Throw statements cannot be in contracts"); +#endif + exp = exp->semantic(sc); + exp = resolveProperties(sc, exp); + if (exp->op == TOKerror) + return this; + ClassDeclaration *cd = exp->type->toBasetype()->isClassHandle(); + if (!cd || ((cd != ClassDeclaration::throwable) && !ClassDeclaration::throwable->isBaseOf(cd, NULL))) + error("can only throw class objects derived from Throwable, not type %s", exp->type->toChars()); + + return this; +} + +int ThrowStatement::blockExit(bool mustNotThrow) +{ + if (mustNotThrow) + error("%s is thrown but not caught", exp->type->toChars()); + return BEthrow; // obviously +} + + +void ThrowStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("throw "); + exp->toCBuffer(buf, hgs); + buf->writeByte(';'); + buf->writenl(); +} + +/******************************** VolatileStatement **************************/ + +VolatileStatement::VolatileStatement(Loc loc, Statement *statement) + : Statement(loc) +{ + this->statement = statement; +} + +Statement *VolatileStatement::syntaxCopy() +{ + VolatileStatement *s = new VolatileStatement(loc, + statement ? statement->syntaxCopy() : NULL); + return s; +} + +Statement *VolatileStatement::semantic(Scope *sc) +{ + if (statement) + statement = statement->semantic(sc); + return this; +} + +Statements *VolatileStatement::flatten(Scope *sc) +{ + Statements *a; + + a = statement ? statement->flatten(sc) : NULL; + if (a) + { for (size_t i = 0; i < a->dim; i++) + { Statement *s = (*a)[i]; + + s = new VolatileStatement(loc, s); + (*a)[i] = s; + } + } + + return a; +} + +int VolatileStatement::blockExit(bool mustNotThrow) +{ + return statement ? statement->blockExit(mustNotThrow) : BEfallthru; +} + + +void VolatileStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("volatile"); + if (statement) + { if (statement->isScopeStatement()) + buf->writenl(); + else + buf->writebyte(' '); + statement->toCBuffer(buf, hgs); + } +} + + +/******************************** DebugStatement **************************/ + +DebugStatement::DebugStatement(Loc loc, Statement *statement) + : Statement(loc) +{ + this->statement = statement; +} + +Statement *DebugStatement::syntaxCopy() +{ + DebugStatement *s = new DebugStatement(loc, + statement ? statement->syntaxCopy() : NULL); + return s; +} + +Statement *DebugStatement::semantic(Scope *sc) +{ + if (statement) + { + sc = sc->push(); + sc->flags |= SCOPEdebug; + statement = statement->semantic(sc); + sc->pop(); + } + return statement; +} + +Statements *DebugStatement::flatten(Scope *sc) +{ + Statements *a = statement ? statement->flatten(sc) : NULL; + if (a) + { for (size_t i = 0; i < a->dim; i++) + { Statement *s = (*a)[i]; + + s = new DebugStatement(loc, s); + (*a)[i] = s; + } + } + + return a; +} + +void DebugStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + if (statement) + { + statement->toCBuffer(buf, hgs); + } +} + + +/******************************** GotoStatement ***************************/ + +GotoStatement::GotoStatement(Loc loc, Identifier *ident) + : Statement(loc) +{ + this->ident = ident; + this->label = NULL; + this->tf = NULL; +} + +Statement *GotoStatement::syntaxCopy() +{ + GotoStatement *s = new GotoStatement(loc, ident); + return s; +} + +Statement *GotoStatement::semantic(Scope *sc) +{ FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + + //printf("GotoStatement::semantic()\n"); + tf = sc->tf; + label = fd->searchLabel(ident); + if (!label->statement && sc->fes) + { + /* Either the goto label is forward referenced or it + * is in the function that the enclosing foreach is in. + * Can't know yet, so wrap the goto in a compound statement + * so we can patch it later, and add it to a 'look at this later' + * list. + */ + Statements *a = new Statements(); + CompoundStatement *s; + + a->push(this); + s = new CompoundStatement(loc, a); + sc->fes->gotos->push(s); // 'look at this later' list + return s; + } + if (label->statement && label->statement->tf != sc->tf) + error("cannot goto in or out of finally block"); + return this; +} + +int GotoStatement::blockExit(bool mustNotThrow) +{ + //printf("GotoStatement::blockExit(%p)\n", this); + return BEgoto; +} + + +void GotoStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("goto "); + buf->writestring(ident->toChars()); + buf->writebyte(';'); + buf->writenl(); +} + +/******************************** LabelStatement ***************************/ + +LabelStatement::LabelStatement(Loc loc, Identifier *ident, Statement *statement) + : Statement(loc) +{ + this->ident = ident; + this->statement = statement; + this->tf = NULL; + this->lblock = NULL; + this->fwdrefs = NULL; +} + +Statement *LabelStatement::syntaxCopy() +{ + LabelStatement *s = new LabelStatement(loc, ident, statement->syntaxCopy()); + return s; +} + +Statement *LabelStatement::semantic(Scope *sc) +{ LabelDsymbol *ls; + FuncDeclaration *fd = sc->parent->isFuncDeclaration(); + + //printf("LabelStatement::semantic()\n"); + ls = fd->searchLabel(ident); + if (ls->statement) + error("Label '%s' already defined", ls->toChars()); + else + ls->statement = this; + tf = sc->tf; + sc = sc->push(); + sc->scopesym = sc->enclosing->scopesym; + sc->callSuper |= CSXlabel; + sc->slabel = this; + if (statement) + statement = statement->semanticNoScope(sc); + sc->pop(); + return this; +} + +Statements *LabelStatement::flatten(Scope *sc) +{ + Statements *a = NULL; + + if (statement) + { + a = statement->flatten(sc); + if (a) + { + if (!a->dim) + { + a->push(new ExpStatement(loc, (Expression *)NULL)); + } + Statement *s = (*a)[0]; + + s = new LabelStatement(loc, ident, s); + (*a)[0] = s; + } + } + + return a; +} + + +int LabelStatement::usesEH() +{ + return statement ? statement->usesEH() : FALSE; +} + +int LabelStatement::blockExit(bool mustNotThrow) +{ + //printf("LabelStatement::blockExit(%p)\n", this); + return statement ? statement->blockExit(mustNotThrow) : BEfallthru; +} + + +int LabelStatement::comeFrom() +{ + //printf("LabelStatement::comeFrom()\n"); + return TRUE; +} + +void LabelStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(ident->toChars()); + buf->writebyte(':'); + buf->writenl(); + if (statement) + statement->toCBuffer(buf, hgs); +} + + +/******************************** LabelDsymbol ***************************/ + +LabelDsymbol::LabelDsymbol(Identifier *ident) + : Dsymbol(ident) +{ + statement = NULL; +#if IN_GCC + asmLabelNum = 0; +#endif +} + +LabelDsymbol *LabelDsymbol::isLabel() // is this a LabelDsymbol()? +{ + return this; +} + + +/************************ AsmStatement ***************************************/ + +AsmStatement::AsmStatement(Loc loc, Token *tokens) + : Statement(loc) +{ + this->tokens = tokens; + asmcode = NULL; + asmalign = 0; + refparam = FALSE; + naked = FALSE; + regs = 0; +} + +Statement *AsmStatement::syntaxCopy() +{ + return new AsmStatement(loc, tokens); +} + + + +int AsmStatement::comeFrom() +{ + return TRUE; +} + +int AsmStatement::blockExit(bool mustNotThrow) +{ + if (mustNotThrow) + error("asm statements are assumed to throw", toChars()); + // Assume the worst + return BEfallthru | BEthrow | BEreturn | BEgoto | BEhalt; +} + +void AsmStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("asm { "); + Token *t = tokens; + while (t) + { + buf->writestring(t->toChars()); + if (t->next && + t->value != TOKmin && + t->value != TOKcomma && + t->next->value != TOKcomma && + t->value != TOKlbracket && + t->next->value != TOKlbracket && + t->next->value != TOKrbracket && + t->value != TOKlparen && + t->next->value != TOKlparen && + t->next->value != TOKrparen && + t->value != TOKdot && + t->next->value != TOKdot) + { + buf->writebyte(' '); + } + t = t->next; + } + buf->writestring("; }"); + buf->writenl(); +} + +/************************ ImportStatement ***************************************/ + +ImportStatement::ImportStatement(Loc loc, Dsymbols *imports) + : Statement(loc) +{ + this->imports = imports; +} + +Statement *ImportStatement::syntaxCopy() +{ + Dsymbols *m = new Dsymbols(); + m->setDim(imports->dim); + for (size_t i = 0; i < imports->dim; i++) + { Dsymbol *s = (*imports)[i]; + (*m)[i] = s->syntaxCopy(NULL); + } + return new ImportStatement(loc, m); +} + +Statement *ImportStatement::semantic(Scope *sc) +{ + for (size_t i = 0; i < imports->dim; i++) + { Dsymbol *s = (*imports)[i]; + s->semantic(sc); + sc->insert(s); + } + return this; +} + +int ImportStatement::blockExit(bool mustNotThrow) +{ + return BEfallthru; +} + +int ImportStatement::isEmpty() +{ + return TRUE; +} + +void ImportStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + for (size_t i = 0; i < imports->dim; i++) + { Dsymbol *s = (*imports)[i]; + s->toCBuffer(buf, hgs); + } +} diff --git a/statement.h b/statement.h new file mode 100644 index 00000000..6ce93d1d --- /dev/null +++ b/statement.h @@ -0,0 +1,904 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_STATEMENT_H +#define DMD_STATEMENT_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" + +#include "arraytypes.h" +#include "dsymbol.h" +#include "lexer.h" + +struct OutBuffer; +struct Scope; +struct Expression; +struct LabelDsymbol; +struct Identifier; +struct IfStatement; +struct ExpStatement; +struct DefaultStatement; +struct VarDeclaration; +struct Condition; +struct Module; +struct Token; +struct InlineCostState; +struct InlineDoState; +struct InlineScanState; +struct ReturnStatement; +struct CompoundStatement; +struct Parameter; +struct StaticAssert; +struct AsmStatement; +struct GotoStatement; +struct ScopeStatement; +struct TryCatchStatement; +struct TryFinallyStatement; +struct CaseStatement; +struct DefaultStatement; +struct LabelStatement; +struct HdrGenState; +struct InterState; + +enum TOK; + +// Back end +struct IRState; +struct Blockx; +#if IN_GCC +union tree_node; typedef union tree_node block; +union tree_node; typedef union tree_node elem; +#else +struct block; +struct elem; +#endif +struct code; + +/* How a statement exits; this is returned by blockExit() + */ +enum BE +{ + BEnone = 0, + BEfallthru = 1, + BEthrow = 2, + BEreturn = 4, + BEgoto = 8, + BEhalt = 0x10, + BEbreak = 0x20, + BEcontinue = 0x40, + BEany = (BEfallthru | BEthrow | BEreturn | BEgoto | BEhalt), +}; + +struct Statement : Object +{ + Loc loc; + + Statement(Loc loc); + virtual Statement *syntaxCopy(); + + void print(); + char *toChars(); + + void error(const char *format, ...); + void warning(const char *format, ...); + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int incontract; + virtual ScopeStatement *isScopeStatement() { return NULL; } + virtual Statement *semantic(Scope *sc); + Statement *semanticScope(Scope *sc, Statement *sbreak, Statement *scontinue); + Statement *semanticNoScope(Scope *sc); + virtual int hasBreak(); + virtual int hasContinue(); + virtual int usesEH(); + virtual int blockExit(bool mustNotThrow); + virtual int comeFrom(); + virtual int isEmpty(); + virtual Statement *scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally); + virtual Statements *flatten(Scope *sc); + virtual Expression *interpret(InterState *istate); + virtual Statement *last(); + + virtual int inlineCost(InlineCostState *ics); + virtual Expression *doInline(InlineDoState *ids); + virtual Statement *doInlineStatement(InlineDoState *ids); + virtual Statement *inlineScan(InlineScanState *iss); + + // Back end + virtual void toIR(IRState *irs); + + // Avoid dynamic_cast + virtual ExpStatement *isExpStatement() { return NULL; } + virtual CompoundStatement *isCompoundStatement() { return NULL; } + virtual ReturnStatement *isReturnStatement() { return NULL; } + virtual IfStatement *isIfStatement() { return NULL; } + virtual CaseStatement *isCaseStatement() { return NULL; } + virtual DefaultStatement *isDefaultStatement() { return NULL; } + virtual LabelStatement *isLabelStatement() { return NULL; } +}; + +struct PeelStatement : Statement +{ + Statement *s; + + PeelStatement(Statement *s); + Statement *semantic(Scope *sc); +}; + +struct ExpStatement : Statement +{ + Expression *exp; + + ExpStatement(Loc loc, Expression *exp); + ExpStatement(Loc loc, Dsymbol *s); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + int blockExit(bool mustNotThrow); + int isEmpty(); + Statement *scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); + + ExpStatement *isExpStatement() { return this; } +}; + +struct DtorExpStatement : ExpStatement +{ + /* Wraps an expression that is the destruction of 'var' + */ + + VarDeclaration *var; + + DtorExpStatement(Loc loc, Expression *exp, VarDeclaration *v); + Statement *syntaxCopy(); + void toIR(IRState *irs); +}; + +struct CompileStatement : Statement +{ + Expression *exp; + + CompileStatement(Loc loc, Expression *exp); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statements *flatten(Scope *sc); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); +}; + +struct CompoundStatement : Statement +{ + Statements *statements; + + CompoundStatement(Loc loc, Statements *s); + CompoundStatement(Loc loc, Statement *s1); + CompoundStatement(Loc loc, Statement *s1, Statement *s2); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statement *semantic(Scope *sc); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + int isEmpty(); + Statements *flatten(Scope *sc); + ReturnStatement *isReturnStatement(); + Expression *interpret(InterState *istate); + Statement *last(); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); + + CompoundStatement *isCompoundStatement() { return this; } +}; + +struct CompoundDeclarationStatement : CompoundStatement +{ + CompoundDeclarationStatement(Loc loc, Statements *s); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +/* The purpose of this is so that continue will go to the next + * of the statements, and break will go to the end of the statements. + */ +struct UnrolledLoopStatement : Statement +{ + Statements *statements; + + UnrolledLoopStatement(Loc loc, Statements *statements); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct ScopeStatement : Statement +{ + Statement *statement; + + ScopeStatement(Loc loc, Statement *s); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + ScopeStatement *isScopeStatement() { return this; } + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + int isEmpty(); + Expression *interpret(InterState *istate); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct WhileStatement : Statement +{ + Expression *condition; + Statement *body; + + WhileStatement(Loc loc, Expression *c, Statement *b); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct DoStatement : Statement +{ + Statement *body; + Expression *condition; + + DoStatement(Loc loc, Statement *b, Expression *c); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct ForStatement : Statement +{ + Statement *init; + Expression *condition; + Expression *increment; + Statement *body; + + ForStatement(Loc loc, Statement *init, Expression *condition, Expression *increment, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Statement *scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + int inlineCost(InlineCostState *ics); + Statement *inlineScan(InlineScanState *iss); + Statement *doInlineStatement(InlineDoState *ids); + + void toIR(IRState *irs); +}; + +struct ForeachStatement : Statement +{ + enum TOK op; // TOKforeach or TOKforeach_reverse + Parameters *arguments; // array of Parameter*'s + Expression *aggr; + Statement *body; + + VarDeclaration *key; + VarDeclaration *value; + + FuncDeclaration *func; // function we're lexically in + + Statements *cases; // put breaks, continues, gotos and returns here + CompoundStatements *gotos; // forward referenced goto's go here + + ForeachStatement(Loc loc, enum TOK op, Parameters *arguments, Expression *aggr, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + bool checkForArgTypes(); + int inferAggregate(Scope *sc, Dsymbol *&sapply); + int inferApplyArgTypes(Scope *sc, Dsymbol *&sapply); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +#if DMDV2 +struct ForeachRangeStatement : Statement +{ + enum TOK op; // TOKforeach or TOKforeach_reverse + Parameter *arg; // loop index variable + Expression *lwr; + Expression *upr; + Statement *body; + + VarDeclaration *key; + + ForeachRangeStatement(Loc loc, enum TOK op, Parameter *arg, + Expression *lwr, Expression *upr, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; +#endif + +struct IfStatement : Statement +{ + Parameter *arg; + Expression *condition; + Statement *ifbody; + Statement *elsebody; + + VarDeclaration *match; // for MatchExpression results + + IfStatement(Loc loc, Parameter *arg, Expression *condition, Statement *ifbody, Statement *elsebody); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int usesEH(); + int blockExit(bool mustNotThrow); + IfStatement *isIfStatement() { return this; } + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct ConditionalStatement : Statement +{ + Condition *condition; + Statement *ifbody; + Statement *elsebody; + + ConditionalStatement(Loc loc, Condition *condition, Statement *ifbody, Statement *elsebody); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Statements *flatten(Scope *sc); + int usesEH(); + int blockExit(bool mustNotThrow); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct PragmaStatement : Statement +{ + Identifier *ident; + Expressions *args; // array of Expression's + Statement *body; + + PragmaStatement(Loc loc, Identifier *ident, Expressions *args, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int usesEH(); + int blockExit(bool mustNotThrow); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct StaticAssertStatement : Statement +{ + StaticAssert *sa; + + StaticAssertStatement(StaticAssert *sa); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct SwitchStatement : Statement +{ + Expression *condition; + Statement *body; + bool isFinal; + + DefaultStatement *sdefault; + TryFinallyStatement *tf; + GotoCaseStatements gotoCases; // array of unresolved GotoCaseStatement's + CaseStatements *cases; // array of CaseStatement's + int hasNoDefault; // !=0 if no default statement + int hasVars; // !=0 if has variable case values + + SwitchStatement(Loc loc, Expression *c, Statement *b, bool isFinal); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int usesEH(); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct CaseStatement : Statement +{ + Expression *exp; + Statement *statement; + + int index; // which case it is (since we sort this) + block *cblock; // back end: label for the block + + CaseStatement(Loc loc, Expression *exp, Statement *s); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int compare(Object *obj); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + CaseStatement *isCaseStatement() { return this; } + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +#if DMDV2 + +struct CaseRangeStatement : Statement +{ + Expression *first; + Expression *last; + Statement *statement; + + CaseRangeStatement(Loc loc, Expression *first, Expression *last, Statement *s); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +#endif + +struct DefaultStatement : Statement +{ + Statement *statement; +#if IN_GCC + block *cblock; // back end: label for the block +#endif + + DefaultStatement(Loc loc, Statement *s); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + DefaultStatement *isDefaultStatement() { return this; } + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct GotoDefaultStatement : Statement +{ + SwitchStatement *sw; + + GotoDefaultStatement(Loc loc); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct GotoCaseStatement : Statement +{ + Expression *exp; // NULL, or which case to goto + CaseStatement *cs; // case statement it resolves to + + GotoCaseStatement(Loc loc, Expression *exp); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct SwitchErrorStatement : Statement +{ + SwitchErrorStatement(Loc loc); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct ReturnStatement : Statement +{ + Expression *exp; + + ReturnStatement(Loc loc, Expression *exp); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); + + ReturnStatement *isReturnStatement() { return this; } +}; + +struct BreakStatement : Statement +{ + Identifier *ident; + + BreakStatement(Loc loc, Identifier *ident); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct ContinueStatement : Statement +{ + Identifier *ident; + + ContinueStatement(Loc loc, Identifier *ident); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Expression *interpret(InterState *istate); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toIR(IRState *irs); +}; + +struct SynchronizedStatement : Statement +{ + Expression *exp; + Statement *body; + + SynchronizedStatement(Loc loc, Expression *exp, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + +// Back end + elem *esync; + SynchronizedStatement(Loc loc, elem *esync, Statement *body); + void toIR(IRState *irs); +}; + +struct WithStatement : Statement +{ + Expression *exp; + Statement *body; + VarDeclaration *wthis; + + WithStatement(Loc loc, Expression *exp, Statement *body); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int usesEH(); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct TryCatchStatement : Statement +{ + Statement *body; + Catches *catches; + + TryCatchStatement(Loc loc, Statement *body, Catches *catches); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int hasBreak(); + int usesEH(); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct Catch : Object +{ + Loc loc; + Type *type; + Identifier *ident; + VarDeclaration *var; + Statement *handler; + bool internalCatch; + + Catch(Loc loc, Type *t, Identifier *id, Statement *handler); + Catch *syntaxCopy(); + void semantic(Scope *sc); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct TryFinallyStatement : Statement +{ + Statement *body; + Statement *finalbody; + + TryFinallyStatement(Loc loc, Statement *body, Statement *finalbody); + Statement *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statement *semantic(Scope *sc); + int hasBreak(); + int hasContinue(); + int usesEH(); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct OnScopeStatement : Statement +{ + TOK tok; + Statement *statement; + + OnScopeStatement(Loc loc, TOK tok, Statement *statement); + Statement *syntaxCopy(); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Statement *semantic(Scope *sc); + int usesEH(); + Statement *scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally); + Expression *interpret(InterState *istate); + + void toIR(IRState *irs); +}; + +struct ThrowStatement : Statement +{ + Expression *exp; + + ThrowStatement(Loc loc, Expression *exp); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct VolatileStatement : Statement +{ + Statement *statement; + + VolatileStatement(Loc loc, Statement *statement); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Statements *flatten(Scope *sc); + int blockExit(bool mustNotThrow); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct DebugStatement : Statement +{ + Statement *statement; + + DebugStatement(Loc loc, Statement *statement); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Statements *flatten(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct GotoStatement : Statement +{ + Identifier *ident; + LabelDsymbol *label; + TryFinallyStatement *tf; + + GotoStatement(Loc loc, Identifier *ident); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); + Expression *interpret(InterState *istate); + + void toIR(IRState *irs); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +struct LabelStatement : Statement +{ + Identifier *ident; + Statement *statement; + TryFinallyStatement *tf; + block *lblock; // back end + + Blocks *fwdrefs; // forward references to this LabelStatement + + LabelStatement(Loc loc, Identifier *ident, Statement *statement); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + Statements *flatten(Scope *sc); + int usesEH(); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + Statement *inlineScan(InlineScanState *iss); + LabelStatement *isLabelStatement() { return this; } + + void toIR(IRState *irs); +}; + +struct LabelDsymbol : Dsymbol +{ + LabelStatement *statement; +#if IN_GCC + unsigned asmLabelNum; // GCC-specific +#endif + + LabelDsymbol(Identifier *ident); + LabelDsymbol *isLabel(); +}; + +struct AsmStatement : Statement +{ + Token *tokens; + code *asmcode; + unsigned asmalign; // alignment of this statement + unsigned regs; // mask of registers modified (must match regm_t in back end) + unsigned char refparam; // !=0 if function parameter is referenced + unsigned char naked; // !=0 if function is to be naked + + AsmStatement(Loc loc, Token *tokens); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); + int comeFrom(); + Expression *interpret(InterState *istate); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + //int inlineCost(InlineCostState *ics); + //Expression *doInline(InlineDoState *ids); + //Statement *inlineScan(InlineScanState *iss); + + void toIR(IRState *irs); +}; + +struct ImportStatement : Statement +{ + Dsymbols *imports; // Array of Import's + + ImportStatement(Loc loc, Dsymbols *imports); + Statement *syntaxCopy(); + Statement *semantic(Scope *sc); + int blockExit(bool mustNotThrow); + int isEmpty(); + Expression *interpret(InterState *istate); + + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + int inlineCost(InlineCostState *ics); + Expression *doInline(InlineDoState *ids); + Statement *doInlineStatement(InlineDoState *ids); + + void toIR(IRState *irs); +}; + +#endif /* DMD_STATEMENT_H */ diff --git a/staticassert.c b/staticassert.c new file mode 100644 index 00000000..4d8bfa42 --- /dev/null +++ b/staticassert.c @@ -0,0 +1,126 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// http://www.dsource.org/projects/dmd/browser/trunk/src/staticassert.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include + +#include "dsymbol.h" +#include "staticassert.h" +#include "expression.h" +#include "id.h" +#include "hdrgen.h" +#include "scope.h" +#include "template.h" +#include "declaration.h" + + +/********************************* AttribDeclaration ****************************/ + +StaticAssert::StaticAssert(Loc loc, Expression *exp, Expression *msg) + : Dsymbol(Id::empty) +{ + this->loc = loc; + this->exp = exp; + this->msg = msg; +} + +Dsymbol *StaticAssert::syntaxCopy(Dsymbol *s) +{ + StaticAssert *sa; + + assert(!s); + sa = new StaticAssert(loc, exp->syntaxCopy(), msg ? msg->syntaxCopy() : NULL); + return sa; +} + +int StaticAssert::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + return 0; // we didn't add anything +} + +void StaticAssert::semantic(Scope *sc) +{ +} + +void StaticAssert::semantic2(Scope *sc) +{ + //printf("StaticAssert::semantic2() %s\n", toChars()); + ScopeDsymbol *sd = new ScopeDsymbol(); + sc = sc->push(sd); + sc->flags |= SCOPEstaticassert; + Expression *e = exp->semantic(sc); + sc = sc->pop(); + if (e->type == Type::terror) + return; + unsigned olderrs = global.errors; + e = e->optimize(WANTvalue | WANTinterpret); + if (global.errors != olderrs) + { + errorSupplemental(loc, "while evaluating: static assert(%s)", exp->toChars()); + } + else if (e->isBool(FALSE)) + { + if (msg) + { HdrGenState hgs; + OutBuffer buf; + + msg = msg->semantic(sc); + msg = msg->optimize(WANTvalue | WANTinterpret); + hgs.console = 1; + msg->toCBuffer(&buf, &hgs); + error("%s", buf.toChars()); + } + else + error("(%s) is false", exp->toChars()); + if (sc->tinst) + sc->tinst->printInstantiationTrace(); + if (!global.gag) + fatal(); + } + else if (!e->isBool(TRUE)) + { + error("(%s) is not evaluatable at compile time", exp->toChars()); + } +} + +int StaticAssert::oneMember(Dsymbol **ps, Identifier *ident) +{ + //printf("StaticAssert::oneMember())\n"); + *ps = NULL; + return TRUE; +} + +void StaticAssert::inlineScan() +{ +} + +void StaticAssert::toObjFile(int multiobj) +{ +} + +const char *StaticAssert::kind() +{ + return "static assert"; +} + +void StaticAssert::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(kind()); + buf->writeByte('('); + exp->toCBuffer(buf, hgs); + if (msg) + { + buf->writeByte(','); + msg->toCBuffer(buf, hgs); + } + buf->writestring(");"); + buf->writenl(); +} diff --git a/staticassert.h b/staticassert.h new file mode 100644 index 00000000..8d64416c --- /dev/null +++ b/staticassert.h @@ -0,0 +1,41 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_STATICASSERT_H +#define DMD_STATICASSERT_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "dsymbol.h" + +struct Expression; +struct HdrGenState; + +struct StaticAssert : Dsymbol +{ + Expression *exp; + Expression *msg; + + StaticAssert(Loc loc, Expression *exp, Expression *msg); + + Dsymbol *syntaxCopy(Dsymbol *s); + int addMember(Scope *sc, ScopeDsymbol *sd, int memnum); + void semantic(Scope *sc); + void semantic2(Scope *sc); + void inlineScan(); + int oneMember(Dsymbol **ps, Identifier *ident); + void toObjFile(int multiobj); + const char *kind(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; + +#endif diff --git a/struct.c b/struct.c new file mode 100644 index 00000000..3a5bb4ea --- /dev/null +++ b/struct.c @@ -0,0 +1,717 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "aggregate.h" +#include "scope.h" +#include "mtype.h" +#include "declaration.h" +#include "module.h" +#include "id.h" +#include "statement.h" +#include "template.h" + +FuncDeclaration *StructDeclaration::xerreq; // object.xopEquals + +/********************************* AggregateDeclaration ****************************/ + +AggregateDeclaration::AggregateDeclaration(Loc loc, Identifier *id) + : ScopeDsymbol(id) +{ + this->loc = loc; + + storage_class = 0; + protection = PROTpublic; + type = NULL; + handle = NULL; + structsize = 0; // size of struct + alignsize = 0; // size of struct for alignment purposes + structalign = 0; // struct member alignment in effect + hasUnions = 0; + sizeok = 0; // size not determined yet + deferred = NULL; + isdeprecated = false; + inv = NULL; + aggNew = NULL; + aggDelete = NULL; + + stag = NULL; + sinit = NULL; + isnested = 0; + vthis = NULL; + +#if DMDV2 + ctor = NULL; + defaultCtor = NULL; + aliasthis = NULL; + noDefaultCtor = FALSE; +#endif + dtor = NULL; +} + +enum PROT AggregateDeclaration::prot() +{ + return protection; +} + +void AggregateDeclaration::semantic2(Scope *sc) +{ + //printf("AggregateDeclaration::semantic2(%s)\n", toChars()); + if (scope && members) + { error("has forward references"); + return; + } + if (members) + { + sc = sc->push(this); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic2(sc); + } + sc->pop(); + } +} + +void AggregateDeclaration::semantic3(Scope *sc) +{ + //printf("AggregateDeclaration::semantic3(%s)\n", toChars()); + if (members) + { + sc = sc->push(this); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic3(sc); + } + sc->pop(); + } +} + +void AggregateDeclaration::inlineScan() +{ + //printf("AggregateDeclaration::inlineScan(%s)\n", toChars()); + if (members) + { + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + //printf("inline scan aggregate symbol '%s'\n", s->toChars()); + s->inlineScan(); + } + } +} + +unsigned AggregateDeclaration::size(Loc loc) +{ + //printf("AggregateDeclaration::size() %s, scope = %p\n", toChars(), scope); + if (!members) + error(loc, "unknown size"); + if (sizeok != 1 && scope) + semantic(NULL); + if (sizeok != 1) + { error(loc, "no size yet for forward reference"); + //*(char*)0=0; + } + return structsize; +} + +Type *AggregateDeclaration::getType() +{ + return type; +} + +int AggregateDeclaration::isDeprecated() +{ + return isdeprecated; +} + +int AggregateDeclaration::isExport() +{ + return protection == PROTexport; +} + +/**************************** + * Do byte or word alignment as necessary. + * Align sizes of 0, as we may not know array sizes yet. + */ + +void AggregateDeclaration::alignmember( + unsigned salign, // struct alignment that is in effect + unsigned size, // alignment requirement of field + unsigned *poffset) +{ + //printf("salign = %d, size = %d, offset = %d\n",salign,size,offset); + if (salign > 1) + { + assert(size != 3); + unsigned sa = size; + if (sa == 0 || salign < sa) + sa = salign; + *poffset = (*poffset + sa - 1) & ~(sa - 1); + } + //printf("result = %d\n",offset); +} + + +void AggregateDeclaration::addField(Scope *sc, VarDeclaration *v) +{ + unsigned memsize; // size of member + unsigned memalignsize; // size of member for alignment purposes + unsigned xalign; // alignment boundaries + + //printf("AggregateDeclaration::addField('%s') %s\n", v->toChars(), toChars()); + assert(!(v->storage_class & (STCstatic | STCextern | STCparameter | STCtls))); + + // Check for forward referenced types which will fail the size() call + Type *t = v->type->toBasetype(); + if (v->storage_class & STCref) + { // References are the size of a pointer + t = Type::tvoidptr; + } + if (t->ty == Tstruct /*&& isStructDeclaration()*/) + { TypeStruct *ts = (TypeStruct *)t; +#if DMDV2 + if (ts->sym == this) + { + error("cannot have field %s with same struct type", v->toChars()); + } +#endif + + if (ts->sym->sizeok != 1 && ts->sym->scope) + ts->sym->semantic(NULL); + if (ts->sym->sizeok != 1) + { + sizeok = 2; // cannot finish; flag as forward referenced + return; + } + } + if (t->ty == Tident) + { + sizeok = 2; // cannot finish; flag as forward referenced + return; + } + + memsize = t->size(loc); + memalignsize = t->alignsize(); + xalign = t->memalign(sc->structalign); +#if 0 + alignmember(xalign, memalignsize, &sc->offset); + v->offset = sc->offset; + sc->offset += memsize; + if (sc->offset > structsize) + structsize = sc->offset; +#else + unsigned ofs = sc->offset; + alignmember(xalign, memalignsize, &ofs); + v->offset = ofs; + ofs += memsize; + if (ofs > structsize) + structsize = ofs; + if (!isUnionDeclaration()) + sc->offset = ofs; +#endif + if (global.params.is64bit && sc->structalign == 8 && memalignsize == 16) + /* Not sure how to handle this */ + ; + else if (sc->structalign < memalignsize) + memalignsize = sc->structalign; + if (alignsize < memalignsize) + alignsize = memalignsize; + //printf("\t%s: alignsize = %d\n", toChars(), alignsize); + + v->storage_class |= STCfield; + //printf(" addField '%s' to '%s' at offset %d, size = %d\n", v->toChars(), toChars(), v->offset, memsize); + fields.push(v); +} + + +/**************************************** + * Returns !=0 if there's an extra member which is the 'this' + * pointer to the enclosing context (enclosing aggregate or function) + */ + +int AggregateDeclaration::isNested() +{ + return isnested; +} + +/**************************************** + * If field[indx] is not part of a union, return indx. + * Otherwise, return the lowest field index of the union. + */ +int AggregateDeclaration::firstFieldInUnion(int indx) +{ + if (isUnionDeclaration()) + return 0; + VarDeclaration * vd = fields.tdata()[indx]; + int firstNonZero = indx; // first index in the union with non-zero size + for (; ;) + { + if (indx == 0) + return firstNonZero; + VarDeclaration * v = fields.tdata()[indx - 1]; + if (v->offset != vd->offset) + return firstNonZero; + --indx; + /* If it is a zero-length field, it's ambiguous: we don't know if it is + * in the union unless we find an earlier non-zero sized field with the + * same offset. + */ + if (v->size(loc) != 0) + firstNonZero = indx; + } +} + +/**************************************** + * Count the number of fields starting at firstIndex which are part of the + * same union as field[firstIndex]. If not a union, return 1. + */ +int AggregateDeclaration::numFieldsInUnion(int firstIndex) +{ + VarDeclaration * vd = fields.tdata()[firstIndex]; + /* If it is a zero-length field, AND we can't find an earlier non-zero + * sized field with the same offset, we assume it's not part of a union. + */ + if (vd->size(loc) == 0 && !isUnionDeclaration() && + firstFieldInUnion(firstIndex) == firstIndex) + return 1; + int count = 1; + for (size_t i = firstIndex+1; i < fields.dim; ++i) + { + VarDeclaration * v = fields.tdata()[i]; + // If offsets are different, they are not in the same union + if (v->offset != vd->offset) + break; + ++count; + } + return count; +} + +/********************************* StructDeclaration ****************************/ + +StructDeclaration::StructDeclaration(Loc loc, Identifier *id) + : AggregateDeclaration(loc, id) +{ + zeroInit = 0; // assume false until we do semantic processing +#if DMDV2 + hasIdentityAssign = 0; + hasIdentityEquals = 0; + cpctor = NULL; + postblit = NULL; + + xeq = NULL; +#endif + + // For forward references + type = new TypeStruct(this); +} + +Dsymbol *StructDeclaration::syntaxCopy(Dsymbol *s) +{ + StructDeclaration *sd; + + if (s) + sd = (StructDeclaration *)s; + else + sd = new StructDeclaration(loc, ident); + ScopeDsymbol::syntaxCopy(sd); + return sd; +} + +void StructDeclaration::semantic(Scope *sc) +{ + Scope *sc2; + + //printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent->toChars(), toChars(), sizeok); + + //static int count; if (++count == 20) halt(); + + assert(type); + if (!members) // if forward reference + return; + + if (symtab) + { if (sizeok == 1 || !scope) + { //printf("already completed\n"); + scope = NULL; + 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; + } + + int errors = global.gaggedErrors; + + unsigned dprogress_save = Module::dprogress; + + parent = sc->parent; + type = type->semantic(loc, sc); +#if STRUCTTHISREF + handle = type; +#else + handle = type->pointerTo(); +#endif + structalign = sc->structalign; + protection = sc->protection; + storage_class |= sc->stc; + if (sc->stc & STCdeprecated) + isdeprecated = true; + assert(!isAnonymous()); + if (sc->stc & STCabstract) + error("structs, unions cannot be abstract"); +#if DMDV2 + if (storage_class & STCimmutable) + type = type->addMod(MODimmutable); + if (storage_class & STCconst) + type = type->addMod(MODconst); + if (storage_class & STCshared) + type = type->addMod(MODshared); +#endif + + if (sizeok == 0) // if not already done the addMember step + { + int hasfunctions = 0; + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + //printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars()); + s->addMember(sc, this, 1); + if (s->isFuncDeclaration()) + hasfunctions = 1; + } + + // If nested struct, add in hidden 'this' pointer to outer scope + if (hasfunctions && !(storage_class & STCstatic)) + { Dsymbol *s = toParent2(); + if (s) + { + AggregateDeclaration *ad = s->isAggregateDeclaration(); + FuncDeclaration *fd = s->isFuncDeclaration(); + + TemplateInstance *ti; + if (ad && (ti = ad->parent->isTemplateInstance()) != NULL && ti->isnested || fd) + { isnested = 1; + Type *t; + if (ad) + t = ad->handle; + else if (fd) + { AggregateDeclaration *ad = fd->isMember2(); + if (ad) + t = ad->handle; + else + t = Type::tvoidptr; + } + else + assert(0); + if (t->ty == Tstruct) + t = Type::tvoidptr; // t should not be a ref type + assert(!vthis); + vthis = new ThisDeclaration(loc, t); + //vthis->storage_class |= STCref; + members->push(vthis); + } + } + } + } + + sizeok = 0; + sc2 = sc->push(this); + sc2->stc &= STCsafe | STCtrusted | STCsystem; + sc2->parent = this; + if (isUnionDeclaration()) + sc2->inunion = 1; + sc2->protection = PROTpublic; + sc2->explicitProtection = 0; + + size_t members_dim = members->dim; + + /* 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)) + { + //printf("setScope %s %s\n", s->kind(), s->toChars()); + s->setScope(sc2); + } + } + + for (size_t i = 0; i < members_dim; i++) + { + Dsymbol *s = (*members)[i]; + + /* If this is the last member, see if we can finish setting the size. + * This could be much better - finish setting the size after the last + * field was processed. The problem is the chicken-and-egg determination + * of when that is. See Bugzilla 7426 for more info. + */ + if (i + 1 == members_dim) + { + if (sizeok == 0 && s->isAliasDeclaration()) + finalizeSize(); + } + s->semantic(sc2); + } + + 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; + + scope = scx ? scx : new Scope(*sc); + scope->setNoFree(); + scope->module->addDeferredSemantic(this); + + Module::dprogress = dprogress_save; + //printf("\tdeferring %s\n", toChars()); + return; + } + + finalizeSize(); + Module::dprogress++; + + //printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars()); + + // Determine if struct is all zeros or not + zeroInit = 1; + for (size_t i = 0; i < fields.dim; i++) + { + Dsymbol *s = fields.tdata()[i]; + VarDeclaration *vd = s->isVarDeclaration(); + if (vd && !vd->isDataseg()) + { + if (vd->init) + { + // Should examine init to see if it is really all 0's + zeroInit = 0; + break; + } + else + { + if (!vd->type->isZeroInit(loc)) + { + zeroInit = 0; + break; + } + } + } + } + +#if DMDV1 + /* This doesn't work for DMDV2 because (ref S) and (S) parameter + * lists will overload the same. + */ + /* The TypeInfo_Struct is expecting an opEquals and opCmp with + * a parameter that is a pointer to the struct. But if there + * isn't one, but is an opEquals or opCmp with a value, write + * another that is a shell around the value: + * int opCmp(struct *p) { return opCmp(*p); } + */ + + TypeFunction *tfeqptr; + { + Parameters *arguments = new Parameters; + Parameter *arg = new Parameter(STCin, handle, Id::p, NULL); + + arguments->push(arg); + tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd); + tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc); + } + + TypeFunction *tfeq; + { + Parameters *arguments = new Parameters; + Parameter *arg = new Parameter(STCin, type, NULL, NULL); + + arguments->push(arg); + tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd); + tfeq = (TypeFunction *)tfeq->semantic(0, sc); + } + + Identifier *id = Id::eq; + for (int i = 0; i < 2; i++) + { + Dsymbol *s = search_function(this, id); + FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL; + if (fdx) + { FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr); + if (!fd) + { fd = fdx->overloadExactMatch(tfeq); + if (fd) + { // Create the thunk, fdptr + FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr); + Expression *e = new IdentifierExp(loc, Id::p); + e = new PtrExp(loc, e); + Expressions *args = new Expressions(); + args->push(e); + e = new IdentifierExp(loc, id); + e = new CallExp(loc, e, args); + fdptr->fbody = new ReturnStatement(loc, e); + ScopeDsymbol *s = fdx->parent->isScopeDsymbol(); + assert(s); + s->members->push(fdptr); + fdptr->addMember(sc, s, 1); + fdptr->semantic(sc2); + } + } + } + + id = Id::cmp; + } +#endif +#if DMDV2 + dtor = buildDtor(sc2); + postblit = buildPostBlit(sc2); + cpctor = buildCpCtor(sc2); + + buildOpAssign(sc2); + hasIdentityEquals = (buildOpEquals(sc2) != NULL); + + xeq = buildXopEquals(sc2); +#endif + + sc2->pop(); + + /* Look for special member functions. + */ +#if DMDV2 + ctor = search(0, Id::ctor, 0); +#endif + inv = (InvariantDeclaration *)search(0, Id::classInvariant, 0); + aggNew = (NewDeclaration *)search(0, Id::classNew, 0); + aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0); + + if (sc->func) + { + semantic2(sc); + semantic3(sc); + } + + if (global.gag && global.gaggedErrors != errors) + { // The type is no good, yet the error messages were gagged. + type = Type::terror; + } + + if (deferred && !global.gag) + { + deferred->semantic2(sc); + deferred->semantic3(sc); + } +} + +Dsymbol *StructDeclaration::search(Loc loc, Identifier *ident, int flags) +{ + //printf("%s.StructDeclaration::search('%s')\n", toChars(), ident->toChars()); + + if (scope && !symtab) + semantic(scope); + + if (!members || !symtab) + { + error("is forward referenced when looking for '%s'", ident->toChars()); + return NULL; + } + + return ScopeDsymbol::search(loc, ident, flags); +} + +void StructDeclaration::finalizeSize() +{ + // 0 sized struct's are set to 1 byte + if (structsize == 0) + { + structsize = 1; + alignsize = 1; + } + + // Round struct size up to next alignsize boundary. + // This will ensure that arrays of structs will get their internals + // aligned properly. + structsize = (structsize + alignsize - 1) & ~(alignsize - 1); + + sizeok = 1; +} + +void StructDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->printf("%s ", kind()); + if (!isAnonymous()) + buf->writestring(toChars()); + if (!members) + { + buf->writeByte(';'); + buf->writenl(); + return; + } + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + + buf->writestring(" "); + s->toCBuffer(buf, hgs); + } + buf->writeByte('}'); + buf->writenl(); +} + + +const char *StructDeclaration::kind() +{ + return "struct"; +} + +/********************************* UnionDeclaration ****************************/ + +UnionDeclaration::UnionDeclaration(Loc loc, Identifier *id) + : StructDeclaration(loc, id) +{ + hasUnions = 1; +} + +Dsymbol *UnionDeclaration::syntaxCopy(Dsymbol *s) +{ + UnionDeclaration *ud; + + if (s) + ud = (UnionDeclaration *)s; + else + ud = new UnionDeclaration(loc, ident); + StructDeclaration::syntaxCopy(ud); + return ud; +} + + +const char *UnionDeclaration::kind() +{ + return "union"; +} + + diff --git a/template.c b/template.c new file mode 100644 index 00000000..9b0d3115 --- /dev/null +++ b/template.c @@ -0,0 +1,6189 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Handle template implementation + +#include +#include + +#include "root.h" +#include "aav.h" +#include "rmem.h" +#include "stringtable.h" + +#include "mtype.h" +#include "template.h" +#include "init.h" +#include "expression.h" +#include "scope.h" +#include "module.h" +#include "aggregate.h" +#include "declaration.h" +#include "dsymbol.h" +#include "mars.h" +#include "dsymbol.h" +#include "identifier.h" +#include "hdrgen.h" +#include "id.h" + +#if WINDOWS_SEH +#include +long __cdecl __ehfilter(LPEXCEPTION_POINTERS ep); +#endif + +#define LOG 0 + +/******************************************** + * These functions substitute for dynamic_cast. dynamic_cast does not work + * on earlier versions of gcc. + */ + +Expression *isExpression(Object *o) +{ + //return dynamic_cast(o); + if (!o || o->dyncast() != DYNCAST_EXPRESSION) + return NULL; + return (Expression *)o; +} + +Dsymbol *isDsymbol(Object *o) +{ + //return dynamic_cast(o); + if (!o || o->dyncast() != DYNCAST_DSYMBOL) + return NULL; + return (Dsymbol *)o; +} + +Type *isType(Object *o) +{ + //return dynamic_cast(o); + if (!o || o->dyncast() != DYNCAST_TYPE) + return NULL; + return (Type *)o; +} + +Tuple *isTuple(Object *o) +{ + //return dynamic_cast(o); + if (!o || o->dyncast() != DYNCAST_TUPLE) + return NULL; + return (Tuple *)o; +} + +/************************************** + * Is this Object an error? + */ +int isError(Object *o) +{ + Type *t = isType(o); + if (t) + return (t->ty == Terror); + Expression *e = isExpression(o); + if (e) + return (e->op == TOKerror); + Tuple *v = isTuple(o); + if (v) + return arrayObjectIsError(&v->objects); + return 0; +} + +/************************************** + * Are any of the Objects an error? + */ +int arrayObjectIsError(Objects *args) +{ + for (size_t i = 0; i < args->dim; i++) + { + Object *o = args->tdata()[i]; + if (isError(o)) + return 1; + } + return 0; +} + +/*********************** + * Try to get arg as a type. + */ + +Type *getType(Object *o) +{ + Type *t = isType(o); + if (!t) + { Expression *e = isExpression(o); + if (e) + t = e->type; + } + return t; +} + +Dsymbol *getDsymbol(Object *oarg) +{ + Dsymbol *sa; + Expression *ea = isExpression(oarg); + if (ea) + { // Try to convert Expression to symbol + if (ea->op == TOKvar) + sa = ((VarExp *)ea)->var; + else if (ea->op == TOKfunction) + sa = ((FuncExp *)ea)->fd; + else + sa = NULL; + } + else + { // Try to convert Type to symbol + Type *ta = isType(oarg); + if (ta) + sa = ta->toDsymbol(NULL); + else + sa = isDsymbol(oarg); // if already a symbol + } + return sa; +} + +/****************************** + * If o1 matches o2, return 1. + * Else, return 0. + */ + +int match(Object *o1, Object *o2, TemplateDeclaration *tempdecl, Scope *sc) +{ + Type *t1 = isType(o1); + Type *t2 = isType(o2); + Expression *e1 = isExpression(o1); + Expression *e2 = isExpression(o2); + Dsymbol *s1 = isDsymbol(o1); + Dsymbol *s2 = isDsymbol(o2); + Tuple *u1 = isTuple(o1); + Tuple *u2 = isTuple(o2); + + //printf("\t match t1 %p t2 %p, e1 %p e2 %p, s1 %p s2 %p, u1 %p u2 %p\n", t1,t2,e1,e2,s1,s2,u1,u2); + + /* A proper implementation of the various equals() overrides + * should make it possible to just do o1->equals(o2), but + * we'll do that another day. + */ + + if (s1) + { + VarDeclaration *v1 = s1->isVarDeclaration(); + if (v1 && v1->storage_class & STCmanifest) + { ExpInitializer *ei1 = v1->init->isExpInitializer(); + if (ei1) + e1 = ei1->exp, s1 = NULL; + } + } + if (s2) + { + VarDeclaration *v2 = s2->isVarDeclaration(); + if (v2 && v2->storage_class & STCmanifest) + { ExpInitializer *ei2 = v2->init->isExpInitializer(); + if (ei2) + e2 = ei2->exp, s2 = NULL; + } + } + + if (t1) + { + /* if t1 is an instance of ti, then give error + * about recursive expansions. + */ + Dsymbol *s = t1->toDsymbol(sc); + if (s && s->parent) + { TemplateInstance *ti1 = s->parent->isTemplateInstance(); + if (ti1 && ti1->tempdecl == tempdecl) + { + for (Scope *sc1 = sc; sc1; sc1 = sc1->enclosing) + { + if (sc1->scopesym == ti1) + { + error("recursive template expansion for template argument %s", t1->toChars()); + return 1; // fake a match + } + } + } + } + + //printf("t1 = %s\n", t1->toChars()); + //printf("t2 = %s\n", t2->toChars()); + if (!t2 || !t1->equals(t2)) + goto Lnomatch; + } + else if (e1) + { +#if 0 + if (e1 && e2) + { + printf("match %d\n", e1->equals(e2)); + e1->print(); + e2->print(); + e1->type->print(); + e2->type->print(); + } +#endif + if (!e2) + goto Lnomatch; + if (!e1->equals(e2)) + goto Lnomatch; + } + else if (s1) + { + if (!s2 || !s1->equals(s2) || s1->parent != s2->parent) + goto Lnomatch; + } + else if (u1) + { + if (!u2) + goto Lnomatch; + if (u1->objects.dim != u2->objects.dim) + goto Lnomatch; + for (size_t i = 0; i < u1->objects.dim; i++) + { + if (!match(u1->objects.tdata()[i], + u2->objects.tdata()[i], + tempdecl, sc)) + goto Lnomatch; + } + } + //printf("match\n"); + return 1; // match + +Lnomatch: + //printf("nomatch\n"); + return 0; // nomatch; +} + + +/************************************ + * Match an array of them. + */ +int arrayObjectMatch(Objects *oa1, Objects *oa2, TemplateDeclaration *tempdecl, Scope *sc) +{ + if (oa1 == oa2) + return 1; + if (oa1->dim != oa2->dim) + return 0; + for (size_t j = 0; j < oa1->dim; j++) + { Object *o1 = oa1->tdata()[j]; + Object *o2 = oa2->tdata()[j]; + if (!match(o1, o2, tempdecl, sc)) + { + return 0; + } + } + return 1; +} + +/**************************************** + * This makes a 'pretty' version of the template arguments. + * It's analogous to genIdent() which makes a mangled version. + */ + +void ObjectToCBuffer(OutBuffer *buf, HdrGenState *hgs, Object *oarg) +{ + //printf("ObjectToCBuffer()\n"); + Type *t = isType(oarg); + Expression *e = isExpression(oarg); + Dsymbol *s = isDsymbol(oarg); + Tuple *v = isTuple(oarg); + /* The logic of this should match what genIdent() does. The _dynamic_cast() + * function relies on all the pretty strings to be unique for different classes + * (see Bugzilla 7375). + * Perhaps it would be better to demangle what genIdent() does. + */ + if (t) + { //printf("\tt: %s ty = %d\n", t->toChars(), t->ty); + t->toCBuffer(buf, NULL, hgs); + } + else if (e) + { + if (e->op == TOKvar) + e = e->optimize(WANTvalue); // added to fix Bugzilla 7375 + e->toCBuffer(buf, hgs); + } + else if (s) + { + char *p = s->ident ? s->ident->toChars() : s->toChars(); + buf->writestring(p); + } + else if (v) + { + Objects *args = &v->objects; + for (size_t i = 0; i < args->dim; i++) + { + if (i) + buf->writeByte(','); + Object *o = (*args)[i]; + ObjectToCBuffer(buf, hgs, o); + } + } + else if (!oarg) + { + buf->writestring("NULL"); + } + else + { +#ifdef DEBUG + printf("bad Object = %p\n", oarg); +#endif + assert(0); + } +} + +#if DMDV2 +Object *objectSyntaxCopy(Object *o) +{ + if (!o) + return NULL; + Type *t = isType(o); + if (t) + return t->syntaxCopy(); + Expression *e = isExpression(o); + if (e) + return e->syntaxCopy(); + return o; +} +#endif + + +/* ======================== TemplateDeclaration ============================= */ + +TemplateDeclaration::TemplateDeclaration(Loc loc, Identifier *id, + TemplateParameters *parameters, Expression *constraint, Dsymbols *decldefs, int ismixin) + : ScopeDsymbol(id) +{ +#if LOG + printf("TemplateDeclaration(this = %p, id = '%s')\n", this, id->toChars()); +#endif +#if 0 + if (parameters) + for (int i = 0; i < parameters->dim; i++) + { TemplateParameter *tp = parameters->tdata()[i]; + //printf("\tparameter[%d] = %p\n", i, tp); + TemplateTypeParameter *ttp = tp->isTemplateTypeParameter(); + + if (ttp) + { + printf("\tparameter[%d] = %s : %s\n", i, tp->ident->toChars(), ttp->specType ? ttp->specType->toChars() : ""); + } + } +#endif + this->loc = loc; + this->parameters = parameters; + this->origParameters = parameters; + this->constraint = constraint; + this->members = decldefs; + this->overnext = NULL; + this->overroot = NULL; + this->semanticRun = 0; + this->onemember = NULL; + this->literal = 0; + this->ismixin = ismixin; + this->previous = NULL; + + // Compute in advance for Ddoc's use + if (members) + { + Dsymbol *s; + if (Dsymbol::oneMembers(members, &s, ident) && s) + { + onemember = s; + s->parent = this; + } + } +} + +Dsymbol *TemplateDeclaration::syntaxCopy(Dsymbol *) +{ + //printf("TemplateDeclaration::syntaxCopy()\n"); + TemplateDeclaration *td; + TemplateParameters *p; + + p = NULL; + if (parameters) + { + p = new TemplateParameters(); + p->setDim(parameters->dim); + for (size_t i = 0; i < p->dim; i++) + { TemplateParameter *tp = (*parameters)[i]; + p->tdata()[i] = tp->syntaxCopy(); + } + } + Expression *e = NULL; + if (constraint) + e = constraint->syntaxCopy(); + Dsymbols *d = Dsymbol::arraySyntaxCopy(members); + td = new TemplateDeclaration(loc, ident, p, e, d, ismixin); + return td; +} + +void TemplateDeclaration::semantic(Scope *sc) +{ +#if LOG + printf("TemplateDeclaration::semantic(this = %p, id = '%s')\n", this, ident->toChars()); + printf("sc->stc = %llx\n", sc->stc); + printf("sc->module = %s\n", sc->module->toChars()); +#endif + if (semanticRun) + return; // semantic() already run + semanticRun = 1; + + if (sc->module && sc->module->ident == Id::object && ident == Id::AssociativeArray) + { Type::associativearray = this; + } + + if (sc->func) + { +#if DMDV1 + error("cannot declare template at function scope %s", sc->func->toChars()); +#endif + } + + if (/*global.params.useArrayBounds &&*/ sc->module) + { + // Generate this function as it may be used + // when template is instantiated in other modules + sc->module->toModuleArray(); + } + + if (/*global.params.useAssert &&*/ sc->module) + { + // Generate this function as it may be used + // when template is instantiated in other modules + sc->module->toModuleAssert(); + } + +#if DMDV2 + if (/*global.params.useUnitTests &&*/ sc->module) + { + // Generate this function as it may be used + // when template is instantiated in other modules + sc->module->toModuleUnittest(); + } +#endif + + /* Remember Scope for later instantiations, but make + * a copy since attributes can change. + */ + this->scope = new Scope(*sc); + this->scope->setNoFree(); + + // Set up scope for parameters + ScopeDsymbol *paramsym = new ScopeDsymbol(); + paramsym->parent = sc->parent; + Scope *paramscope = sc->push(paramsym); + paramscope->parameterSpecialization = 1; + paramscope->stc = 0; + + if (!parent) + parent = sc->parent; + + if (global.params.doDocComments) + { + origParameters = new TemplateParameters(); + origParameters->setDim(parameters->dim); + for (size_t i = 0; i < parameters->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + origParameters->tdata()[i] = tp->syntaxCopy(); + } + } + + for (size_t i = 0; i < parameters->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + + tp->declareParameter(paramscope); + } + + for (size_t i = 0; i < parameters->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + + tp->semantic(paramscope); + if (i + 1 != parameters->dim && tp->isTemplateTupleParameter()) + error("template tuple parameter must be last one"); + } + + paramscope->pop(); + + // Compute again + onemember = NULL; + if (members) + { + Dsymbol *s; + if (Dsymbol::oneMembers(members, &s, ident) && s) + { + onemember = s; + s->parent = this; + } + } + + /* BUG: should check: + * o no virtual functions or non-static data members of classes + */ +} + +const char *TemplateDeclaration::kind() +{ + return (onemember && onemember->isAggregateDeclaration()) + ? onemember->kind() + : (char *)"template"; +} + +/********************************** + * Overload existing TemplateDeclaration 'this' with the new one 's'. + * Return !=0 if successful; i.e. no conflict. + */ + +int TemplateDeclaration::overloadInsert(Dsymbol *s) +{ + TemplateDeclaration **pf; + TemplateDeclaration *f; + +#if LOG + printf("TemplateDeclaration::overloadInsert('%s')\n", s->toChars()); +#endif + f = s->isTemplateDeclaration(); + if (!f) + return FALSE; + TemplateDeclaration *pthis = this; + for (pf = &pthis; *pf; pf = &(*pf)->overnext) + { +#if 0 + // Conflict if TemplateParameter's match + // Will get caught anyway later with TemplateInstance, but + // should check it now. + TemplateDeclaration *f2 = *pf; + + if (f->parameters->dim != f2->parameters->dim) + goto Lcontinue; + + for (size_t i = 0; i < f->parameters->dim; i++) + { TemplateParameter *p1 = f->parameters->tdata()[i]; + TemplateParameter *p2 = f2->parameters->tdata()[i]; + + if (!p1->overloadMatch(p2)) + goto Lcontinue; + } + +#if LOG + printf("\tfalse: conflict\n"); +#endif + return FALSE; + + Lcontinue: + ; +#endif + } + + f->overroot = this; + *pf = f; +#if LOG + printf("\ttrue: no conflict\n"); +#endif + return TRUE; +} + +/**************************** + * Declare all the function parameters as variables + * and add them to the scope + */ +void TemplateDeclaration::makeParamNamesVisibleInConstraint(Scope *paramscope, Expressions *fargs) +{ + /* We do this ONLY if there is only one function in the template. + */ + FuncDeclaration *fd = onemember && onemember->toAlias() ? + onemember->toAlias()->isFuncDeclaration() : NULL; + if (fd) + { + /* + Making parameters is similar to FuncDeclaration::semantic3 + */ + paramscope->parent = fd; + + TypeFunction *tf = (TypeFunction *)fd->type->syntaxCopy(); + + // Shouldn't run semantic on default arguments and return type. + for (int i = 0; iparameters->dim; i++) + tf->parameters->tdata()[i]->defaultArg = NULL; + tf->next = NULL; + + // Resolve parameter types and 'auto ref's. + tf->fargs = fargs; + tf = (TypeFunction *)tf->semantic(loc, paramscope); + + Parameters *fparameters = tf->parameters; + int fvarargs = tf->varargs; + + size_t nfparams = Parameter::dim(fparameters); // Num function parameters + for (size_t i = 0; i < nfparams; i++) + { + Parameter *fparam = Parameter::getNth(fparameters, i); + // Remove addMod same as func.d L1065 of FuncDeclaration::semantic3 + //Type *vtype = fparam->type; + //if (fd->type && fd->isPure()) + // vtype = vtype->addMod(MODconst); + fparam->storageClass &= (STCin | STCout | STCref | STClazy | STCfinal | STC_TYPECTOR | STCnodtor); + fparam->storageClass |= STCparameter; + if (fvarargs == 2 && i + 1 == nfparams) + fparam->storageClass |= STCvariadic; + } + for (size_t i = 0; i < fparameters->dim; i++) + { + Parameter *fparam = fparameters->tdata()[i]; + if (!fparam->ident) + continue; // don't add it, if it has no name + VarDeclaration *v = new VarDeclaration(loc, fparam->type, fparam->ident, NULL); + v->storage_class = fparam->storageClass; + v->semantic(paramscope); + if (!paramscope->insert(v)) + error("parameter %s.%s is already defined", toChars(), v->toChars()); + else + v->parent = this; + } + } +} + +/*************************************** + * Given that ti is an instance of this TemplateDeclaration, + * deduce the types of the parameters to this, and store + * those deduced types in dedtypes[]. + * Input: + * flag 1: don't do semantic() because of dummy types + * 2: don't change types in matchArg() + * Output: + * dedtypes deduced arguments + * Return match level. + */ + +MATCH TemplateDeclaration::matchWithInstance(TemplateInstance *ti, + Objects *dedtypes, Expressions *fargs, int flag) +{ MATCH m; + size_t dedtypes_dim = dedtypes->dim; + +#define LOGM 0 +#if LOGM + printf("\n+TemplateDeclaration::matchWithInstance(this = %s, ti = %s, flag = %d)\n", toChars(), ti->toChars(), flag); +#endif + +#if 0 + printf("dedtypes->dim = %d, parameters->dim = %d\n", dedtypes_dim, parameters->dim); + if (ti->tiargs->dim) + printf("ti->tiargs->dim = %d, [0] = %p\n", + ti->tiargs->dim, + ti->tiargs->tdata()[0]); +#endif + dedtypes->zero(); + + size_t parameters_dim = parameters->dim; + int variadic = isVariadic() != NULL; + + // If more arguments than parameters, no match + if (ti->tiargs->dim > parameters_dim && !variadic) + { +#if LOGM + printf(" no match: more arguments than parameters\n"); +#endif + return MATCHnomatch; + } + + assert(dedtypes_dim == parameters_dim); + assert(dedtypes_dim >= ti->tiargs->dim || variadic); + + // Set up scope for parameters + assert((size_t)scope > 0x10000); + ScopeDsymbol *paramsym = new ScopeDsymbol(); + paramsym->parent = scope->parent; + Scope *paramscope = scope->push(paramsym); + paramscope->stc = 0; + + // Attempt type deduction + m = MATCHexact; + for (size_t i = 0; i < dedtypes_dim; i++) + { MATCH m2; + TemplateParameter *tp = parameters->tdata()[i]; + Declaration *sparam; + + //printf("\targument [%d]\n", i); +#if LOGM + //printf("\targument [%d] is %s\n", i, oarg ? oarg->toChars() : "null"); + TemplateTypeParameter *ttp = tp->isTemplateTypeParameter(); + if (ttp) + printf("\tparameter[%d] is %s : %s\n", i, tp->ident->toChars(), ttp->specType ? ttp->specType->toChars() : ""); +#endif + + m2 = tp->matchArg(paramscope, ti->tiargs, i, parameters, dedtypes, &sparam); + //printf("\tm2 = %d\n", m2); + + if (m2 == MATCHnomatch) + { +#if 0 + printf("\tmatchArg() for parameter %i failed\n", i); +#endif + goto Lnomatch; + } + + if (m2 < m) + m = m2; + + if (!flag) + sparam->semantic(paramscope); + if (!paramscope->insert(sparam)) + goto Lnomatch; + } + + if (!flag) + { + /* Any parameter left without a type gets the type of + * its corresponding arg + */ + for (size_t i = 0; i < dedtypes_dim; i++) + { + if (!dedtypes->tdata()[i]) + { assert(i < ti->tiargs->dim); + dedtypes->tdata()[i] = (Type *)ti->tiargs->tdata()[i]; + } + } + } + +#if DMDV2 + if (m && constraint && !flag) + { /* Check to see if constraint is satisfied. + */ + makeParamNamesVisibleInConstraint(paramscope, fargs); + Expression *e = constraint->syntaxCopy(); + Scope *sc = paramscope->push(); + + /* There's a chicken-and-egg problem here. We don't know yet if this template + * instantiation will be a local one (isnested is set), and we won't know until + * after selecting the correct template. Thus, function we're nesting inside + * is not on the sc scope chain, and this can cause errors in FuncDeclaration::getLevel(). + * Workaround the problem by setting a flag to relax the checking on frame errors. + */ + sc->flags |= SCOPEstaticif; + + FuncDeclaration *fd = onemember && onemember->toAlias() ? + onemember->toAlias()->isFuncDeclaration() : NULL; + Dsymbol *s = parent; + while (s->isTemplateInstance() || s->isTemplateMixin()) + s = s->parent; + AggregateDeclaration *ad = s->isAggregateDeclaration(); + VarDeclaration *vthissave; + if (fd && ad) + { + vthissave = fd->vthis; + fd->vthis = fd->declareThis(paramscope, ad); + } + + e = e->semantic(sc); + + if (fd && fd->vthis) + fd->vthis = vthissave; + + sc->pop(); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->isBool(TRUE)) + ; + else if (e->isBool(FALSE)) + goto Lnomatch; + else + { + e->error("constraint %s is not constant or does not evaluate to a bool", e->toChars()); + } + } +#endif + +#if LOGM + // Print out the results + printf("--------------------------\n"); + printf("template %s\n", toChars()); + printf("instance %s\n", ti->toChars()); + if (m) + { + for (size_t i = 0; i < dedtypes_dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + Object *oarg; + + printf(" [%d]", i); + + if (i < ti->tiargs->dim) + oarg = ti->tiargs->tdata()[i]; + else + oarg = NULL; + tp->print(oarg, dedtypes->tdata()[i]); + } + } + else + goto Lnomatch; +#endif + +#if LOGM + printf(" match = %d\n", m); +#endif + goto Lret; + +Lnomatch: +#if LOGM + printf(" no match\n"); +#endif + m = MATCHnomatch; + +Lret: + paramscope->pop(); +#if LOGM + printf("-TemplateDeclaration::matchWithInstance(this = %p, ti = %p) = %d\n", this, ti, m); +#endif + return m; +} + +/******************************************** + * Determine partial specialization order of 'this' vs td2. + * Returns: + * match this is at least as specialized as td2 + * 0 td2 is more specialized than this + */ + +MATCH TemplateDeclaration::leastAsSpecialized(TemplateDeclaration *td2, Expressions *fargs) +{ + /* This works by taking the template parameters to this template + * declaration and feeding them to td2 as if it were a template + * instance. + * If it works, then this template is at least as specialized + * as td2. + */ + + TemplateInstance ti(0, ident); // create dummy template instance + Objects dedtypes; + +#define LOG_LEASTAS 0 + +#if LOG_LEASTAS + printf("%s.leastAsSpecialized(%s)\n", toChars(), td2->toChars()); +#endif + + // Set type arguments to dummy template instance to be types + // generated from the parameters to this template declaration + ti.tiargs = new Objects(); + ti.tiargs->setDim(parameters->dim); + for (size_t i = 0; i < ti.tiargs->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + + Object *p = (Object *)tp->dummyArg(); + if (p) + ti.tiargs->tdata()[i] = p; + else + ti.tiargs->setDim(i); + } + + // Temporary Array to hold deduced types + //dedtypes.setDim(parameters->dim); + dedtypes.setDim(td2->parameters->dim); + + // Attempt a type deduction + MATCH m = td2->matchWithInstance(&ti, &dedtypes, fargs, 1); + if (m) + { + /* A non-variadic template is more specialized than a + * variadic one. + */ + if (isVariadic() && !td2->isVariadic()) + goto L1; + +#if LOG_LEASTAS + printf(" matches %d, so is least as specialized\n", m); +#endif + return m; + } + L1: +#if LOG_LEASTAS + printf(" doesn't match, so is not as specialized\n"); +#endif + return MATCHnomatch; +} + + +/************************************************* + * Match function arguments against a specific template function. + * Input: + * loc instantiation location + * targsi Expression/Type initial list of template arguments + * ethis 'this' argument if !NULL + * fargs arguments to function + * Output: + * dedargs Expression/Type deduced template arguments + * Returns: + * match level + */ + +MATCH TemplateDeclaration::deduceFunctionTemplateMatch(Scope *sc, Loc loc, Objects *targsi, + Expression *ethis, Expressions *fargs, + Objects *dedargs) +{ + size_t nfparams; + size_t nfargs; + size_t nargsi; // array size of targsi + int fptupindex = -1; + int tuple_dim = 0; + MATCH match = MATCHexact; + FuncDeclaration *fd = onemember->toAlias()->isFuncDeclaration(); + Parameters *fparameters; // function parameter list + int fvarargs; // function varargs + Objects dedtypes; // for T:T*, the dedargs is the T*, dedtypes is the T + unsigned wildmatch = 0; + + TypeFunction *tf = (TypeFunction *)fd->type; + +#if 0 + printf("\nTemplateDeclaration::deduceFunctionTemplateMatch() %s\n", toChars()); + for (size_t i = 0; i < fargs->dim; i++) + { Expression *e = fargs->tdata()[i]; + printf("\tfarg[%d] is %s, type is %s\n", i, e->toChars(), e->type->toChars()); + } + printf("fd = %s\n", fd->toChars()); + printf("fd->type = %s\n", fd->type->toChars()); + if (ethis) + printf("ethis->type = %s\n", ethis->type->toChars()); +#endif + + assert((size_t)scope > 0x10000); + + dedargs->setDim(parameters->dim); + dedargs->zero(); + + dedtypes.setDim(parameters->dim); + dedtypes.zero(); + + // Set up scope for parameters + ScopeDsymbol *paramsym = new ScopeDsymbol(); + paramsym->parent = scope->parent; + Scope *paramscope = scope->push(paramsym); + paramscope->stc = 0; + + TemplateTupleParameter *tp = isVariadic(); + int tp_is_declared = 0; + +#if 0 + for (size_t i = 0; i < dedargs->dim; i++) + { + printf("\tdedarg[%d] = ", i); + Object *oarg = dedargs->tdata()[i]; + if (oarg) printf("%s", oarg->toChars()); + printf("\n"); + } +#endif + + + nargsi = 0; + if (targsi) + { // Set initial template arguments + + nargsi = targsi->dim; + size_t n = parameters->dim; + if (tp) + n--; + if (nargsi > n) + { if (!tp) + goto Lnomatch; + + /* The extra initial template arguments + * now form the tuple argument. + */ + Tuple *t = new Tuple(); + assert(parameters->dim); + dedargs->tdata()[parameters->dim - 1] = t; + + tuple_dim = nargsi - n; + t->objects.setDim(tuple_dim); + for (size_t i = 0; i < tuple_dim; i++) + { + t->objects.tdata()[i] = targsi->tdata()[n + i]; + } + declareParameter(paramscope, tp, t); + tp_is_declared = 1; + } + else + n = nargsi; + + memcpy(dedargs->tdata(), targsi->tdata(), n * sizeof(*dedargs->tdata())); + + for (size_t i = 0; i < n; i++) + { assert(i < parameters->dim); + TemplateParameter *tp = parameters->tdata()[i]; + MATCH m; + Declaration *sparam = NULL; + + m = tp->matchArg(paramscope, dedargs, i, parameters, &dedtypes, &sparam); + //printf("\tdeduceType m = %d\n", m); + if (m == MATCHnomatch) + goto Lnomatch; + if (m < match) + match = m; + + sparam->semantic(paramscope); + if (!paramscope->insert(sparam)) + goto Lnomatch; + } + } +#if 0 + for (size_t i = 0; i < dedargs->dim; i++) + { + printf("\tdedarg[%d] = ", i); + Object *oarg = dedargs->tdata()[i]; + if (oarg) printf("%s", oarg->toChars()); + printf("\n"); + } +#endif + + fparameters = fd->getParameters(&fvarargs); + nfparams = Parameter::dim(fparameters); // number of function parameters + nfargs = fargs ? fargs->dim : 0; // number of function arguments + + /* Check for match of function arguments with variadic template + * parameter, such as: + * + * template Foo(T, A...) { void Foo(T t, A a); } + * void main() { Foo(1,2,3); } + */ + if (tp) // if variadic + { + if (nfparams == 0 && nfargs != 0) // if no function parameters + { + if (tp_is_declared) + goto L2; + Tuple *t = new Tuple(); + //printf("t = %p\n", t); + dedargs->tdata()[parameters->dim - 1] = t; + declareParameter(paramscope, tp, t); + goto L2; + } + else if (nfargs < nfparams - 1) + goto L1; + else + { + /* Figure out which of the function parameters matches + * the tuple template parameter. Do this by matching + * type identifiers. + * Set the index of this function parameter to fptupindex. + */ + for (fptupindex = 0; fptupindex < nfparams; fptupindex++) + { + Parameter *fparam = fparameters->tdata()[fptupindex]; + if (fparam->type->ty != Tident) + continue; + TypeIdentifier *tid = (TypeIdentifier *)fparam->type; + if (!tp->ident->equals(tid->ident) || tid->idents.dim) + continue; + + if (fvarargs) // variadic function doesn't + goto Lnomatch; // go with variadic template + + if (tp_is_declared) + goto L2; + + // Apply function parameter storage classes to parameter type + tid = (TypeIdentifier *)tid->addStorageClass(fparam->storageClass); + + /* The types of the function arguments + * now form the tuple argument. + */ + Tuple *t = new Tuple(); + dedargs->tdata()[parameters->dim - 1] = t; + + tuple_dim = nfargs - (nfparams - 1); + t->objects.setDim(tuple_dim); + for (size_t i = 0; i < tuple_dim; i++) + { Expression *farg = fargs->tdata()[fptupindex + i]; + unsigned mod = farg->type->mod; + Type *tt; + MATCH m; + + #define X(U,T) ((U) << 4) | (T) + if (tid->mod & MODwild) + { + switch (X(tid->mod, mod)) + { + case X(MODwild, MODwild): + case X(MODwild | MODshared, MODwild | MODshared): + case X(MODwild, 0): + case X(MODwild, MODconst): + case X(MODwild, MODimmutable): + case X(MODwild | MODshared, MODshared): + case X(MODwild | MODshared, MODconst | MODshared): + + if (mod & MODwild) + wildmatch |= MODwild; + else if (mod == 0) + wildmatch |= MODmutable; + else + wildmatch |= (mod & ~MODshared); + tt = farg->type->mutableOf(); + m = MATCHconst; + goto Lx; + + default: + break; + } + } + + switch (X(tid->mod, mod)) + { + case X(0, 0): + case X(0, MODconst): + case X(0, MODimmutable): + case X(0, MODshared): + case X(0, MODconst | MODshared): + case X(0, MODwild): + case X(0, MODwild | MODshared): + // foo(U:U) T => T + // foo(U:U) const(T) => const(T) + // foo(U:U) immutable(T) => immutable(T) + // foo(U:U) shared(T) => shared(T) + // foo(U:U) const(shared(T)) => const(shared(T)) + // foo(U:U) wild(T) => wild(T) + // foo(U:U) wild(shared(T)) => wild(shared(T)) + + tt = farg->type; + m = MATCHexact; + break; + + case X(MODconst, MODconst): + case X(MODimmutable, MODimmutable): + case X(MODshared, MODshared): + case X(MODconst | MODshared, MODconst | MODshared): + case X(MODwild, MODwild): + case X(MODwild | MODshared, MODwild | MODshared): + // foo(U:const(U)) const(T) => T + // foo(U:immutable(U)) immutable(T) => T + // foo(U:shared(U)) shared(T) => T + // foo(U:const(shared(U)) const(shared(T)) => T + // foo(U:wild(U)) wild(T) => T + // foo(U:wild(shared(U)) wild(shared(T)) => T + + tt = farg->type->mutableOf()->unSharedOf(); + m = MATCHexact; + break; + + case X(MODconst, 0): + case X(MODconst, MODimmutable): + case X(MODconst, MODconst | MODshared): + case X(MODconst | MODshared, MODimmutable): + case X(MODconst, MODwild): + case X(MODconst, MODwild | MODshared): + // foo(U:const(U)) T => T + // foo(U:const(U)) immutable(T) => T + // foo(U:const(U)) const(shared(T)) => shared(T) + // foo(U:const(shared(U)) immutable(T) => T + // foo(U:const(U)) wild(shared(T)) => shared(T) + + tt = farg->type->mutableOf(); + m = MATCHconst; + break; + + case X(MODshared, MODconst | MODshared): + case X(MODconst | MODshared, MODshared): + case X(MODshared, MODwild | MODshared): + // foo(U:shared(U)) const(shared(T)) => const(T) + // foo(U:const(shared(U)) shared(T) => T + // foo(U:shared(U)) wild(shared(T)) => wild(T) + tt = farg->type->unSharedOf(); + m = MATCHconst; + break; + + case X(MODimmutable, 0): + case X(MODimmutable, MODconst): + case X(MODimmutable, MODshared): + case X(MODimmutable, MODconst | MODshared): + case X(MODconst, MODshared): + case X(MODshared, 0): + case X(MODshared, MODconst): + case X(MODshared, MODimmutable): + case X(MODconst | MODshared, 0): + case X(MODconst | MODshared, MODconst): + case X(MODimmutable, MODwild): + case X(MODshared, MODwild): + case X(MODconst | MODshared, MODwild): + case X(MODwild, 0): + case X(MODwild, MODconst): + case X(MODwild, MODimmutable): + case X(MODwild, MODshared): + case X(MODwild, MODconst | MODshared): + case X(MODwild | MODshared, 0): + case X(MODwild | MODshared, MODconst): + case X(MODwild | MODshared, MODimmutable): + case X(MODwild | MODshared, MODshared): + case X(MODwild | MODshared, MODconst | MODshared): + case X(MODwild | MODshared, MODwild): + case X(MODimmutable, MODwild | MODshared): + case X(MODconst | MODshared, MODwild | MODshared): + case X(MODwild, MODwild | MODshared): + + // foo(U:immutable(U)) T => nomatch + // foo(U:immutable(U)) const(T) => nomatch + // foo(U:immutable(U)) shared(T) => nomatch + // foo(U:immutable(U)) const(shared(T)) => nomatch + // foo(U:const(U)) shared(T) => nomatch + // foo(U:shared(U)) T => nomatch + // foo(U:shared(U)) const(T) => nomatch + // foo(U:shared(U)) immutable(T) => nomatch + // foo(U:const(shared(U)) T => nomatch + // foo(U:const(shared(U)) const(T) => nomatch + // foo(U:immutable(U)) wild(T) => nomatch + // foo(U:shared(U)) wild(T) => nomatch + // foo(U:const(shared(U)) wild(T) => nomatch + // foo(U:wild(U)) T => nomatch + // foo(U:wild(U)) const(T) => nomatch + // foo(U:wild(U)) immutable(T) => nomatch + // foo(U:wild(U)) shared(T) => nomatch + // foo(U:wild(U)) const(shared(T)) => nomatch + // foo(U:wild(shared(U)) T => nomatch + // foo(U:wild(shared(U)) const(T) => nomatch + // foo(U:wild(shared(U)) immutable(T) => nomatch + // foo(U:wild(shared(U)) shared(T) => nomatch + // foo(U:wild(shared(U)) const(shared(T)) => nomatch + // foo(U:wild(shared(U)) wild(T) => nomatch + // foo(U:immutable(U)) wild(shared(T)) => nomatch + // foo(U:const(shared(U))) wild(shared(T)) => nomatch + // foo(U:wild(U)) wild(shared(T)) => nomatch + m = MATCHnomatch; + break; + + default: + assert(0); + } + #undef X + + Lx: + if (m == MATCHnomatch) + goto Lnomatch; + if (m < match) + match = m; + + t->objects.tdata()[i] = tt; + } + declareParameter(paramscope, tp, t); + goto L2; + } + fptupindex = -1; + } + } + +L1: + if (nfparams == nfargs) + ; + else if (nfargs > nfparams) + { + if (fvarargs == 0) + goto Lnomatch; // too many args, no match + match = MATCHconvert; // match ... with a conversion + } + +L2: +#if DMDV2 + if (ethis) + { + // Match 'ethis' to any TemplateThisParameter's + for (size_t i = 0; i < parameters->dim; i++) + { TemplateParameter *tp = parameters->tdata()[i]; + TemplateThisParameter *ttp = tp->isTemplateThisParameter(); + if (ttp) + { MATCH m; + + Type *t = new TypeIdentifier(0, ttp->ident); + m = ethis->type->deduceType(paramscope, t, parameters, &dedtypes); + if (!m) + goto Lnomatch; + if (m < match) + match = m; // pick worst match + } + } + + // Match attributes of ethis against attributes of fd + if (fd->type) + { + Type *tthis = ethis->type; + unsigned mod = fd->type->mod; + StorageClass stc = scope->stc | fd->storage_class2; + // Propagate parent storage class (see bug 5504) + Dsymbol *p = parent; + while (p->isTemplateDeclaration() || p->isTemplateInstance()) + p = p->parent; + AggregateDeclaration *ad = p->isAggregateDeclaration(); + if (ad) + stc |= ad->storage_class; + + if (stc & (STCshared | STCsynchronized)) + mod |= MODshared; + if (stc & STCimmutable) + mod |= MODimmutable; + if (stc & STCconst) + mod |= MODconst; + if (stc & STCwild) + mod |= MODwild; + // Fix mod + if (mod & MODimmutable) + mod = MODimmutable; + if (mod & MODconst) + mod &= ~STCwild; + if (tthis->mod != mod) + { + if (!MODmethodConv(tthis->mod, mod)) + goto Lnomatch; + if (MATCHconst < match) + match = MATCHconst; + } + } + } +#endif + + // Loop through the function parameters + for (size_t parami = 0; parami < nfparams; parami++) + { + /* Skip over function parameters which wound up + * as part of a template tuple parameter. + */ + if (parami == fptupindex) + continue; + /* Set i = index into function arguments + * Function parameters correspond to function arguments as follows. + * Note that tuple_dim may be zero, and there may be default or + * variadic arguments at the end. + * arg [0..fptupindex] == param[0..fptupindex] + * arg [fptupindex..fptupindex+tuple_dim] == param[fptupindex] + * arg[fputupindex+dim.. ] == param[fptupindex+1.. ] + */ + size_t i = parami; + if (fptupindex >= 0 && parami > fptupindex) + i += tuple_dim - 1; + + Parameter *fparam = Parameter::getNth(fparameters, parami); + + if (i >= nfargs) // if not enough arguments + { + if (fparam->defaultArg) + { /* Default arguments do not participate in template argument + * deduction. + */ + goto Lmatch; + } + } + else + { + Expression *farg = fargs->tdata()[i]; +Lretry: +#if 0 + printf("\tfarg->type = %s\n", farg->type->toChars()); + printf("\tfparam->type = %s\n", fparam->type->toChars()); +#endif + Type *argtype = farg->type; + + // Apply function parameter storage classes to parameter types + fparam->type = fparam->type->addStorageClass(fparam->storageClass); + +#if DMDV2 + /* Allow string literals which are type [] to match with [dim] + */ + if (farg->op == TOKstring) + { StringExp *se = (StringExp *)farg; + if (!se->committed && argtype->ty == Tarray && + fparam->type->toBasetype()->ty == Tsarray) + { + argtype = new TypeSArray(argtype->nextOf(), new IntegerExp(se->loc, se->len, Type::tindex)); + argtype = argtype->semantic(se->loc, NULL); + argtype = argtype->invariantOf(); + } + } + + /* Allow implicit function literals to delegate conversion + */ + if (farg->op == TOKfunction) + { FuncExp *fe = (FuncExp *)farg; + Type *tp = fparam->type; + if (tp->ty == Tdelegate && + fe->type->ty == Tpointer && fe->type->nextOf()->ty == Tfunction && + fe->tok == TOKreserved) + { Type *tdg = new TypeDelegate(fe->type->nextOf()); + tdg = tdg->semantic(loc, sc); + farg = fe->inferType(sc, tdg); + } + else if (fe->type == Type::tvoid) + { + farg = fe->inferType(sc, tp); + if (!farg) + goto Lvarargs; + } + argtype = farg->type; + } + + /* Remove top const for dynamic array types and pointer types + */ + if ((argtype->ty == Tarray || argtype->ty == Tpointer) && + !argtype->isMutable() && + (!(fparam->storageClass & STCref) || + (fparam->storageClass & STCauto) && !farg->isLvalue())) + { + argtype = argtype->mutableOf(); + } +#endif + + if (fvarargs == 2 && i + 1 == nfparams && i + 1 < nfargs) + goto Lvarargs; + + MATCH m; + m = argtype->deduceType(paramscope, fparam->type, parameters, &dedtypes, + tf->hasWild() ? &wildmatch : NULL); + //printf("\tdeduceType m = %d\n", m); + //if (tf->hasWild()) + // printf("\twildmatch = x%x m = %d\n", wildmatch, m); + + /* If no match, see if there's a conversion to a delegate + */ + if (!m) + { Type *tbp = fparam->type->toBasetype(); + Type *tba = farg->type->toBasetype(); + AggregateDeclaration *ad; + if (tbp->ty == Tdelegate) + { + TypeDelegate *td = (TypeDelegate *)fparam->type->toBasetype(); + TypeFunction *tf = (TypeFunction *)td->next; + + if (!tf->varargs && Parameter::dim(tf->parameters) == 0) + { + m = farg->type->deduceType(paramscope, tf->next, parameters, &dedtypes); + if (!m && tf->next->toBasetype()->ty == Tvoid) + m = MATCHconvert; + } + //printf("\tm2 = %d\n", m); + } + else if (tba->ty == Tclass) + { + ad = ((TypeClass *)tba)->sym; + goto Lad; + } + else if (tba->ty == Tstruct) + { + ad = ((TypeStruct *)tba)->sym; + Lad: + if (ad->aliasthis) + { /* If a semantic error occurs while doing alias this, + * eg purity(bug 7295), just regard it as not a match. + */ + unsigned olderrors = global.startGagging(); + Expression *e = new DotIdExp(farg->loc, farg, ad->aliasthis->ident); + e = e->semantic(sc); + e = resolveProperties(sc, e); + if (!global.endGagging(olderrors)) + { farg = e; + goto Lretry; + } + } + } + } + + if (m && (fparam->storageClass & (STCref | STCauto)) == STCref) + { if (!farg->isLvalue()) + goto Lnomatch; + } + if (m && (fparam->storageClass & STCout)) + { if (!farg->isLvalue()) + goto Lnomatch; + } + if (!m && (fparam->storageClass & STClazy) && fparam->type->ty == Tvoid && + farg->type->ty != Tvoid) + m = MATCHconvert; + + if (m) + { if (m < match) + match = m; // pick worst match + continue; + } + } + + Lvarargs: + /* The following code for variadic arguments closely + * matches TypeFunction::callMatch() + */ + if (!(fvarargs == 2 && i + 1 == nfparams)) + goto Lnomatch; + + /* Check for match with function parameter T... + */ + Type *tb = fparam->type->toBasetype(); + switch (tb->ty) + { + // Perhaps we can do better with this, see TypeFunction::callMatch() + case Tsarray: + { TypeSArray *tsa = (TypeSArray *)tb; + dinteger_t sz = tsa->dim->toInteger(); + if (sz != nfargs - i) + goto Lnomatch; + } + case Tarray: + { TypeArray *ta = (TypeArray *)tb; + for (; i < nfargs; i++) + { + Expression *arg = fargs->tdata()[i]; + assert(arg); + + if (arg->op == TOKfunction) + { FuncExp *fe = (FuncExp *)arg; + Type *tp = tb->nextOf(); + if (tp->ty == Tdelegate && + fe->type->ty == Tpointer && fe->type->nextOf()->ty == Tfunction && + fe->tok == TOKreserved) + { tp = new TypeDelegate(fe->type->nextOf()); + tp = tp->semantic(loc, sc); + arg = fe->inferType(sc, tp); + } + else if (arg->type == Type::tvoid) + { + arg = fe->inferType(sc, tp); + if (!arg) + goto Lnomatch; + } + } + + MATCH m; + /* If lazy array of delegates, + * convert arg(s) to delegate(s) + */ + Type *tret = fparam->isLazyArray(); + if (tret) + { + if (ta->next->equals(arg->type)) + { m = MATCHexact; + } + else + { + m = arg->implicitConvTo(tret); + if (m == MATCHnomatch) + { + if (tret->toBasetype()->ty == Tvoid) + m = MATCHconvert; + } + } + } + else + { + m = arg->type->deduceType(paramscope, ta->next, parameters, &dedtypes); + //m = arg->implicitConvTo(ta->next); + } + if (m == MATCHnomatch) + goto Lnomatch; + if (m < match) + match = m; + } + goto Lmatch; + } + case Tclass: + case Tident: + goto Lmatch; + + default: + goto Lnomatch; + } + } + +Lmatch: + + for (size_t i = nargsi; i < dedargs->dim; i++) + { + TemplateParameter *tparam = parameters->tdata()[i]; + //printf("tparam[%d] = %s\n", i, tparam->ident->toChars()); + /* For T:T*, the dedargs is the T*, dedtypes is the T + * But for function templates, we really need them to match + */ + Object *oarg = dedargs->tdata()[i]; + Object *oded = dedtypes.tdata()[i]; + //printf("1dedargs[%d] = %p, dedtypes[%d] = %p\n", i, oarg, i, oded); + //if (oarg) printf("oarg: %s\n", oarg->toChars()); + //if (oded) printf("oded: %s\n", oded->toChars()); + if (!oarg) + { + if (oded) + { + if (tparam->specialization()) + { /* The specialization can work as long as afterwards + * the oded == oarg + */ + Declaration *sparam; + dedargs->tdata()[i] = oded; + MATCH m2 = tparam->matchArg(paramscope, dedargs, i, parameters, &dedtypes, &sparam); + //printf("m2 = %d\n", m2); + if (!m2) + goto Lnomatch; + if (m2 < match) + match = m2; // pick worst match + if (dedtypes.tdata()[i] != oded) + error("specialization not allowed for deduced parameter %s", tparam->ident->toChars()); + } + } + else + { oded = tparam->defaultArg(loc, paramscope); + if (!oded) + { + if (tp && // if tuple parameter and + fptupindex < 0 && // tuple parameter was not in function parameter list and + nargsi == dedargs->dim - 1) // we're one argument short (i.e. no tuple argument) + { // make tuple argument an empty tuple + oded = (Object *)new Tuple(); + } + else + goto Lnomatch; + } + } + declareParameter(paramscope, tparam, oded); + dedargs->tdata()[i] = oded; + } + } + +#if DMDV2 + if (constraint) + { /* Check to see if constraint is satisfied. + * Most of this code appears twice; this is a good candidate for refactoring. + */ + makeParamNamesVisibleInConstraint(paramscope, fargs); + Expression *e = constraint->syntaxCopy(); + paramscope->flags |= SCOPEstaticif; + + /* Detect recursive attempts to instantiate this template declaration, + * Bugzilla 4072 + * void foo(T)(T x) if (is(typeof(foo(x)))) { } + * static assert(!is(typeof(foo(7)))); + * Recursive attempts are regarded as a constraint failure. + */ + int nmatches = 0; + for (Previous *p = previous; p; p = p->prev) + { + if (arrayObjectMatch(p->dedargs, dedargs, this, sc)) + { + //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars()); + /* It must be a subscope of p->sc, other scope chains are not recursive + * instantiations. + */ + for (Scope *scx = sc; scx; scx = scx->enclosing) + { + if (scx == p->sc) + goto Lnomatch; + } + } + /* BUG: should also check for ref param differences + */ + } + + Previous pr; + pr.prev = previous; + pr.sc = paramscope; + pr.dedargs = dedargs; + previous = ≺ // add this to threaded list + + int nerrors = global.errors; + + FuncDeclaration *fd = onemember && onemember->toAlias() ? + onemember->toAlias()->isFuncDeclaration() : NULL; + Dsymbol *s = parent; + while (s->isTemplateInstance() || s->isTemplateMixin()) + s = s->parent; + AggregateDeclaration *ad = s->isAggregateDeclaration(); + VarDeclaration *vthissave; + if (fd && ad) + { + vthissave = fd->vthis; + fd->vthis = fd->declareThis(paramscope, ad); + } + + e = e->semantic(paramscope); + + if (fd && fd->vthis) + fd->vthis = vthissave; + + previous = pr.prev; // unlink from threaded list + + if (nerrors != global.errors) // if any errors from evaluating the constraint, no match + goto Lnomatch; + + e = e->optimize(WANTvalue | WANTinterpret); + if (e->isBool(TRUE)) + ; + else if (e->isBool(FALSE)) + goto Lnomatch; + else + { + e->error("constraint %s is not constant or does not evaluate to a bool", e->toChars()); + } + } +#endif + +#if 0 + for (i = 0; i < dedargs->dim; i++) + { Type *t = dedargs->tdata()[i]; + printf("\tdedargs[%d] = %d, %s\n", i, t->dyncast(), t->toChars()); + } +#endif + + paramscope->pop(); + //printf("\tmatch %d\n", match); + return match; + +Lnomatch: + paramscope->pop(); + //printf("\tnomatch\n"); + return MATCHnomatch; +} + +/************************************************** + * Declare template parameter tp with value o, and install it in the scope sc. + */ + +void TemplateDeclaration::declareParameter(Scope *sc, TemplateParameter *tp, Object *o) +{ + //printf("TemplateDeclaration::declareParameter('%s', o = %p)\n", tp->ident->toChars(), o); + + Type *targ = isType(o); + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + Tuple *va = isTuple(o); + + Dsymbol *s; + + // See if tp->ident already exists with a matching definition + Dsymbol *scopesym; + s = sc->search(loc, tp->ident, &scopesym); + if (s && scopesym == sc->scopesym) + { + TupleDeclaration *td = s->isTupleDeclaration(); + if (va && td) + { Tuple tup; + tup.objects = *td->objects; + if (match(va, &tup, this, sc)) + { + return; + } + } + } + + if (targ) + { + //printf("type %s\n", targ->toChars()); + s = new AliasDeclaration(0, tp->ident, targ); + } + else if (sa) + { + //printf("Alias %s %s;\n", sa->ident->toChars(), tp->ident->toChars()); + s = new AliasDeclaration(0, tp->ident, sa); + } + else if (ea) + { + // tdtypes.data[i] always matches ea here + Initializer *init = new ExpInitializer(loc, ea); + TemplateValueParameter *tvp = tp->isTemplateValueParameter(); + + Type *t = tvp ? tvp->valType : NULL; + + VarDeclaration *v = new VarDeclaration(loc, t, tp->ident, init); + v->storage_class = STCmanifest; + s = v; + } + else if (va) + { + //printf("\ttuple\n"); + s = new TupleDeclaration(loc, tp->ident, &va->objects); + } + else + { +#ifdef DEBUG + o->print(); +#endif + assert(0); + } + if (!sc->insert(s)) + error("declaration %s is already defined", tp->ident->toChars()); + s->semantic(sc); +} + +/************************************** + * Determine if TemplateDeclaration is variadic. + */ + +TemplateTupleParameter *isVariadic(TemplateParameters *parameters) +{ size_t dim = parameters->dim; + TemplateTupleParameter *tp = NULL; + + if (dim) + tp = (parameters->tdata()[dim - 1])->isTemplateTupleParameter(); + return tp; +} + +TemplateTupleParameter *TemplateDeclaration::isVariadic() +{ + return ::isVariadic(parameters); +} + +/*********************************** + * We can overload templates. + */ + +int TemplateDeclaration::isOverloadable() +{ + return 1; +} + +/************************************************* + * Given function arguments, figure out which template function + * to expand, and return that function. + * If no match, give error message and return NULL. + * Input: + * sc instantiation scope + * loc instantiation location + * targsi initial list of template arguments + * ethis if !NULL, the 'this' pointer argument + * fargs arguments to function + * flags 1: do not issue error message on no match, just return NULL + */ + +FuncDeclaration *TemplateDeclaration::deduceFunctionTemplate(Scope *sc, Loc loc, + Objects *targsi, Expression *ethis, Expressions *fargs, int flags) +{ + MATCH m_best = MATCHnomatch; + TemplateDeclaration *td_ambig = NULL; + TemplateDeclaration *td_best = NULL; + Objects *tdargs = new Objects(); + TemplateInstance *ti; + FuncDeclaration *fd_best; + +#if 0 + printf("TemplateDeclaration::deduceFunctionTemplate() %s\n", toChars()); + printf(" targsi:\n"); + if (targsi) + { for (size_t i = 0; i < targsi->dim; i++) + { Object *arg = targsi->tdata()[i]; + printf("\t%s\n", arg->toChars()); + } + } + printf(" fargs:\n"); + for (size_t i = 0; i < fargs->dim; i++) + { Expression *arg = fargs->tdata()[i]; + printf("\t%s %s\n", arg->type->toChars(), arg->toChars()); + //printf("\tty = %d\n", arg->type->ty); + } + printf("stc = %llx\n", scope->stc); +#endif + + for (TemplateDeclaration *td = this; td; td = td->overnext) + { + if (!td->semanticRun) + { + error("forward reference to template %s", td->toChars()); + goto Lerror; + } + if (!td->onemember || !td->onemember->toAlias()->isFuncDeclaration()) + { + error("is not a function template"); + goto Lerror; + } + + MATCH m; + Objects dedargs; + FuncDeclaration *fd = NULL; + + m = td->deduceFunctionTemplateMatch(sc, loc, targsi, ethis, fargs, &dedargs); + //printf("deduceFunctionTemplateMatch = %d\n", m); + if (!m) // if no match + continue; + + if (m < m_best) + goto Ltd_best; + if (m > m_best) + goto Ltd; + + { + // Disambiguate by picking the most specialized TemplateDeclaration + MATCH c1 = td->leastAsSpecialized(td_best, fargs); + MATCH c2 = td_best->leastAsSpecialized(td, fargs); + //printf("1: c1 = %d, c2 = %d\n", c1, c2); + + if (c1 > c2) + goto Ltd; + else if (c1 < c2) + goto Ltd_best; + } + + if (!fd_best) + { + fd_best = td_best->doHeaderInstantiation(sc, tdargs, fargs); + if (!fd_best) + goto Lerror; + } + { + tdargs->setDim(dedargs.dim); + memcpy(tdargs->data, dedargs.data, tdargs->dim * sizeof(void *)); + fd = td->doHeaderInstantiation(sc, tdargs, fargs); + if (!fd) + goto Lerror; + } + assert(fd && fd_best); + + { + // Disambiguate by tf->callMatch + TypeFunction *tf1 = (TypeFunction *)fd->type; + TypeFunction *tf2 = (TypeFunction *)fd_best->type; + MATCH c1 = (MATCH) tf1->callMatch(fd->needThis() && !fd->isCtorDeclaration() ? ethis : NULL, fargs); + MATCH c2 = (MATCH) tf2->callMatch(fd_best->needThis() && !fd->isCtorDeclaration() ? ethis : NULL, fargs); + //printf("2: c1 = %d, c2 = %d\n", c1, c2); + + if (c1 > c2) + goto Ltd; + if (c1 < c2) + goto Ltd_best; + } + + { + // Disambiguate by picking the most specialized FunctionDeclaration + MATCH c1 = fd->leastAsSpecialized(fd_best); + MATCH c2 = fd_best->leastAsSpecialized(fd); + //printf("3: c1 = %d, c2 = %d\n", c1, c2); + + if (c1 > c2) + goto Ltd; + if (c1 < c2) + goto Ltd_best; + } + + Lambig: // td_best and td are ambiguous + td_ambig = td; + continue; + + Ltd_best: // td_best is the best match so far + td_ambig = NULL; + continue; + + Ltd: // td is the new best match + td_ambig = NULL; + assert((size_t)td->scope > 0x10000); + td_best = td; + fd_best = fd; + m_best = m; + tdargs->setDim(dedargs.dim); + memcpy(tdargs->tdata(), dedargs.tdata(), tdargs->dim * sizeof(void *)); + continue; + } + if (!td_best) + { + if (!(flags & 1)) + error(loc, "does not match any function template declaration"); + goto Lerror; + } + if (td_ambig) + { + error(loc, "%s matches more than one template declaration, %s(%d):%s and %s(%d):%s", + toChars(), + td_best->loc.filename, td_best->loc.linnum, td_best->toChars(), + td_ambig->loc.filename, td_ambig->loc.linnum, td_ambig->toChars()); + } + + /* The best match is td_best with arguments tdargs. + * Now instantiate the template. + */ + assert((size_t)td_best->scope > 0x10000); + ti = new TemplateInstance(loc, td_best, tdargs); + ti->semantic(sc, fargs); + fd_best = ti->toAlias()->isFuncDeclaration(); + if (!fd_best || !((TypeFunction*)fd_best->type)->callMatch(ethis, fargs, flags)) + goto Lerror; + return fd_best; + + Lerror: +#if DMDV2 + if (!(flags & 1)) +#endif + { + HdrGenState hgs; + + OutBuffer bufa; + Objects *args = targsi; + if (args) + { for (size_t i = 0; i < args->dim; i++) + { + if (i) + bufa.writeByte(','); + Object *oarg = args->tdata()[i]; + ObjectToCBuffer(&bufa, &hgs, oarg); + } + } + + OutBuffer buf; + argExpTypesToCBuffer(&buf, fargs, &hgs); + error(loc, "cannot deduce template function from argument types !(%s)(%s)", + bufa.toChars(), buf.toChars()); + } + return NULL; +} + +/************************************************* + * Limited function template instantiation for using fd->leastAsSpecialized() + */ +FuncDeclaration *TemplateDeclaration::doHeaderInstantiation(Scope *sc, + Objects *tdargs, Expressions *fargs) +{ + FuncDeclaration *fd = onemember->toAlias()->isFuncDeclaration(); + if (!fd) + return NULL; + +#if 0 + printf("doHeaderInstantiation this = %s\n", toChars()); + for (size_t i = 0; i < tdargs->dim; ++i) + printf("\ttdargs[%d] = %s\n", i, ((Object *)tdargs->data[i])->toChars()); +#endif + + assert((size_t)scope > 0x10000); + TemplateInstance *ti = new TemplateInstance(loc, this, tdargs); + ti->tinst = sc->tinst; + { + ti->tdtypes.setDim(ti->tempdecl->parameters->dim); + if (!ti->tempdecl->matchWithInstance(ti, &ti->tdtypes, fargs, 2)) + return NULL; + } + + ti->parent = parent; + + // function body and contracts are not need + //fd = fd->syntaxCopy(NULL)->isFuncDeclaration(); + fd = new FuncDeclaration(fd->loc, fd->endloc, fd->ident, fd->storage_class, fd->type->syntaxCopy()); + fd->parent = ti; + + Scope *scope = this->scope; + + ti->argsym = new ScopeDsymbol(); + ti->argsym->parent = scope->parent; + scope = scope->push(ti->argsym); + + Scope *paramscope = scope->push(); + paramscope->stc = 0; + ti->declareParameters(paramscope); + paramscope->pop(); + + { + TypeFunction *tf = (TypeFunction *)fd->type; + if (tf && tf->ty == Tfunction) + tf->fargs = fargs; + } + + Scope *sc2; + sc2 = scope->push(ti); + sc2->parent = /*isnested ? sc->parent :*/ ti; + sc2->tinst = ti; + + { + Scope *sc = sc2; + sc = sc->push(); + + if (fd->isCtorDeclaration()) + sc->flags |= SCOPEctor; + fd->type = fd->type->semantic(fd->loc, sc); + sc = sc->pop(); + } + //printf("\t[%s] fd->type = %s, mod = %x, ", loc.toChars(), fd->type->toChars(), fd->type->mod); + //printf("fd->needThis() = %d\n", fd->needThis()); + + sc2->pop(); + scope->pop(); + + return fd; +} + +bool TemplateDeclaration::hasStaticCtorOrDtor() +{ + return FALSE; // don't scan uninstantiated templates +} + +void TemplateDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ +#if 0 // Should handle template functions for doc generation + if (onemember && onemember->isFuncDeclaration()) + buf->writestring("foo "); +#endif + if (hgs->ddoc) + buf->writestring(kind()); + else + buf->writestring("template"); + buf->writeByte(' '); + buf->writestring(ident->toChars()); + buf->writeByte('('); + for (size_t i = 0; i < parameters->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + if (hgs->ddoc) + tp = origParameters->tdata()[i]; + if (i) + buf->writeByte(','); + tp->toCBuffer(buf, hgs); + } + buf->writeByte(')'); +#if DMDV2 + if (constraint) + { buf->writestring(" if ("); + constraint->toCBuffer(buf, hgs); + buf->writeByte(')'); + } +#endif + + if (hgs->hdrgen) + { + hgs->tpltMember++; + buf->writenl(); + buf->writebyte('{'); + buf->writenl(); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->toCBuffer(buf, hgs); + } + buf->writebyte('}'); + buf->writenl(); + hgs->tpltMember--; + } +} + + +char *TemplateDeclaration::toChars() +{ OutBuffer buf; + HdrGenState hgs; + + memset(&hgs, 0, sizeof(hgs)); + buf.writestring(ident->toChars()); + buf.writeByte('('); + for (size_t i = 0; i < parameters->dim; i++) + { + TemplateParameter *tp = parameters->tdata()[i]; + if (i) + buf.writeByte(','); + tp->toCBuffer(&buf, &hgs); + } + buf.writeByte(')'); +#if DMDV2 + if (constraint) + { buf.writestring(" if ("); + constraint->toCBuffer(&buf, &hgs); + buf.writeByte(')'); + } +#endif + buf.writeByte(0); + return (char *)buf.extractData(); +} + +/* ======================== Type ============================================ */ + +/**** + * Given an identifier, figure out which TemplateParameter it is. + * Return -1 if not found. + */ + +int templateIdentifierLookup(Identifier *id, TemplateParameters *parameters) +{ + for (size_t i = 0; i < parameters->dim; i++) + { TemplateParameter *tp = parameters->tdata()[i]; + + if (tp->ident->equals(id)) + return i; + } + return -1; +} + +int templateParameterLookup(Type *tparam, TemplateParameters *parameters) +{ + assert(tparam->ty == Tident); + TypeIdentifier *tident = (TypeIdentifier *)tparam; + //printf("\ttident = '%s'\n", tident->toChars()); + if (tident->idents.dim == 0) + { + return templateIdentifierLookup(tident->ident, parameters); + } + return -1; +} + +/* These form the heart of template argument deduction. + * Given 'this' being the type argument to the template instance, + * it is matched against the template declaration parameter specialization + * 'tparam' to determine the type to be used for the parameter. + * Example: + * template Foo(T:T*) // template declaration + * Foo!(int*) // template instantiation + * Input: + * this = int* + * tparam = T + * parameters = [ T:T* ] // Array of TemplateParameter's + * Output: + * dedtypes = [ int ] // Array of Expression/Type's + */ + +MATCH Type::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, + Objects *dedtypes, unsigned *wildmatch) +{ +#if 0 + printf("Type::deduceType()\n"); + printf("\tthis = %d, ", ty); print(); + printf("\ttparam = %d, ", tparam->ty); tparam->print(); +#endif + if (!tparam) + goto Lnomatch; + + if (this == tparam) + goto Lexact; + + if (tparam->ty == Tident) + { + // Determine which parameter tparam is + int i = templateParameterLookup(tparam, parameters); + if (i == -1) + { + if (!sc) + goto Lnomatch; + + /* Need a loc to go with the semantic routine. + */ + Loc loc; + if (parameters->dim) + { + TemplateParameter *tp = parameters->tdata()[0]; + loc = tp->loc; + } + + /* BUG: what if tparam is a template instance, that + * has as an argument another Tident? + */ + tparam = tparam->semantic(loc, sc); + assert(tparam->ty != Tident); + return deduceType(sc, tparam, parameters, dedtypes, wildmatch); + } + + TemplateParameter *tp = parameters->tdata()[i]; + + // Found the corresponding parameter tp + if (!tp->isTemplateTypeParameter()) + goto Lnomatch; + Type *tt = this; + Type *at = (Type *)dedtypes->tdata()[i]; + + // 7*7 == 49 cases + + #define X(U,T) ((U) << 4) | (T) + + if (wildmatch && (tparam->mod & MODwild)) + { + switch (X(tparam->mod, mod)) + { + case X(MODwild, MODwild): + case X(MODwild | MODshared, MODwild | MODshared): + case X(MODwild, 0): + case X(MODwild, MODconst): + case X(MODwild, MODimmutable): + case X(MODwild | MODshared, MODshared): + case X(MODwild | MODshared, MODconst | MODshared): + + if (!at) + { + if (mod & MODwild) + *wildmatch |= MODwild; + else if (mod == 0) + *wildmatch |= MODmutable; + else + *wildmatch |= (mod & ~MODshared); + tt = mutableOf(); + dedtypes->tdata()[i] = tt; + goto Lconst; + } + + //printf("\t> tt = %s, at = %s\n", tt->toChars(), at->toChars()); + //printf("\t> tt->implicitConvTo(at->constOf()) = %d\n", tt->implicitConvTo(at->constOf())); + //printf("\t> at->implicitConvTo(tt->constOf()) = %d\n", at->implicitConvTo(tt->constOf())); + + if (tt->equals(at)) + { + goto Lconst; + } + else if (tt->implicitConvTo(at->constOf())) + { + dedtypes->tdata()[i] = at->constOf()->mutableOf(); + *wildmatch |= MODconst; + goto Lconst; + } + else if (at->implicitConvTo(tt->constOf())) + { + dedtypes->tdata()[i] = tt->constOf()->mutableOf(); + *wildmatch |= MODconst; + goto Lconst; + } + goto Lnomatch; + + default: + break; + } + } + + switch (X(tparam->mod, mod)) + { + case X(0, 0): + case X(0, MODconst): + case X(0, MODimmutable): + case X(0, MODshared): + case X(0, MODconst | MODshared): + case X(0, MODwild): + case X(0, MODwild | MODshared): + // foo(U:U) T => T + // foo(U:U) const(T) => const(T) + // foo(U:U) immutable(T) => immutable(T) + // foo(U:U) shared(T) => shared(T) + // foo(U:U) const(shared(T)) => const(shared(T)) + // foo(U:U) wild(T) => wild(T) + // foo(U:U) wild(shared(T)) => wild(shared(T)) + if (!at) + { dedtypes->tdata()[i] = tt; + goto Lexact; + } + break; + + case X(MODconst, MODconst): + case X(MODimmutable, MODimmutable): + case X(MODshared, MODshared): + case X(MODconst | MODshared, MODconst | MODshared): + case X(MODwild, MODwild): + case X(MODwild | MODshared, MODwild | MODshared): + // foo(U:const(U)) const(T) => T + // foo(U:immutable(U)) immutable(T) => T + // foo(U:shared(U)) shared(T) => T + // foo(U:const(shared(U)) const(shared(T)) => T + // foo(U:wild(U)) wild(T) => T + // foo(U:wild(shared(U)) wild(shared(T)) => T + tt = mutableOf()->unSharedOf(); + if (!at) + { dedtypes->tdata()[i] = tt; + goto Lexact; + } + break; + + case X(MODconst, 0): + case X(MODconst, MODimmutable): + case X(MODconst, MODconst | MODshared): + case X(MODconst | MODshared, MODimmutable): + case X(MODconst, MODwild): + case X(MODconst, MODwild | MODshared): + // foo(U:const(U)) T => T + // foo(U:const(U)) immutable(T) => T + // foo(U:const(U)) const(shared(T)) => shared(T) + // foo(U:const(shared(U)) immutable(T) => T + // foo(U:const(U)) wild(shared(T)) => shared(T) + tt = mutableOf(); + if (!at) + { dedtypes->tdata()[i] = tt; + goto Lconst; + } + break; + + case X(MODshared, MODconst | MODshared): + case X(MODconst | MODshared, MODshared): + case X(MODshared, MODwild | MODshared): + // foo(U:shared(U)) const(shared(T)) => const(T) + // foo(U:const(shared(U)) shared(T) => T + // foo(U:shared(U)) wild(shared(T)) => wild(T) + tt = unSharedOf(); + if (!at) + { dedtypes->tdata()[i] = tt; + goto Lconst; + } + break; + + case X(MODimmutable, 0): + case X(MODimmutable, MODconst): + case X(MODimmutable, MODshared): + case X(MODimmutable, MODconst | MODshared): + case X(MODconst, MODshared): + case X(MODshared, 0): + case X(MODshared, MODconst): + case X(MODshared, MODimmutable): + case X(MODconst | MODshared, 0): + case X(MODconst | MODshared, MODconst): + case X(MODimmutable, MODwild): + case X(MODshared, MODwild): + case X(MODconst | MODshared, MODwild): + case X(MODwild, 0): + case X(MODwild, MODconst): + case X(MODwild, MODimmutable): + case X(MODwild, MODshared): + case X(MODwild, MODconst | MODshared): + case X(MODwild | MODshared, 0): + case X(MODwild | MODshared, MODconst): + case X(MODwild | MODshared, MODimmutable): + case X(MODwild | MODshared, MODshared): + case X(MODwild | MODshared, MODconst | MODshared): + case X(MODwild | MODshared, MODwild): + case X(MODimmutable, MODwild | MODshared): + case X(MODconst | MODshared, MODwild | MODshared): + case X(MODwild, MODwild | MODshared): + + // foo(U:immutable(U)) T => nomatch + // foo(U:immutable(U)) const(T) => nomatch + // foo(U:immutable(U)) shared(T) => nomatch + // foo(U:immutable(U)) const(shared(T)) => nomatch + // foo(U:const(U)) shared(T) => nomatch + // foo(U:shared(U)) T => nomatch + // foo(U:shared(U)) const(T) => nomatch + // foo(U:shared(U)) immutable(T) => nomatch + // foo(U:const(shared(U)) T => nomatch + // foo(U:const(shared(U)) const(T) => nomatch + // foo(U:immutable(U)) wild(T) => nomatch + // foo(U:shared(U)) wild(T) => nomatch + // foo(U:const(shared(U)) wild(T) => nomatch + // foo(U:wild(U)) T => nomatch + // foo(U:wild(U)) const(T) => nomatch + // foo(U:wild(U)) immutable(T) => nomatch + // foo(U:wild(U)) shared(T) => nomatch + // foo(U:wild(U)) const(shared(T)) => nomatch + // foo(U:wild(shared(U)) T => nomatch + // foo(U:wild(shared(U)) const(T) => nomatch + // foo(U:wild(shared(U)) immutable(T) => nomatch + // foo(U:wild(shared(U)) shared(T) => nomatch + // foo(U:wild(shared(U)) const(shared(T)) => nomatch + // foo(U:wild(shared(U)) wild(T) => nomatch + // foo(U:immutable(U)) wild(shared(T)) => nomatch + // foo(U:const(shared(U))) wild(shared(T)) => nomatch + // foo(U:wild(U)) wild(shared(T)) => nomatch + //if (!at) + goto Lnomatch; + break; + + default: + assert(0); + } + #undef X + + if (tt->equals(at)) + goto Lexact; + else if (tt->ty == Tclass && at->ty == Tclass) + { + return tt->implicitConvTo(at); + } + else if (tt->ty == Tsarray && at->ty == Tarray && + tt->nextOf()->implicitConvTo(at->nextOf()) >= MATCHconst) + { + goto Lexact; + } + else + goto Lnomatch; + } + else if (tparam->ty == Ttypeof) + { + /* Need a loc to go with the semantic routine. + */ + Loc loc; + if (parameters->dim) + { + TemplateParameter *tp = parameters->tdata()[0]; + loc = tp->loc; + } + + tparam = tparam->semantic(loc, sc); + } + + if (ty != tparam->ty) + { +#if DMDV2 + // Can't instantiate AssociativeArray!() without a scope + if (tparam->ty == Taarray && !((TypeAArray*)tparam)->sc) + ((TypeAArray*)tparam)->sc = sc; + + MATCH m = implicitConvTo(tparam); + if (m == MATCHnomatch) + { + Type *at = aliasthisOf(); + if (at) + m = at->deduceType(sc, tparam, parameters, dedtypes, wildmatch); + } + return m; +#else + return implicitConvTo(tparam); +#endif + } + + if (nextOf()) + return nextOf()->deduceType(sc, tparam->nextOf(), parameters, dedtypes, wildmatch); + +Lexact: + return MATCHexact; + +Lnomatch: + return MATCHnomatch; + +#if DMDV2 +Lconst: + return MATCHconst; +#endif +} + +#if DMDV2 +MATCH TypeDArray::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, + Objects *dedtypes, unsigned *wildmatch) +{ +#if 0 + printf("TypeDArray::deduceType()\n"); + printf("\tthis = %d, ", ty); print(); + printf("\ttparam = %d, ", tparam->ty); tparam->print(); +#endif + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} +#endif + +MATCH TypeSArray::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, + Objects *dedtypes, unsigned *wildmatch) +{ +#if 0 + printf("TypeSArray::deduceType()\n"); + printf("\tthis = %d, ", ty); print(); + printf("\ttparam = %d, ", tparam->ty); tparam->print(); +#endif + + // Extra check that array dimensions must match + if (tparam) + { + if (tparam->ty == Tarray) + { MATCH m; + + m = next->deduceType(sc, tparam->nextOf(), parameters, dedtypes, wildmatch); + if (m == MATCHexact) + m = MATCHconvert; + return m; + } + + Identifier *id = NULL; + if (tparam->ty == Tsarray) + { + TypeSArray *tp = (TypeSArray *)tparam; + if (tp->dim->op == TOKvar && + ((VarExp *)tp->dim)->var->storage_class & STCtemplateparameter) + { + id = ((VarExp *)tp->dim)->var->ident; + } + else if (dim->toInteger() != tp->dim->toInteger()) + return MATCHnomatch; + } + else if (tparam->ty == Taarray) + { + TypeAArray *tp = (TypeAArray *)tparam; + if (tp->index->ty == Tident && + ((TypeIdentifier *)tp->index)->idents.dim == 0) + { + id = ((TypeIdentifier *)tp->index)->ident; + } + } + if (id) + { + // This code matches code in TypeInstance::deduceType() + int i = templateIdentifierLookup(id, parameters); + if (i == -1) + goto Lnomatch; + TemplateParameter *tprm = parameters->tdata()[i]; + TemplateValueParameter *tvp = tprm->isTemplateValueParameter(); + if (!tvp) + goto Lnomatch; + Expression *e = (Expression *)dedtypes->tdata()[i]; + if (e) + { + if (!dim->equals(e)) + goto Lnomatch; + } + else + { + Type *vt = tvp->valType->semantic(0, sc); + MATCH m = (MATCH)dim->implicitConvTo(vt); + if (!m) + goto Lnomatch; + dedtypes->tdata()[i] = dim; + } + return next->deduceType(sc, tparam->nextOf(), parameters, dedtypes, wildmatch); + } + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); + + Lnomatch: + return MATCHnomatch; +} + +MATCH TypeAArray::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ +#if 0 + printf("TypeAArray::deduceType()\n"); + printf("\tthis = %d, ", ty); print(); + printf("\ttparam = %d, ", tparam->ty); tparam->print(); +#endif + + // Extra check that index type must match + if (tparam && tparam->ty == Taarray) + { + TypeAArray *tp = (TypeAArray *)tparam; + if (!index->deduceType(sc, tp->index, parameters, dedtypes, wildmatch)) + { + return MATCHnomatch; + } + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +MATCH TypeFunction::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + //printf("TypeFunction::deduceType()\n"); + //printf("\tthis = %d, ", ty); print(); + //printf("\ttparam = %d, ", tparam->ty); tparam->print(); + + // Extra check that function characteristics must match + if (tparam && tparam->ty == Tfunction) + { + TypeFunction *tp = (TypeFunction *)tparam; + if (varargs != tp->varargs || + linkage != tp->linkage) + return MATCHnomatch; + + size_t nfargs = Parameter::dim(this->parameters); + size_t nfparams = Parameter::dim(tp->parameters); + + // bug 2579 fix: Apply function parameter storage classes to parameter types + for (size_t i = 0; i < nfparams; i++) + { + Parameter *fparam = Parameter::getNth(tp->parameters, i); + fparam->type = fparam->type->addStorageClass(fparam->storageClass); + fparam->storageClass &= ~(STC_TYPECTOR | STCin); + } + //printf("\t-> this = %d, ", ty); print(); + //printf("\t-> tparam = %d, ", tparam->ty); tparam->print(); + + /* See if tuple match + */ + if (nfparams > 0 && nfargs >= nfparams - 1) + { + /* See if 'A' of the template parameter matches 'A' + * of the type of the last function parameter. + */ + Parameter *fparam = Parameter::getNth(tp->parameters, nfparams - 1); + assert(fparam); + assert(fparam->type); + if (fparam->type->ty != Tident) + goto L1; + TypeIdentifier *tid = (TypeIdentifier *)fparam->type; + if (tid->idents.dim) + goto L1; + + /* Look through parameters to find tuple matching tid->ident + */ + size_t tupi = 0; + for (; 1; tupi++) + { if (tupi == parameters->dim) + goto L1; + TemplateParameter *t = parameters->tdata()[tupi]; + TemplateTupleParameter *tup = t->isTemplateTupleParameter(); + if (tup && tup->ident->equals(tid->ident)) + break; + } + + /* The types of the function arguments [nfparams - 1 .. nfargs] + * now form the tuple argument. + */ + size_t tuple_dim = nfargs - (nfparams - 1); + + /* See if existing tuple, and whether it matches or not + */ + Object *o = dedtypes->tdata()[tupi]; + if (o) + { // Existing deduced argument must be a tuple, and must match + Tuple *t = isTuple(o); + if (!t || t->objects.dim != tuple_dim) + return MATCHnomatch; + for (size_t i = 0; i < tuple_dim; i++) + { Parameter *arg = Parameter::getNth(this->parameters, nfparams - 1 + i); + if (!arg->type->equals(t->objects.tdata()[i])) + return MATCHnomatch; + } + } + else + { // Create new tuple + Tuple *t = new Tuple(); + t->objects.setDim(tuple_dim); + for (size_t i = 0; i < tuple_dim; i++) + { Parameter *arg = Parameter::getNth(this->parameters, nfparams - 1 + i); + t->objects.tdata()[i] = arg->type; + } + dedtypes->tdata()[tupi] = t; + } + nfparams--; // don't consider the last parameter for type deduction + goto L2; + } + + L1: + if (nfargs != nfparams) + return MATCHnomatch; + L2: + for (size_t i = 0; i < nfparams; i++) + { + Parameter *a = Parameter::getNth(this->parameters, i); + Parameter *ap = Parameter::getNth(tp->parameters, i); + if (a->storageClass != ap->storageClass || + !a->type->deduceType(sc, ap->type, parameters, dedtypes, wildmatch)) + return MATCHnomatch; + } + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +MATCH TypeIdentifier::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + // Extra check + if (tparam && tparam->ty == Tident) + { + TypeIdentifier *tp = (TypeIdentifier *)tparam; + + for (size_t i = 0; i < idents.dim; i++) + { + Identifier *id1 = idents.tdata()[i]; + Identifier *id2 = tp->idents.tdata()[i]; + + if (!id1->equals(id2)) + return MATCHnomatch; + } + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +MATCH TypeInstance::deduceType(Scope *sc, + Type *tparam, TemplateParameters *parameters, + Objects *dedtypes, unsigned *wildmatch) +{ +#if 0 + printf("TypeInstance::deduceType()\n"); + printf("\tthis = %d, ", ty); print(); + printf("\ttparam = %d, ", tparam->ty); tparam->print(); +#endif + + // Extra check + if (tparam && tparam->ty == Tinstance) + { + TypeInstance *tp = (TypeInstance *)tparam; + + //printf("tempinst->tempdecl = %p\n", tempinst->tempdecl); + //printf("tp->tempinst->tempdecl = %p\n", tp->tempinst->tempdecl); + if (!tp->tempinst->tempdecl) + { //printf("tp->tempinst->name = '%s'\n", tp->tempinst->name->toChars()); + if (!tp->tempinst->name->equals(tempinst->name)) + { + /* Handle case of: + * template Foo(T : sa!(T), alias sa) + */ + int i = templateIdentifierLookup(tp->tempinst->name, parameters); + if (i == -1) + { /* Didn't find it as a parameter identifier. Try looking + * it up and seeing if is an alias. See Bugzilla 1454 + */ + Dsymbol *s = tempinst->tempdecl->scope->search(0, tp->tempinst->name, NULL); + if (s) + { + s = s->toAlias(); + TemplateDeclaration *td = s->isTemplateDeclaration(); + if (td && td == tempinst->tempdecl) + goto L2; + } + goto Lnomatch; + } + TemplateParameter *tpx = parameters->tdata()[i]; + // This logic duplicates tpx->matchArg() + TemplateAliasParameter *ta = tpx->isTemplateAliasParameter(); + if (!ta) + goto Lnomatch; + Object *sa = tempinst->tempdecl; + if (!sa) + goto Lnomatch; + if (ta->specAlias && sa != ta->specAlias) + goto Lnomatch; + if (dedtypes->tdata()[i]) + { // Must match already deduced symbol + Object *s = dedtypes->tdata()[i]; + + if (s != sa) + goto Lnomatch; + } + dedtypes->tdata()[i] = sa; + } + } + else if (tempinst->tempdecl != tp->tempinst->tempdecl) + goto Lnomatch; + + L2: + + for (size_t i = 0; 1; i++) + { + //printf("\ttest: tempinst->tiargs[%d]\n", i); + Object *o1; + if (i < tempinst->tiargs->dim) + o1 = tempinst->tiargs->tdata()[i]; + else if (i < tempinst->tdtypes.dim && i < tp->tempinst->tiargs->dim) + // Pick up default arg + o1 = tempinst->tdtypes.tdata()[i]; + else + break; + + if (i >= tp->tempinst->tiargs->dim) + goto Lnomatch; + + Object *o2 = tp->tempinst->tiargs->tdata()[i]; + + Type *t1 = isType(o1); + Type *t2 = isType(o2); + + Expression *e1 = isExpression(o1); + Expression *e2 = isExpression(o2); + + Dsymbol *s1 = isDsymbol(o1); + Dsymbol *s2 = isDsymbol(o2); + + Tuple *v1 = isTuple(o1); + Tuple *v2 = isTuple(o2); +#if 0 + if (t1) printf("t1 = %s\n", t1->toChars()); + if (t2) printf("t2 = %s\n", t2->toChars()); + if (e1) printf("e1 = %s\n", e1->toChars()); + if (e2) printf("e2 = %s\n", e2->toChars()); + if (s1) printf("s1 = %s\n", s1->toChars()); + if (s2) printf("s2 = %s\n", s2->toChars()); + if (v1) printf("v1 = %s\n", v1->toChars()); + if (v2) printf("v2 = %s\n", v2->toChars()); +#endif + + TemplateTupleParameter *ttp; + int j; + if (t2 && + t2->ty == Tident && + i == tp->tempinst->tiargs->dim - 1 && + i == tempinst->tempdecl->parameters->dim - 1 && + (ttp = tempinst->tempdecl->isVariadic()) != NULL) + { + /* Given: + * struct A(B...) {} + * alias A!(int, float) X; + * static if (!is(X Y == A!(Z), Z)) + * deduce that Z is a tuple(int, float) + */ + + j = templateParameterLookup(t2, parameters); + if (j == -1) + goto Lnomatch; + + /* Create tuple from remaining args + */ + Tuple *vt = new Tuple(); + size_t vtdim = tempinst->tiargs->dim - i; + vt->objects.setDim(vtdim); + for (size_t k = 0; k < vtdim; k++) + vt->objects.tdata()[k] = tempinst->tiargs->tdata()[i + k]; + + Tuple *v = (Tuple *)dedtypes->tdata()[j]; + if (v) + { + if (!match(v, vt, tempinst->tempdecl, sc)) + goto Lnomatch; + } + else + dedtypes->tdata()[j] = vt; + break; //return MATCHexact; + } + + if (t1 && t2) + { + if (!t1->deduceType(sc, t2, parameters, dedtypes, wildmatch)) + goto Lnomatch; + } + else if (e1 && e2) + { + if (!e1->equals(e2)) + { if (e2->op == TOKvar) + { + /* + * (T:Number!(e2), int e2) + */ + j = templateIdentifierLookup(((VarExp *)e2)->var->ident, parameters); + goto L1; + } + goto Lnomatch; + } + } + else if (e1 && t2 && t2->ty == Tident) + { + j = templateParameterLookup(t2, parameters); + L1: + if (j == -1) + goto Lnomatch; + TemplateParameter *tp = parameters->tdata()[j]; + // BUG: use tp->matchArg() instead of the following + TemplateValueParameter *tv = tp->isTemplateValueParameter(); + if (!tv) + goto Lnomatch; + Expression *e = (Expression *)dedtypes->tdata()[j]; + if (e) + { + if (!e1->equals(e)) + goto Lnomatch; + } + else + { Type *vt = tv->valType->semantic(0, sc); + MATCH m = (MATCH)e1->implicitConvTo(vt); + if (!m) + goto Lnomatch; + dedtypes->tdata()[j] = e1; + } + } + else if (s1 && t2 && t2->ty == Tident) + { + j = templateParameterLookup(t2, parameters); + if (j == -1) + goto Lnomatch; + TemplateParameter *tp = parameters->tdata()[j]; + // BUG: use tp->matchArg() instead of the following + TemplateAliasParameter *ta = tp->isTemplateAliasParameter(); + if (!ta) + goto Lnomatch; + Dsymbol *s = (Dsymbol *)dedtypes->tdata()[j]; + if (s) + { + if (!s1->equals(s)) + goto Lnomatch; + } + else + { + dedtypes->tdata()[j] = s1; + } + } + else if (s1 && s2) + { + if (!s1->equals(s2)) + goto Lnomatch; + } + // BUG: Need to handle tuple parameters + else + goto Lnomatch; + } + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); + +Lnomatch: + //printf("no match\n"); + return MATCHnomatch; +} + +MATCH TypeStruct::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + //printf("TypeStruct::deduceType()\n"); + //printf("\tthis->parent = %s, ", sym->parent->toChars()); print(); + //printf("\ttparam = %d, ", tparam->ty); tparam->print(); + + /* If this struct is a template struct, and we're matching + * it against a template instance, convert the struct type + * to a template instance, too, and try again. + */ + TemplateInstance *ti = sym->parent->isTemplateInstance(); + + if (tparam && tparam->ty == Tinstance) + { + if (ti && ti->toAlias() == sym) + { + TypeInstance *t = new TypeInstance(0, ti); + return t->deduceType(sc, tparam, parameters, dedtypes, wildmatch); + } + + /* Match things like: + * S!(T).foo + */ + TypeInstance *tpi = (TypeInstance *)tparam; + if (tpi->idents.dim) + { Identifier *id = tpi->idents.tdata()[tpi->idents.dim - 1]; + if (id->dyncast() == DYNCAST_IDENTIFIER && sym->ident->equals(id)) + { + Type *tparent = sym->parent->getType(); + if (tparent) + { + /* Slice off the .foo in S!(T).foo + */ + tpi->idents.dim--; + MATCH m = tparent->deduceType(sc, tpi, parameters, dedtypes, wildmatch); + tpi->idents.dim++; + return m; + } + } + } + } + + // Extra check + if (tparam && tparam->ty == Tstruct) + { + TypeStruct *tp = (TypeStruct *)tparam; + + //printf("\t%d\n", (MATCH) implicitConvTo(tp)); + return implicitConvTo(tp); + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +MATCH TypeEnum::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + // Extra check + if (tparam && tparam->ty == Tenum) + { + TypeEnum *tp = (TypeEnum *)tparam; + + if (sym != tp->sym) + return MATCHnomatch; + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +MATCH TypeTypedef::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + // Extra check + if (tparam && tparam->ty == Ttypedef) + { + TypeTypedef *tp = (TypeTypedef *)tparam; + + if (sym != tp->sym) + return MATCHnomatch; + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +/* Helper for TypeClass::deduceType(). + * Classes can match with implicit conversion to a base class or interface. + * This is complicated, because there may be more than one base class which + * matches. In such cases, one or more parameters remain ambiguous. + * For example, + * + * interface I(X, Y) {} + * class C : I(uint, double), I(char, double) {} + * C x; + * foo(T, U)( I!(T, U) x) + * + * deduces that U is double, but T remains ambiguous (could be char or uint). + * + * Given a baseclass b, and initial deduced types 'dedtypes', this function + * tries to match tparam with b, and also tries all base interfaces of b. + * If a match occurs, numBaseClassMatches is incremented, and the new deduced + * types are ANDed with the current 'best' estimate for dedtypes. + */ +void deduceBaseClassParameters(BaseClass *b, + Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, + Objects *best, int &numBaseClassMatches) +{ + TemplateInstance *parti = b->base ? b->base->parent->isTemplateInstance() : NULL; + if (parti) + { + // Make a temporary copy of dedtypes so we don't destroy it + Objects *tmpdedtypes = new Objects(); + tmpdedtypes->setDim(dedtypes->dim); + memcpy(tmpdedtypes->tdata(), dedtypes->tdata(), dedtypes->dim * sizeof(void *)); + + TypeInstance *t = new TypeInstance(0, parti); + MATCH m = t->deduceType(sc, tparam, parameters, tmpdedtypes); + if (m != MATCHnomatch) + { + // If this is the first ever match, it becomes our best estimate + if (numBaseClassMatches==0) + memcpy(best->tdata(), tmpdedtypes->tdata(), tmpdedtypes->dim * sizeof(void *)); + else for (size_t k = 0; k < tmpdedtypes->dim; ++k) + { + // If we've found more than one possible type for a parameter, + // mark it as unknown. + if (tmpdedtypes->tdata()[k] != best->tdata()[k]) + best->tdata()[k] = dedtypes->tdata()[k]; + } + ++numBaseClassMatches; + } + } + // Now recursively test the inherited interfaces + for (size_t j = 0; j < b->baseInterfaces_dim; ++j) + { + deduceBaseClassParameters( &(b->baseInterfaces)[j], + sc, tparam, parameters, dedtypes, + best, numBaseClassMatches); + } + +} + +MATCH TypeClass::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wildmatch) +{ + //printf("TypeClass::deduceType(this = %s)\n", toChars()); + + /* If this class is a template class, and we're matching + * it against a template instance, convert the class type + * to a template instance, too, and try again. + */ + TemplateInstance *ti = sym->parent->isTemplateInstance(); + + if (tparam && tparam->ty == Tinstance) + { + if (ti && ti->toAlias() == sym) + { + TypeInstance *t = new TypeInstance(0, ti); + MATCH m = t->deduceType(sc, tparam, parameters, dedtypes, wildmatch); + // Even if the match fails, there is still a chance it could match + // a base class. + if (m != MATCHnomatch) + return m; + } + + /* Match things like: + * S!(T).foo + */ + TypeInstance *tpi = (TypeInstance *)tparam; + if (tpi->idents.dim) + { Identifier *id = tpi->idents.tdata()[tpi->idents.dim - 1]; + if (id->dyncast() == DYNCAST_IDENTIFIER && sym->ident->equals(id)) + { + Type *tparent = sym->parent->getType(); + if (tparent) + { + /* Slice off the .foo in S!(T).foo + */ + tpi->idents.dim--; + MATCH m = tparent->deduceType(sc, tpi, parameters, dedtypes, wildmatch); + tpi->idents.dim++; + return m; + } + } + } + + // If it matches exactly or via implicit conversion, we're done + MATCH m = Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); + if (m != MATCHnomatch) + return m; + + /* There is still a chance to match via implicit conversion to + * a base class or interface. Because there could be more than one such + * match, we need to check them all. + */ + + int numBaseClassMatches = 0; // Have we found an interface match? + + // Our best guess at dedtypes + Objects *best = new Objects(); + best->setDim(dedtypes->dim); + + ClassDeclaration *s = sym; + while(s && s->baseclasses->dim > 0) + { + // Test the base class + deduceBaseClassParameters((s->baseclasses->tdata()[0]), + sc, tparam, parameters, dedtypes, + best, numBaseClassMatches); + + // Test the interfaces inherited by the base class + for (size_t i = 0; i < s->interfaces_dim; ++i) + { + BaseClass *b = s->interfaces[i]; + deduceBaseClassParameters(b, sc, tparam, parameters, dedtypes, + best, numBaseClassMatches); + } + s = ((s->baseclasses->tdata()[0]))->base; + } + + if (numBaseClassMatches == 0) + return MATCHnomatch; + + // If we got at least one match, copy the known types into dedtypes + memcpy(dedtypes->tdata(), best->tdata(), best->dim * sizeof(void *)); + return MATCHconvert; + } + + // Extra check + if (tparam && tparam->ty == Tclass) + { + TypeClass *tp = (TypeClass *)tparam; + + //printf("\t%d\n", (MATCH) implicitConvTo(tp)); + return implicitConvTo(tp); + } + return Type::deduceType(sc, tparam, parameters, dedtypes, wildmatch); +} + +/* ======================== TemplateParameter =============================== */ + +TemplateParameter::TemplateParameter(Loc loc, Identifier *ident) +{ + this->loc = loc; + this->ident = ident; + this->sparam = NULL; +} + +TemplateTypeParameter *TemplateParameter::isTemplateTypeParameter() +{ + return NULL; +} + +TemplateValueParameter *TemplateParameter::isTemplateValueParameter() +{ + return NULL; +} + +TemplateAliasParameter *TemplateParameter::isTemplateAliasParameter() +{ + return NULL; +} + +TemplateTupleParameter *TemplateParameter::isTemplateTupleParameter() +{ + return NULL; +} + +#if DMDV2 +TemplateThisParameter *TemplateParameter::isTemplateThisParameter() +{ + return NULL; +} +#endif + +/* ======================== TemplateTypeParameter =========================== */ + +// type-parameter + +Type *TemplateTypeParameter::tdummy = NULL; + +TemplateTypeParameter::TemplateTypeParameter(Loc loc, Identifier *ident, Type *specType, + Type *defaultType) + : TemplateParameter(loc, ident) +{ + this->ident = ident; + this->specType = specType; + this->defaultType = defaultType; +} + +TemplateTypeParameter *TemplateTypeParameter::isTemplateTypeParameter() +{ + return this; +} + +TemplateParameter *TemplateTypeParameter::syntaxCopy() +{ + TemplateTypeParameter *tp = new TemplateTypeParameter(loc, ident, specType, defaultType); + if (tp->specType) + tp->specType = specType->syntaxCopy(); + if (defaultType) + tp->defaultType = defaultType->syntaxCopy(); + return tp; +} + +void TemplateTypeParameter::declareParameter(Scope *sc) +{ + //printf("TemplateTypeParameter::declareParameter('%s')\n", ident->toChars()); + TypeIdentifier *ti = new TypeIdentifier(loc, ident); + sparam = new AliasDeclaration(loc, ident, ti); + if (!sc->insert(sparam)) + error(loc, "parameter '%s' multiply defined", ident->toChars()); +} + +void TemplateTypeParameter::semantic(Scope *sc) +{ + //printf("TemplateTypeParameter::semantic('%s')\n", ident->toChars()); + if (specType) + { + specType = specType->semantic(loc, sc); + } +#if 0 // Don't do semantic() until instantiation + if (defaultType) + { + defaultType = defaultType->semantic(loc, sc); + } +#endif +} + +/**************************************** + * Determine if two TemplateParameters are the same + * as far as TemplateDeclaration overloading goes. + * Returns: + * 1 match + * 0 no match + */ + +int TemplateTypeParameter::overloadMatch(TemplateParameter *tp) +{ + TemplateTypeParameter *ttp = tp->isTemplateTypeParameter(); + + if (ttp) + { + if (specType != ttp->specType) + goto Lnomatch; + + if (specType && !specType->equals(ttp->specType)) + goto Lnomatch; + + return 1; // match + } + +Lnomatch: + return 0; +} + +/******************************************* + * Match to a particular TemplateParameter. + * Input: + * i i'th argument + * tiargs[] actual arguments to template instance + * parameters[] template parameters + * dedtypes[] deduced arguments to template instance + * *psparam set to symbol declared and initialized to dedtypes[i] + */ + +MATCH TemplateTypeParameter::matchArg(Scope *sc, Objects *tiargs, + size_t i, TemplateParameters *parameters, Objects *dedtypes, + Declaration **psparam) +{ + //printf("TemplateTypeParameter::matchArg()\n"); + Object *oarg; + MATCH m = MATCHexact; + Type *ta; + + if (i < tiargs->dim) + oarg = tiargs->tdata()[i]; + else + { // Get default argument instead + oarg = defaultArg(loc, sc); + if (!oarg) + { assert(i < dedtypes->dim); + // It might have already been deduced + oarg = dedtypes->tdata()[i]; + if (!oarg) + { + goto Lnomatch; + } + } + } + + ta = isType(oarg); + if (!ta) + { + //printf("%s %p %p %p\n", oarg->toChars(), isExpression(oarg), isDsymbol(oarg), isTuple(oarg)); + goto Lnomatch; + } + //printf("ta is %s\n", ta->toChars()); + + if (specType) + { + if (!ta || ta == tdummy) + goto Lnomatch; + + //printf("\tcalling deduceType(): ta is %s, specType is %s\n", ta->toChars(), specType->toChars()); + MATCH m2 = ta->deduceType(sc, specType, parameters, dedtypes); + if (m2 == MATCHnomatch) + { //printf("\tfailed deduceType\n"); + goto Lnomatch; + } + + if (m2 < m) + m = m2; + if (dedtypes->tdata()[i]) + ta = (Type *)dedtypes->tdata()[i]; + } + else + { + if (dedtypes->tdata()[i]) + { // Must match already deduced type + Type *t = (Type *)dedtypes->tdata()[i]; + + if (!t->equals(ta)) + { //printf("t = %s ta = %s\n", t->toChars(), ta->toChars()); + goto Lnomatch; + } + } + else + { + // So that matches with specializations are better + m = MATCHconvert; + } + } + dedtypes->tdata()[i] = ta; + + *psparam = new AliasDeclaration(loc, ident, ta); + //printf("\tm = %d\n", m); + return m; + +Lnomatch: + *psparam = NULL; + //printf("\tm = %d\n", MATCHnomatch); + return MATCHnomatch; +} + + +void TemplateTypeParameter::print(Object *oarg, Object *oded) +{ + printf(" %s\n", ident->toChars()); + + Type *t = isType(oarg); + Type *ta = isType(oded); + + assert(ta); + + if (specType) + printf("\tSpecialization: %s\n", specType->toChars()); + if (defaultType) + printf("\tDefault: %s\n", defaultType->toChars()); + printf("\tParameter: %s\n", t ? t->toChars() : "NULL"); + printf("\tDeduced Type: %s\n", ta->toChars()); +} + + +void TemplateTypeParameter::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(ident->toChars()); + if (specType) + { + buf->writestring(" : "); + specType->toCBuffer(buf, NULL, hgs); + } + if (defaultType) + { + buf->writestring(" = "); + defaultType->toCBuffer(buf, NULL, hgs); + } +} + + +void *TemplateTypeParameter::dummyArg() +{ Type *t; + + if (specType) + t = specType; + else + { // Use this for alias-parameter's too (?) + if (!tdummy) + tdummy = new TypeIdentifier(loc, ident); + t = tdummy; + } + return (void *)t; +} + + +Object *TemplateTypeParameter::specialization() +{ + return specType; +} + + +Object *TemplateTypeParameter::defaultArg(Loc loc, Scope *sc) +{ + Type *t; + + t = defaultType; + if (t) + { + t = t->syntaxCopy(); + t = t->semantic(loc, sc); + } + return t; +} + +/* ======================== TemplateThisParameter =========================== */ + +#if DMDV2 +// this-parameter + +TemplateThisParameter::TemplateThisParameter(Loc loc, Identifier *ident, + Type *specType, + Type *defaultType) + : TemplateTypeParameter(loc, ident, specType, defaultType) +{ +} + +TemplateThisParameter *TemplateThisParameter::isTemplateThisParameter() +{ + return this; +} + +TemplateParameter *TemplateThisParameter::syntaxCopy() +{ + TemplateThisParameter *tp = new TemplateThisParameter(loc, ident, specType, defaultType); + if (tp->specType) + tp->specType = specType->syntaxCopy(); + if (defaultType) + tp->defaultType = defaultType->syntaxCopy(); + return tp; +} + +void TemplateThisParameter::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("this "); + TemplateTypeParameter::toCBuffer(buf, hgs); +} +#endif + +/* ======================== TemplateAliasParameter ========================== */ + +// alias-parameter + +Dsymbol *TemplateAliasParameter::sdummy = NULL; + +TemplateAliasParameter::TemplateAliasParameter(Loc loc, Identifier *ident, + Type *specType, Object *specAlias, Object *defaultAlias) + : TemplateParameter(loc, ident) +{ + this->ident = ident; + this->specType = specType; + this->specAlias = specAlias; + this->defaultAlias = defaultAlias; +} + +TemplateAliasParameter *TemplateAliasParameter::isTemplateAliasParameter() +{ + return this; +} + +TemplateParameter *TemplateAliasParameter::syntaxCopy() +{ + TemplateAliasParameter *tp = new TemplateAliasParameter(loc, ident, specType, specAlias, defaultAlias); + if (tp->specType) + tp->specType = specType->syntaxCopy(); + tp->specAlias = objectSyntaxCopy(specAlias); + tp->defaultAlias = objectSyntaxCopy(defaultAlias); + return tp; +} + +void TemplateAliasParameter::declareParameter(Scope *sc) +{ + TypeIdentifier *ti = new TypeIdentifier(loc, ident); + sparam = new AliasDeclaration(loc, ident, ti); + if (!sc->insert(sparam)) + error(loc, "parameter '%s' multiply defined", ident->toChars()); +} + +Object *aliasParameterSemantic(Loc loc, Scope *sc, Object *o) +{ + if (o) + { + Expression *ea = isExpression(o); + Type *ta = isType(o); + if (ta) + { Dsymbol *s = ta->toDsymbol(sc); + if (s) + o = s; + else + o = ta->semantic(loc, sc); + } + else if (ea) + { + ea = ea->semantic(sc); + o = ea->optimize(WANTvalue | WANTinterpret); + } + } + return o; +} + +void TemplateAliasParameter::semantic(Scope *sc) +{ + if (specType) + { + specType = specType->semantic(loc, sc); + } + specAlias = aliasParameterSemantic(loc, sc, specAlias); +#if 0 // Don't do semantic() until instantiation + if (defaultAlias) + defaultAlias = defaultAlias->semantic(loc, sc); +#endif +} + +int TemplateAliasParameter::overloadMatch(TemplateParameter *tp) +{ + TemplateAliasParameter *tap = tp->isTemplateAliasParameter(); + + if (tap) + { + if (specAlias != tap->specAlias) + goto Lnomatch; + + return 1; // match + } + +Lnomatch: + return 0; +} + +MATCH TemplateAliasParameter::matchArg(Scope *sc, Objects *tiargs, + size_t i, TemplateParameters *parameters, Objects *dedtypes, + Declaration **psparam) +{ + Object *sa; + Object *oarg; + Expression *ea; + Dsymbol *s; + + //printf("TemplateAliasParameter::matchArg()\n"); + + if (i < tiargs->dim) + oarg = tiargs->tdata()[i]; + else + { // Get default argument instead + oarg = defaultArg(loc, sc); + if (!oarg) + { assert(i < dedtypes->dim); + // It might have already been deduced + oarg = dedtypes->tdata()[i]; + if (!oarg) + goto Lnomatch; + } + } + + sa = getDsymbol(oarg); + if (sa) + { + /* specType means the alias must be a declaration with a type + * that matches specType. + */ + if (specType) + { Declaration *d = ((Dsymbol *)sa)->isDeclaration(); + if (!d) + goto Lnomatch; + if (!d->type->equals(specType)) + goto Lnomatch; + } + } + else + { + sa = oarg; + ea = isExpression(oarg); + if (ea) + { if (specType) + { + if (!ea->type->equals(specType)) + goto Lnomatch; + } + } + else + goto Lnomatch; + } + + if (specAlias) + { + if (sa == sdummy) + goto Lnomatch; + if (sa != specAlias) + goto Lnomatch; + } + else if (dedtypes->tdata()[i]) + { // Must match already deduced symbol + Object *si = dedtypes->tdata()[i]; + + if (!sa || si != sa) + goto Lnomatch; + } + dedtypes->tdata()[i] = sa; + + s = isDsymbol(sa); + if (s) + *psparam = new AliasDeclaration(loc, ident, s); + else + { + assert(ea); + + // Declare manifest constant + Initializer *init = new ExpInitializer(loc, ea); + VarDeclaration *v = new VarDeclaration(loc, NULL, ident, init); + v->storage_class = STCmanifest; + v->semantic(sc); + *psparam = v; + } + return MATCHexact; + +Lnomatch: + *psparam = NULL; + //printf("\tm = %d\n", MATCHnomatch); + return MATCHnomatch; +} + + +void TemplateAliasParameter::print(Object *oarg, Object *oded) +{ + printf(" %s\n", ident->toChars()); + + Dsymbol *sa = isDsymbol(oded); + assert(sa); + + printf("\tParameter alias: %s\n", sa->toChars()); +} + +void TemplateAliasParameter::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("alias "); + if (specType) + { HdrGenState hgs1; + specType->toCBuffer(buf, ident, &hgs1); + } + else + buf->writestring(ident->toChars()); + if (specAlias) + { + buf->writestring(" : "); + ObjectToCBuffer(buf, hgs, specAlias); + } + if (defaultAlias) + { + buf->writestring(" = "); + ObjectToCBuffer(buf, hgs, defaultAlias); + } +} + + +void *TemplateAliasParameter::dummyArg() +{ Object *s; + + s = specAlias; + if (!s) + { + if (!sdummy) + sdummy = new Dsymbol(); + s = sdummy; + } + return (void*)s; +} + + +Object *TemplateAliasParameter::specialization() +{ + return specAlias; +} + + +Object *TemplateAliasParameter::defaultArg(Loc loc, Scope *sc) +{ + Object *da = defaultAlias; + Type *ta = isType(defaultAlias); + if (ta) + { + if (ta->ty == Tinstance) + { + // If the default arg is a template, instantiate for each type + da = ta->syntaxCopy(); + } + } + + Object *o = aliasParameterSemantic(loc, sc, da); + return o; +} + +/* ======================== TemplateValueParameter ========================== */ + +// value-parameter + +AA *TemplateValueParameter::edummies = NULL; + +TemplateValueParameter::TemplateValueParameter(Loc loc, Identifier *ident, Type *valType, + Expression *specValue, Expression *defaultValue) + : TemplateParameter(loc, ident) +{ + this->ident = ident; + this->valType = valType; + this->specValue = specValue; + this->defaultValue = defaultValue; +} + +TemplateValueParameter *TemplateValueParameter::isTemplateValueParameter() +{ + return this; +} + +TemplateParameter *TemplateValueParameter::syntaxCopy() +{ + TemplateValueParameter *tp = + new TemplateValueParameter(loc, ident, valType, specValue, defaultValue); + tp->valType = valType->syntaxCopy(); + if (specValue) + tp->specValue = specValue->syntaxCopy(); + if (defaultValue) + tp->defaultValue = defaultValue->syntaxCopy(); + return tp; +} + +void TemplateValueParameter::declareParameter(Scope *sc) +{ + VarDeclaration *v = new VarDeclaration(loc, valType, ident, NULL); + v->storage_class = STCtemplateparameter; + if (!sc->insert(v)) + error(loc, "parameter '%s' multiply defined", ident->toChars()); + sparam = v; +} + +void TemplateValueParameter::semantic(Scope *sc) +{ + sparam->semantic(sc); + valType = valType->semantic(loc, sc); + if (!(valType->isintegral() || valType->isfloating() || valType->isString()) && + valType->ty != Tident) + { + if (valType != Type::terror) + error(loc, "arithmetic/string type expected for value-parameter, not %s", valType->toChars()); + } + + if (specValue) + { Expression *e = specValue; + + e = e->semantic(sc); + e = e->implicitCastTo(sc, valType); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->op == TOKint64 || e->op == TOKfloat64 || + e->op == TOKcomplex80 || e->op == TOKnull || e->op == TOKstring) + specValue = e; + //e->toInteger(); + } + +#if 0 // defer semantic analysis to arg match + if (defaultValue) + { Expression *e = defaultValue; + + e = e->semantic(sc); + e = e->implicitCastTo(sc, valType); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->op == TOKint64) + defaultValue = e; + //e->toInteger(); + } +#endif +} + +int TemplateValueParameter::overloadMatch(TemplateParameter *tp) +{ + TemplateValueParameter *tvp = tp->isTemplateValueParameter(); + + if (tvp) + { + if (valType != tvp->valType) + goto Lnomatch; + + if (valType && !valType->equals(tvp->valType)) + goto Lnomatch; + + if (specValue != tvp->specValue) + goto Lnomatch; + + return 1; // match + } + +Lnomatch: + return 0; +} + + +MATCH TemplateValueParameter::matchArg(Scope *sc, Objects *tiargs, + size_t i, TemplateParameters *parameters, Objects *dedtypes, + Declaration **psparam) +{ + //printf("TemplateValueParameter::matchArg()\n"); + + Initializer *init; + Declaration *sparam; + MATCH m = MATCHexact; + Expression *ei; + Object *oarg; + + if (i < tiargs->dim) + oarg = tiargs->tdata()[i]; + else + { // Get default argument instead + oarg = defaultArg(loc, sc); + if (!oarg) + { assert(i < dedtypes->dim); + // It might have already been deduced + oarg = dedtypes->tdata()[i]; + if (!oarg) + goto Lnomatch; + } + } + + ei = isExpression(oarg); + Type *vt; + + if (!ei && oarg) + goto Lnomatch; + + if (ei && ei->op == TOKvar) + { // Resolve const variables that we had skipped earlier + ei = ei->optimize(WANTvalue | WANTinterpret); + } + + //printf("\tvalType: %s, ty = %d\n", valType->toChars(), valType->ty); + vt = valType->semantic(0, sc); + //printf("ei: %s, ei->type: %s\n", ei->toChars(), ei->type->toChars()); + //printf("vt = %s\n", vt->toChars()); + + if (ei->type) + { + m = (MATCH)ei->implicitConvTo(vt); + //printf("m: %d\n", m); + if (!m) + goto Lnomatch; + } + + if (specValue) + { + if (!ei || _aaGetRvalue(edummies, ei->type) == ei) + goto Lnomatch; + + Expression *e = specValue; + + e = e->semantic(sc); + e = e->implicitCastTo(sc, valType); + e = e->optimize(WANTvalue | WANTinterpret); + + ei = ei->syntaxCopy(); + ei = ei->semantic(sc); + ei = ei->implicitCastTo(sc, vt); + ei = ei->optimize(WANTvalue | WANTinterpret); + //printf("\tei: %s, %s\n", ei->toChars(), ei->type->toChars()); + //printf("\te : %s, %s\n", e->toChars(), e->type->toChars()); + if (!ei->equals(e)) + goto Lnomatch; + } + else + { + if (dedtypes->tdata()[i]) + { // Must match already deduced value + Expression *e = (Expression *)dedtypes->tdata()[i]; + + if (!ei || !ei->equals(e)) + goto Lnomatch; + } + else if (m != MATCHexact) + { + ei = ei->implicitCastTo(sc, vt); + ei = ei->optimize(WANTvalue | WANTinterpret); + } + } + dedtypes->tdata()[i] = ei; + + init = new ExpInitializer(loc, ei); + sparam = new VarDeclaration(loc, vt, ident, init); + sparam->storage_class = STCmanifest; + *psparam = sparam; + return m; + +Lnomatch: + //printf("\tno match\n"); + *psparam = NULL; + return MATCHnomatch; +} + + +void TemplateValueParameter::print(Object *oarg, Object *oded) +{ + printf(" %s\n", ident->toChars()); + + Expression *ea = isExpression(oded); + + if (specValue) + printf("\tSpecialization: %s\n", specValue->toChars()); + printf("\tParameter Value: %s\n", ea ? ea->toChars() : "NULL"); +} + + +void TemplateValueParameter::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + valType->toCBuffer(buf, ident, hgs); + if (specValue) + { + buf->writestring(" : "); + specValue->toCBuffer(buf, hgs); + } + if (defaultValue) + { + buf->writestring(" = "); + defaultValue->toCBuffer(buf, hgs); + } +} + + +void *TemplateValueParameter::dummyArg() +{ Expression *e; + + e = specValue; + if (!e) + { + // Create a dummy value + Expression **pe = (Expression **)_aaGet(&edummies, valType); + if (!*pe) + *pe = valType->defaultInit(); + e = *pe; + } + return (void *)e; +} + + +Object *TemplateValueParameter::specialization() +{ + return specValue; +} + + +Object *TemplateValueParameter::defaultArg(Loc loc, Scope *sc) +{ + Expression *e = defaultValue; + if (e) + { + e = e->syntaxCopy(); + e = e->semantic(sc); +#if DMDV2 + e = e->resolveLoc(loc, sc); +#endif + } + return e; +} + +/* ======================== TemplateTupleParameter ========================== */ + +// variadic-parameter + +TemplateTupleParameter::TemplateTupleParameter(Loc loc, Identifier *ident) + : TemplateParameter(loc, ident) +{ + this->ident = ident; +} + +TemplateTupleParameter *TemplateTupleParameter::isTemplateTupleParameter() +{ + return this; +} + +TemplateParameter *TemplateTupleParameter::syntaxCopy() +{ + TemplateTupleParameter *tp = new TemplateTupleParameter(loc, ident); + return tp; +} + +void TemplateTupleParameter::declareParameter(Scope *sc) +{ + TypeIdentifier *ti = new TypeIdentifier(loc, ident); + sparam = new AliasDeclaration(loc, ident, ti); + if (!sc->insert(sparam)) + error(loc, "parameter '%s' multiply defined", ident->toChars()); +} + +void TemplateTupleParameter::semantic(Scope *sc) +{ +} + +int TemplateTupleParameter::overloadMatch(TemplateParameter *tp) +{ + TemplateTupleParameter *tvp = tp->isTemplateTupleParameter(); + + if (tvp) + { + return 1; // match + } + + return 0; +} + +MATCH TemplateTupleParameter::matchArg(Scope *sc, Objects *tiargs, + size_t i, TemplateParameters *parameters, Objects *dedtypes, + Declaration **psparam) +{ + //printf("TemplateTupleParameter::matchArg()\n"); + + /* The rest of the actual arguments (tiargs[]) form the match + * for the variadic parameter. + */ + assert(i + 1 == dedtypes->dim); // must be the last one + Tuple *ovar; + + if (dedtypes->tdata()[i] && isTuple(dedtypes->tdata()[i])) + // It was already been deduced + ovar = isTuple(dedtypes->tdata()[i]); + else if (i + 1 == tiargs->dim && isTuple(tiargs->tdata()[i])) + ovar = isTuple(tiargs->tdata()[i]); + else + { + ovar = new Tuple(); + //printf("ovar = %p\n", ovar); + if (i < tiargs->dim) + { + //printf("i = %d, tiargs->dim = %d\n", i, tiargs->dim); + ovar->objects.setDim(tiargs->dim - i); + for (size_t j = 0; j < ovar->objects.dim; j++) + ovar->objects.tdata()[j] = tiargs->tdata()[i + j]; + } + } + *psparam = new TupleDeclaration(loc, ident, &ovar->objects); + dedtypes->tdata()[i] = ovar; + return MATCHexact; +} + + +void TemplateTupleParameter::print(Object *oarg, Object *oded) +{ + printf(" %s... [", ident->toChars()); + Tuple *v = isTuple(oded); + assert(v); + + //printf("|%d| ", v->objects.dim); + for (size_t i = 0; i < v->objects.dim; i++) + { + if (i) + printf(", "); + + Object *o = v->objects.tdata()[i]; + + Dsymbol *sa = isDsymbol(o); + if (sa) + printf("alias: %s", sa->toChars()); + + Type *ta = isType(o); + if (ta) + printf("type: %s", ta->toChars()); + + Expression *ea = isExpression(o); + if (ea) + printf("exp: %s", ea->toChars()); + + assert(!isTuple(o)); // no nested Tuple arguments + } + + printf("]\n"); +} + +void TemplateTupleParameter::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(ident->toChars()); + buf->writestring("..."); +} + + +void *TemplateTupleParameter::dummyArg() +{ + return NULL; +} + + +Object *TemplateTupleParameter::specialization() +{ + return NULL; +} + + +Object *TemplateTupleParameter::defaultArg(Loc loc, Scope *sc) +{ + return NULL; +} + +/* ======================== TemplateInstance ================================ */ + +TemplateInstance::TemplateInstance(Loc loc, Identifier *ident) + : ScopeDsymbol(NULL) +{ +#if LOG + printf("TemplateInstance(this = %p, ident = '%s')\n", this, ident ? ident->toChars() : "null"); +#endif + this->loc = loc; + this->name = ident; + this->tiargs = NULL; + this->tempdecl = NULL; + this->inst = NULL; + this->tinst = NULL; + this->argsym = NULL; + this->aliasdecl = NULL; + this->semanticRun = 0; + this->semantictiargsdone = 0; + this->withsym = NULL; + this->nest = 0; + this->havetempdecl = 0; + this->isnested = NULL; + this->errors = 0; + this->speculative = 0; +} + +/***************** + * This constructor is only called when we figured out which function + * template to instantiate. + */ + +TemplateInstance::TemplateInstance(Loc loc, TemplateDeclaration *td, Objects *tiargs) + : ScopeDsymbol(NULL) +{ +#if LOG + printf("TemplateInstance(this = %p, tempdecl = '%s')\n", this, td->toChars()); +#endif + this->loc = loc; + this->name = td->ident; + this->tiargs = tiargs; + this->tempdecl = td; + this->inst = NULL; + this->tinst = NULL; + this->argsym = NULL; + this->aliasdecl = NULL; + this->semanticRun = 0; + this->semantictiargsdone = 1; + this->withsym = NULL; + this->nest = 0; + this->havetempdecl = 1; + this->isnested = NULL; + this->errors = 0; + this->speculative = 0; + + assert((size_t)tempdecl->scope > 0x10000); +} + + +Objects *TemplateInstance::arraySyntaxCopy(Objects *objs) +{ + Objects *a = NULL; + if (objs) + { a = new Objects(); + a->setDim(objs->dim); + for (size_t i = 0; i < objs->dim; i++) + { + a->tdata()[i] = objectSyntaxCopy(objs->tdata()[i]); + } + } + return a; +} + +Dsymbol *TemplateInstance::syntaxCopy(Dsymbol *s) +{ + TemplateInstance *ti; + + if (s) + ti = (TemplateInstance *)s; + else + ti = new TemplateInstance(loc, name); + + ti->tiargs = arraySyntaxCopy(tiargs); + + ScopeDsymbol::syntaxCopy(ti); + return ti; +} + + +void TemplateInstance::semantic(Scope *sc) +{ + semantic(sc, NULL); +} + +void TemplateInstance::semantic(Scope *sc, Expressions *fargs) +{ + //printf("TemplateInstance::semantic('%s', this=%p, gag = %d, sc = %p)\n", toChars(), this, global.gag, sc); + if (global.errors && name != Id::AssociativeArray) + { + //printf("not instantiating %s due to %d errors\n", toChars(), global.errors); + if (!global.gag) + { + /* Trying to soldier on rarely generates useful messages + * at this point. + */ + fatal(); + } +// return; + } +#if LOG + printf("\n+TemplateInstance::semantic('%s', this=%p)\n", toChars(), this); +#endif + if (inst) // if semantic() was already run + { +#if LOG + printf("-TemplateInstance::semantic('%s', this=%p) already run\n", inst->toChars(), inst); +#endif + return; + } + + // get the enclosing template instance from the scope tinst + tinst = sc->tinst; + + if (semanticRun != 0) + { +#if LOG + printf("Recursive template expansion\n"); +#endif + error(loc, "recursive template expansion"); +// inst = this; + return; + } + semanticRun = 1; + +#if LOG + printf("\tdo semantic\n"); +#endif + if (havetempdecl) + { + assert((size_t)tempdecl->scope > 0x10000); + // Deduce tdtypes + tdtypes.setDim(tempdecl->parameters->dim); + if (!tempdecl->matchWithInstance(this, &tdtypes, fargs, 2)) + { + error("incompatible arguments for template instantiation"); + inst = this; + return; + } + } + else + { + /* Run semantic on each argument, place results in tiargs[] + * (if we havetempdecl, then tiargs is already evaluated) + */ + semanticTiargs(sc); + if (arrayObjectIsError(tiargs)) + { inst = this; + //printf("error return %p, %d\n", tempdecl, global.errors); + return; // error recovery + } + + tempdecl = findTemplateDeclaration(sc); + if (tempdecl) + tempdecl = findBestMatch(sc, fargs); + if (!tempdecl || global.errors) + { inst = this; + //printf("error return %p, %d\n", tempdecl, global.errors); + return; // error recovery + } + } + + // If tempdecl is a mixin, disallow it + if (tempdecl->ismixin) + error("mixin templates are not regular templates"); + + hasNestedArgs(tiargs); + + /* See if there is an existing TemplateInstantiation that already + * implements the typeargs. If so, just refer to that one instead. + */ + + for (size_t i = 0; i < tempdecl->instances.dim; i++) + { + TemplateInstance *ti = tempdecl->instances.tdata()[i]; +#if LOG + printf("\t%s: checking for match with instance %d (%p): '%s'\n", toChars(), i, ti, ti->toChars()); +#endif + assert(tdtypes.dim == ti->tdtypes.dim); + + // Nesting must match + if (isnested != ti->isnested) + { + //printf("test2 isnested %s ti->isnested %s\n", isnested ? isnested->toChars() : "", ti->isnested ? ti->isnested->toChars() : ""); + continue; + } +#if 0 + if (isnested && sc->parent != ti->parent) + continue; +#endif + if (!arrayObjectMatch(&tdtypes, &ti->tdtypes, tempdecl, sc)) + goto L1; + + /* Template functions may have different instantiations based on + * "auto ref" parameters. + */ + if (fargs) + { + FuncDeclaration *fd = ti->toAlias()->isFuncDeclaration(); + if (fd) + { + Parameters *fparameters = fd->getParameters(NULL); + size_t nfparams = Parameter::dim(fparameters); // Num function parameters + for (size_t j = 0; j < nfparams && j < fargs->dim; j++) + { Parameter *fparam = Parameter::getNth(fparameters, j); + Expression *farg = fargs->tdata()[j]; + if (fparam->storageClass & STCauto) // if "auto ref" + { + if (farg->isLvalue()) + { if (!(fparam->storageClass & STCref)) + goto L1; // auto ref's don't match + } + else + { if (fparam->storageClass & STCref) + goto L1; // auto ref's don't match + } + } + } + } + } + + // It's a match + inst = ti; + parent = ti->parent; + + // If both this and the previous instantiation were speculative, + // use the number of errors that happened last time. + if (inst->speculative && global.gag) + { + global.errors += inst->errors; + global.gaggedErrors += inst->errors; + } + + // If the first instantiation was speculative, but this is not: + if (inst->speculative && !global.gag) + { + // If the first instantiation had failed, re-run semantic, + // so that error messages are shown. + if (inst->errors) + goto L1; + // It had succeeded, mark it is a non-speculative instantiation, + // and reuse it. + inst->speculative = 0; + } + +#if LOG + printf("\tit's a match with instance %p\n", inst); +#endif + return; + + L1: + ; + } + + /* So, we need to implement 'this' instance. + */ +#if LOG + printf("\timplement template instance %s '%s'\n", tempdecl->parent->toChars(), toChars()); + printf("\ttempdecl %s\n", tempdecl->toChars()); +#endif + unsigned errorsave = global.errors; + inst = this; + // Mark as speculative if we are instantiated from inside is(typeof()) + if (global.gag && sc->intypeof) + speculative = 1; + + int tempdecl_instance_idx = tempdecl->instances.dim; + tempdecl->instances.push(this); + parent = tempdecl->parent; + //printf("parent = '%s'\n", parent->kind()); + + ident = genIdent(tiargs); // need an identifier for name mangling purposes. + +#if 1 + if (isnested) + parent = isnested; +#endif + //printf("parent = '%s'\n", parent->kind()); + + // Add 'this' to the enclosing scope's members[] so the semantic routines + // will get called on the instance members. Store the place we added it to + // in target_symbol_list(_idx) so we can remove it later if we encounter + // an error. +#if 1 + int dosemantic3 = 0; + Dsymbols *target_symbol_list = NULL; + int target_symbol_list_idx; + + if (!sc->parameterSpecialization) + { Dsymbols *a; + + Scope *scx = sc; +#if 0 + for (scx = sc; scx; scx = scx->enclosing) + if (scx->scopesym) + break; +#endif + + //if (scx && scx->scopesym) printf("3: scx is %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars()); + if (scx && scx->scopesym && + scx->scopesym->members && !scx->scopesym->isTemplateMixin() +#if 0 // removed because it bloated compile times + /* The problem is if A imports B, and B imports A, and both A + * and B instantiate the same template, does the compilation of A + * or the compilation of B do the actual instantiation? + * + * see bugzilla 2500. + */ + && !scx->module->selfImports() +#endif + ) + { + //printf("\t1: adding to %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars()); + a = scx->scopesym->members; + } + else + { Module *m = sc->module->importedFrom; + //printf("\t2: adding to module %s instead of module %s\n", m->toChars(), sc->module->toChars()); + a = m->members; + if (m->semanticRun >= 3) + { + dosemantic3 = 1; + } + } + for (int i = 0; 1; i++) + { + if (i == a->dim) + { + target_symbol_list = a; + target_symbol_list_idx = i; + a->push(this); + break; + } + if (this == a->tdata()[i]) // if already in Array + break; + } + } +#endif + + // Copy the syntax trees from the TemplateDeclaration + members = Dsymbol::arraySyntaxCopy(tempdecl->members); + + // Create our own scope for the template parameters + Scope *scope = tempdecl->scope; + if (!tempdecl->semanticRun) + { + error("template instantiation %s forward references template declaration %s\n", toChars(), tempdecl->toChars()); + return; + } + +#if LOG + printf("\tcreate scope for template parameters '%s'\n", toChars()); +#endif + argsym = new ScopeDsymbol(); + argsym->parent = scope->parent; + scope = scope->push(argsym); +// scope->stc = 0; + + // Declare each template parameter as an alias for the argument type + Scope *paramscope = scope->push(); + paramscope->stc = 0; + declareParameters(paramscope); + paramscope->pop(); + + // Add members of template instance to template instance symbol table +// parent = scope->scopesym; + symtab = new DsymbolTable(); + int memnum = 0; + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; +#if LOG + printf("\t[%d] adding member '%s' %p kind %s to '%s', memnum = %d\n", i, s->toChars(), s, s->kind(), this->toChars(), memnum); +#endif + memnum |= s->addMember(scope, this, memnum); + } +#if LOG + printf("adding members done\n"); +#endif + + /* See if there is only one member of template instance, and that + * member has the same name as the template instance. + * If so, this template instance becomes an alias for that member. + */ + //printf("members->dim = %d\n", members->dim); + if (members->dim) + { + Dsymbol *s; + if (Dsymbol::oneMembers(members, &s, tempdecl->ident) && s) + { + //printf("s->kind = '%s'\n", s->kind()); + //s->print(); + //printf("'%s', '%s'\n", s->ident->toChars(), tempdecl->ident->toChars()); + //printf("setting aliasdecl\n"); + aliasdecl = new AliasDeclaration(loc, s->ident, s); + } + } + + /* If function template declaration + */ + if (fargs && aliasdecl) + { + FuncDeclaration *fd = aliasdecl->toAlias()->isFuncDeclaration(); + if (fd) + { + /* Transmit fargs to type so that TypeFunction::semantic() can + * resolve any "auto ref" storage classes. + */ + TypeFunction *tf = (TypeFunction *)fd->type; + if (tf && tf->ty == Tfunction) + tf->fargs = fargs; + } + } + + // Do semantic() analysis on template instance members +#if LOG + printf("\tdo semantic() on template instance members '%s'\n", toChars()); +#endif + Scope *sc2; + sc2 = scope->push(this); + //printf("isnested = %d, sc->parent = %s\n", isnested, sc->parent->toChars()); + sc2->parent = /*isnested ? sc->parent :*/ this; + sc2->tinst = this; + +#if WINDOWS_SEH + __try + { +#endif + static int nest; + //printf("%d\n", nest); + if (++nest > 500) + { + global.gag = 0; // ensure error message gets printed + error("recursive expansion"); + fatal(); + } + + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = (*members)[i]; + s->setScope(sc2); + } + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + //printf("\t[%d] semantic on '%s' %p kind %s in '%s'\n", i, s->toChars(), s, s->kind(), this->toChars()); + //printf("test: isnested = %d, sc2->parent = %s\n", isnested, sc2->parent->toChars()); +// if (isnested) +// s->parent = sc->parent; + //printf("test3: isnested = %d, s->parent = %s\n", isnested, s->parent->toChars()); + s->semantic(sc2); + //printf("test4: isnested = %d, s->parent = %s\n", isnested, s->parent->toChars()); + sc2->module->runDeferredSemantic(); + } + --nest; +#if WINDOWS_SEH + } + __except (__ehfilter(GetExceptionInformation())) + { + global.gag = 0; // ensure error message gets printed + error("recursive expansion"); + fatal(); + } +#endif + + /* If any of the instantiation members didn't get semantic() run + * on them due to forward references, we cannot run semantic2() + * or semantic3() yet. + */ + for (size_t i = 0; i < Module::deferred.dim; i++) + { Dsymbol *sd = Module::deferred.tdata()[i]; + + if (sd->parent == this) + { + //printf("deferred %s %s\n", sd->parent->toChars(), sd->toChars()); + AggregateDeclaration *ad = sd->isAggregateDeclaration(); + if (ad) + ad->deferred = this; + goto Laftersemantic; + } + } + + /* ConditionalDeclaration may introduce eponymous declaration, + * so we should find it once again after semantic. + */ + if (members->dim) + { + Dsymbol *s; + if (Dsymbol::oneMembers(members, &s, tempdecl->ident) && s) + { + if (!aliasdecl || aliasdecl->toAlias() != s) + { + //printf("s->kind = '%s'\n", s->kind()); + //s->print(); + //printf("'%s', '%s'\n", s->ident->toChars(), tempdecl->ident->toChars()); + //printf("setting aliasdecl 2\n"); + aliasdecl = new AliasDeclaration(loc, s->ident, s); + } + } + else if (aliasdecl) + aliasdecl = NULL; + } + + /* The problem is when to parse the initializer for a variable. + * Perhaps VarDeclaration::semantic() should do it like it does + * for initializers inside a function. + */ +// if (sc->parent->isFuncDeclaration()) + + /* BUG 782: this has problems if the classes this depends on + * are forward referenced. Find a way to defer semantic() + * on this template. + */ + semantic2(sc2); + + if (sc->func || dosemantic3) + { +#if WINDOWS_SEH + __try + { +#endif + static int nest; + if (++nest > 300) + { + global.gag = 0; // ensure error message gets printed + error("recursive expansion"); + fatal(); + } + semantic3(sc2); + --nest; +#if WINDOWS_SEH + } + __except (__ehfilter(GetExceptionInformation())) + { + global.gag = 0; // ensure error message gets printed + error("recursive expansion"); + fatal(); + } +#endif + } + + Laftersemantic: + sc2->pop(); + + scope->pop(); + + // Give additional context info if error occurred during instantiation + if (global.errors != errorsave) + { + error(loc, "error instantiating"); + if (tinst) + { tinst->printInstantiationTrace(); + } + errors = 1; + if (global.gag) + { + // Errors are gagged, so remove the template instance from the + // instance/symbol lists we added it to and reset our state to + // finish clean and so we can try to instantiate it again later + // (see bugzilla 4302 and 6602). + tempdecl->instances.remove(tempdecl_instance_idx); + if (target_symbol_list) + { + // Because we added 'this' in the last position above, we + // should be able to remove it without messing other indices up. + assert(target_symbol_list->tdata()[target_symbol_list_idx] == this); + target_symbol_list->remove(target_symbol_list_idx); + } + semanticRun = 0; + inst = NULL; + } + } + +#if LOG + printf("-TemplateInstance::semantic('%s', this=%p)\n", toChars(), this); +#endif +} + + +void TemplateInstance::semanticTiargs(Scope *sc) +{ + //printf("+TemplateInstance::semanticTiargs() %s\n", toChars()); + if (semantictiargsdone) + return; + semantictiargsdone = 1; + semanticTiargs(loc, sc, tiargs, 0); +} + +/********************************** + * Input: + * flags 1: replace const variables with their initializers + */ + +void TemplateInstance::semanticTiargs(Loc loc, Scope *sc, Objects *tiargs, int flags) +{ + // Run semantic on each argument, place results in tiargs[] + //printf("+TemplateInstance::semanticTiargs()\n"); + if (!tiargs) + return; + for (size_t j = 0; j < tiargs->dim; j++) + { + Object *o = tiargs->tdata()[j]; + Type *ta = isType(o); + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + + //printf("1: tiargs->tdata()[%d] = %p, %p, %p, ea=%p, ta=%p\n", j, o, isDsymbol(o), isTuple(o), ea, ta); + if (ta) + { + //printf("type %s\n", ta->toChars()); + // It might really be an Expression or an Alias + ta->resolve(loc, sc, &ea, &ta, &sa); + if (ea) + { + ea = ea->semantic(sc); + /* This test is to skip substituting a const var with + * its initializer. The problem is the initializer won't + * match with an 'alias' parameter. Instead, do the + * const substitution in TemplateValueParameter::matchArg(). + */ + if (flags & 1) // only used by __traits, must not interpret the args + ea = ea->optimize(WANTvalue); + else if (ea->op != TOKvar) + ea = ea->optimize(WANTvalue | WANTinterpret); + tiargs->tdata()[j] = ea; + } + else if (sa) + { + Ldsym: + tiargs->tdata()[j] = sa; + TupleDeclaration *d = sa->toAlias()->isTupleDeclaration(); + if (d) + { + size_t dim = d->objects->dim; + tiargs->remove(j); + tiargs->insert(j, d->objects); + j--; + } + } + else if (ta) + { + Ltype: + if (ta->ty == Ttuple) + { // Expand tuple + TypeTuple *tt = (TypeTuple *)ta; + size_t dim = tt->arguments->dim; + tiargs->remove(j); + if (dim) + { tiargs->reserve(dim); + for (size_t i = 0; i < dim; i++) + { Parameter *arg = tt->arguments->tdata()[i]; + tiargs->insert(j + i, arg->type); + } + } + j--; + } + else + tiargs->tdata()[j] = ta; + } + else + { + assert(global.errors); + tiargs->tdata()[j] = Type::terror; + } + } + else if (ea) + { + if (!ea) + { assert(global.errors); + ea = new ErrorExp(); + } + assert(ea); + ea = ea->semantic(sc); + if (flags & 1) // only used by __traits, must not interpret the args + ea = ea->optimize(WANTvalue); + else if (ea->op != TOKvar && ea->op != TOKtuple) + ea = ea->optimize(WANTvalue | WANTinterpret); + tiargs->tdata()[j] = ea; + if (ea->op == TOKtype) + { ta = ea->type; + goto Ltype; + } + if (ea->op == TOKimport) + { sa = ((ScopeExp *)ea)->sds; + goto Ldsym; + } + if (ea->op == TOKtuple) + { // Expand tuple + TupleExp *te = (TupleExp *)ea; + size_t dim = te->exps->dim; + tiargs->remove(j); + if (dim) + { tiargs->reserve(dim); + for (size_t i = 0; i < dim; i++) + tiargs->insert(j + i, te->exps->tdata()[i]); + } + j--; + } + } + else if (sa) + { + TemplateDeclaration *td = sa->isTemplateDeclaration(); + if (td && !td->semanticRun && td->literal) + td->semantic(sc); + } + else + { + assert(0); + } + //printf("1: tiargs->tdata()[%d] = %p\n", j, tiargs->tdata()[j]); + } +#if 0 + printf("-TemplateInstance::semanticTiargs()\n"); + for (size_t j = 0; j < tiargs->dim; j++) + { + Object *o = tiargs->tdata()[j]; + Type *ta = isType(o); + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + Tuple *va = isTuple(o); + + printf("\ttiargs[%d] = ta %p, ea %p, sa %p, va %p\n", j, ta, ea, sa, va); + } +#endif +} + +/********************************************** + * Find template declaration corresponding to template instance. + */ + +TemplateDeclaration *TemplateInstance::findTemplateDeclaration(Scope *sc) +{ + //printf("TemplateInstance::findTemplateDeclaration() %s\n", toChars()); + if (!tempdecl) + { + /* Given: + * foo!( ... ) + * figure out which TemplateDeclaration foo refers to. + */ + Dsymbol *s; + Dsymbol *scopesym; + Identifier *id; + + id = name; + s = sc->search(loc, id, &scopesym); + if (!s) + { + s = sc->search_correct(id); + if (s) + error("template '%s' is not defined, did you mean %s?", id->toChars(), s->toChars()); + else + error("template '%s' is not defined", id->toChars()); + return NULL; + } + + /* If an OverloadSet, look for a unique member that is a template declaration + */ + OverloadSet *os = s->isOverloadSet(); + if (os) + { s = NULL; + for (size_t i = 0; i < os->a.dim; i++) + { Dsymbol *s2 = os->a.tdata()[i]; + if (s2->isTemplateDeclaration()) + { + if (s) + error("ambiguous template declaration %s and %s", s->toPrettyChars(), s2->toPrettyChars()); + s = s2; + } + } + if (!s) + { error("template '%s' is not defined", id->toChars()); + return NULL; + } + } + +#if LOG + printf("It's an instance of '%s' kind '%s'\n", s->toChars(), s->kind()); + if (s->parent) + printf("s->parent = '%s'\n", s->parent->toChars()); +#endif + withsym = scopesym->isWithScopeSymbol(); + + /* We might have found an alias within a template when + * we really want the template. + */ + TemplateInstance *ti; + if (s->parent && + (ti = s->parent->isTemplateInstance()) != NULL) + { + if (ti->tempdecl && ti->tempdecl->ident == id) + { + /* This is so that one can refer to the enclosing + * template, even if it has the same name as a member + * of the template, if it has a !(arguments) + */ + tempdecl = ti->tempdecl; + if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's + tempdecl = tempdecl->overroot; // then get the start + s = tempdecl; + } + } + + s = s->toAlias(); + + /* It should be a TemplateDeclaration, not some other symbol + */ + tempdecl = s->isTemplateDeclaration(); + if (!tempdecl) + { + if (!s->parent && global.errors) + return NULL; + if (!s->parent && s->getType()) + { Dsymbol *s2 = s->getType()->toDsymbol(sc); + if (!s2) + { + error("%s is not a template declaration, it is a %s", id->toChars(), s->kind()); + return NULL; + } + s = s2; + } +#ifdef DEBUG + //if (!s->parent) printf("s = %s %s\n", s->kind(), s->toChars()); +#endif + //assert(s->parent); + TemplateInstance *ti = s->parent ? s->parent->isTemplateInstance() : NULL; + if (ti && + (ti->name == id || + ti->toAlias()->ident == id) + && + ti->tempdecl) + { + /* This is so that one can refer to the enclosing + * template, even if it has the same name as a member + * of the template, if it has a !(arguments) + */ + tempdecl = ti->tempdecl; + if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's + tempdecl = tempdecl->overroot; // then get the start + } + else + { + error("%s is not a template declaration, it is a %s", id->toChars(), s->kind()); + return NULL; + } + } + } + else + assert(tempdecl->isTemplateDeclaration()); + return tempdecl; +} + +TemplateDeclaration *TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs) +{ + /* Since there can be multiple TemplateDeclaration's with the same + * name, look for the best match. + */ + TemplateDeclaration *td_ambig = NULL; + TemplateDeclaration *td_best = NULL; + MATCH m_best = MATCHnomatch; + Objects dedtypes; + +#if LOG + printf("TemplateInstance::findBestMatch()\n"); +#endif + // First look for forward references + for (TemplateDeclaration *td = tempdecl; td; td = td->overnext) + { + if (!td->semanticRun) + { + if (td->scope) + { // Try to fix forward reference + td->semantic(td->scope); + } + if (!td->semanticRun) + { + error("%s forward references template declaration %s\n", toChars(), td->toChars()); + return NULL; + } + } + } + + for (TemplateDeclaration *td = tempdecl; td; td = td->overnext) + { + MATCH m; + +//if (tiargs->dim) printf("2: tiargs->dim = %d, data[0] = %p\n", tiargs->dim, tiargs->tdata()[0]); + + // If more arguments than parameters, + // then this is no match. + if (td->parameters->dim < tiargs->dim) + { + if (!td->isVariadic()) + continue; + } + + dedtypes.setDim(td->parameters->dim); + dedtypes.zero(); + assert(td->semanticRun); + m = td->matchWithInstance(this, &dedtypes, fargs, 0); + //printf("matchWithInstance = %d\n", m); + if (!m) // no match at all + continue; + + if (m < m_best) + goto Ltd_best; + if (m > m_best) + goto Ltd; + + { + // Disambiguate by picking the most specialized TemplateDeclaration + MATCH c1 = td->leastAsSpecialized(td_best, fargs); + MATCH c2 = td_best->leastAsSpecialized(td, fargs); + //printf("c1 = %d, c2 = %d\n", c1, c2); + + if (c1 > c2) + goto Ltd; + else if (c1 < c2) + goto Ltd_best; + else + goto Lambig; + } + + Lambig: // td_best and td are ambiguous + td_ambig = td; + continue; + + Ltd_best: // td_best is the best match so far + td_ambig = NULL; + continue; + + Ltd: // td is the new best match + td_ambig = NULL; + td_best = td; + m_best = m; + tdtypes.setDim(dedtypes.dim); + memcpy(tdtypes.tdata(), dedtypes.tdata(), tdtypes.dim * sizeof(void *)); + continue; + } + + if (!td_best) + { + if (tempdecl && !tempdecl->overnext) + // Only one template, so we can give better error message + error("%s does not match template declaration %s", toChars(), tempdecl->toChars()); + else + error("%s does not match any template declaration", toChars()); + return NULL; + } + if (td_ambig) + { + error("%s matches more than one template declaration, %s(%d):%s and %s(%d):%s", + toChars(), + td_best->loc.filename, td_best->loc.linnum, td_best->toChars(), + td_ambig->loc.filename, td_ambig->loc.linnum, td_ambig->toChars()); + } + + /* The best match is td_best + */ + tempdecl = td_best; + +#if 0 + /* Cast any value arguments to be same type as value parameter + */ + for (size_t i = 0; i < tiargs->dim; i++) + { Object *o = tiargs->tdata()[i]; + Expression *ea = isExpression(o); // value argument + TemplateParameter *tp = tempdecl->parameters->tdata()[i]; + assert(tp); + TemplateValueParameter *tvp = tp->isTemplateValueParameter(); + if (tvp) + { + assert(ea); + ea = ea->castTo(tvp->valType); + ea = ea->optimize(WANTvalue | WANTinterpret); + tiargs->tdata()[i] = (Object *)ea; + } + } +#endif + +#if LOG + printf("\tIt's a match with template declaration '%s'\n", tempdecl->toChars()); +#endif + return tempdecl; +} + + +/***************************************** + * Determines if a TemplateInstance will need a nested + * generation of the TemplateDeclaration. + */ + +int TemplateInstance::hasNestedArgs(Objects *args) +{ int nested = 0; + //printf("TemplateInstance::hasNestedArgs('%s')\n", tempdecl->ident->toChars()); + + /* A nested instance happens when an argument references a local + * symbol that is on the stack. + */ + for (size_t i = 0; i < args->dim; i++) + { Object *o = args->tdata()[i]; + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + Tuple *va = isTuple(o); + if (ea) + { + if (ea->op == TOKvar) + { + sa = ((VarExp *)ea)->var; + goto Lsa; + } + if (ea->op == TOKfunction) + { + sa = ((FuncExp *)ea)->fd; + goto Lsa; + } + } + else if (sa) + { + Lsa: + TemplateDeclaration *td = sa->isTemplateDeclaration(); + Declaration *d = sa->isDeclaration(); + if ((td && td->literal) || + (d && !d->isDataseg() && +#if DMDV2 + !(d->storage_class & STCmanifest) && +#endif + (!d->isFuncDeclaration() || d->isFuncDeclaration()->isNested()) && + !isTemplateMixin() + )) + { + // if module level template + if (tempdecl->toParent()->isModule()) + { Dsymbol *dparent = sa->toParent(); + if (!isnested) + isnested = dparent; + else if (isnested != dparent) + { + /* Select the more deeply nested of the two. + * Error if one is not nested inside the other. + */ + for (Dsymbol *p = isnested; p; p = p->parent) + { + if (p == dparent) + goto L1; // isnested is most nested + } + for (Dsymbol *p = dparent; p; p = p->parent) + { + if (p == isnested) + { isnested = dparent; + goto L1; // dparent is most nested + } + } + error("%s is nested in both %s and %s", + toChars(), isnested->toChars(), dparent->toChars()); + } + L1: + //printf("\tnested inside %s\n", isnested->toChars()); + nested |= 1; + } + else + error("cannot use local '%s' as parameter to non-global template %s", sa->toChars(), tempdecl->toChars()); + } + } + else if (va) + { + nested |= hasNestedArgs(&va->objects); + } + } + return nested; +} + +/**************************************** + * This instance needs an identifier for name mangling purposes. + * Create one by taking the template declaration name and adding + * the type signature for it. + */ + +Identifier *TemplateInstance::genIdent(Objects *args) +{ OutBuffer buf; + + //printf("TemplateInstance::genIdent('%s')\n", tempdecl->ident->toChars()); + char *id = tempdecl->ident->toChars(); + buf.printf("__T%zu%s", strlen(id), id); + for (size_t i = 0; i < args->dim; i++) + { Object *o = args->tdata()[i]; + Type *ta = isType(o); + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + Tuple *va = isTuple(o); + //printf("\to [%d] %p ta %p ea %p sa %p va %p\n", i, o, ta, ea, sa, va); + if (ta) + { + buf.writeByte('T'); + if (ta->deco) + buf.writestring(ta->deco); + else + { +#ifdef DEBUG + printf("ta = %d, %s\n", ta->ty, ta->toChars()); +#endif + assert(global.errors); + } + } + else if (ea) + { + // Don't interpret it yet, it might actually be an alias + ea = ea->optimize(WANTvalue); + if (ea->op == TOKvar) + { + sa = ((VarExp *)ea)->var; + ea = NULL; + goto Lsa; + } + if (ea->op == TOKthis) + { + sa = ((ThisExp *)ea)->var; + ea = NULL; + goto Lsa; + } + if (ea->op == TOKfunction) + { + sa = ((FuncExp *)ea)->fd; + ea = NULL; + goto Lsa; + } + buf.writeByte('V'); + if (ea->op == TOKtuple) + { ea->error("tuple is not a valid template value argument"); + continue; + } + // Now that we know it is not an alias, we MUST obtain a value + ea = ea->optimize(WANTvalue | WANTinterpret); + if (ea->op == TOKerror) + continue; +#if 1 + /* Use deco that matches what it would be for a function parameter + */ + buf.writestring(ea->type->deco); +#else + // Use type of parameter, not type of argument + TemplateParameter *tp = tempdecl->parameters->tdata()[i]; + assert(tp); + TemplateValueParameter *tvp = tp->isTemplateValueParameter(); + assert(tvp); + buf.writestring(tvp->valType->deco); +#endif + ea->toMangleBuffer(&buf); + } + else if (sa) + { + Lsa: + buf.writeByte('S'); + Declaration *d = sa->isDeclaration(); + if (d && (!d->type || !d->type->deco)) + { error("forward reference of %s", d->toChars()); + continue; + } +#if 0 + VarDeclaration *v = sa->isVarDeclaration(); + if (v && v->storage_class & STCmanifest) + { ExpInitializer *ei = v->init->isExpInitializer(); + if (ei) + { + ea = ei->exp; + goto Lea; + } + } +#endif + const char *p = sa->mangle(); + + /* Bugzilla 3043: if the first character of p is a digit this + * causes ambiguity issues because the digits of the two numbers are adjacent. + * Current demanglers resolve this by trying various places to separate the + * numbers until one gets a successful demangle. + * Unfortunately, fixing this ambiguity will break existing binary + * compatibility and the demanglers, so we'll leave it as is. + */ + buf.printf("%zu%s", strlen(p), p); + } + else if (va) + { + assert(i + 1 == args->dim); // must be last one + args = &va->objects; + i = -1; + } + else + assert(0); + } + buf.writeByte('Z'); + id = buf.toChars(); + //buf.data = NULL; // we can free the string after call to idPool() + //printf("\tgenIdent = %s\n", id); + return Lexer::idPool(id); +} + + +/**************************************************** + * Declare parameters of template instance, initialize them with the + * template instance arguments. + */ + +void TemplateInstance::declareParameters(Scope *sc) +{ + //printf("TemplateInstance::declareParameters()\n"); + for (size_t i = 0; i < tdtypes.dim; i++) + { + TemplateParameter *tp = tempdecl->parameters->tdata()[i]; + //Object *o = tiargs->tdata()[i]; + Object *o = tdtypes.tdata()[i]; // initializer for tp + + //printf("\ttdtypes[%d] = %p\n", i, o); + tempdecl->declareParameter(sc, tp, o); + } +} + +/***************************************************** + * Determine if template instance is really a template function, + * and that template function needs to infer types from the function + * arguments. + */ + +int TemplateInstance::needsTypeInference(Scope *sc) +{ + //printf("TemplateInstance::needsTypeInference() %s\n", toChars()); + if (!tempdecl) + tempdecl = findTemplateDeclaration(sc); + int multipleMatches = FALSE; + for (TemplateDeclaration *td = tempdecl; td; td = td->overnext) + { + /* If any of the overloaded template declarations need inference, + * then return TRUE + */ + FuncDeclaration *fd; + if (!td->onemember || + (fd = td->onemember->toAlias()->isFuncDeclaration()) == NULL || + fd->type->ty != Tfunction) + { + /* Not a template function, therefore type inference is not possible. + */ + //printf("false\n"); + return FALSE; + } + + for (size_t i = 0; i < td->parameters->dim; i++) + if (td->parameters->tdata()[i]->isTemplateThisParameter()) + return TRUE; + + /* Determine if the instance arguments, tiargs, are all that is necessary + * to instantiate the template. + */ + TemplateTupleParameter *tp = td->isVariadic(); + //printf("tp = %p, td->parameters->dim = %d, tiargs->dim = %d\n", tp, td->parameters->dim, tiargs->dim); + TypeFunction *fdtype = (TypeFunction *)fd->type; + if (Parameter::dim(fdtype->parameters) && + ((tp && td->parameters->dim > 1) || tiargs->dim < td->parameters->dim)) + return TRUE; + /* If there is more than one function template which matches, we may + * need type inference (see Bugzilla 4430) + */ + if (td != tempdecl) + multipleMatches = TRUE; + } + //printf("false\n"); + return multipleMatches; +} + +void TemplateInstance::semantic2(Scope *sc) +{ int i; + + if (semanticRun >= 2) + return; + semanticRun = 2; +#if LOG + printf("+TemplateInstance::semantic2('%s')\n", toChars()); +#endif + if (!errors && members) + { + sc = tempdecl->scope; + assert(sc); + sc = sc->push(argsym); + sc = sc->push(this); + sc->tinst = this; + for (i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; +#if LOG +printf("\tmember '%s', kind = '%s'\n", s->toChars(), s->kind()); +#endif + s->semantic2(sc); + } + sc = sc->pop(); + sc->pop(); + } +#if LOG + printf("-TemplateInstance::semantic2('%s')\n", toChars()); +#endif +} + +void TemplateInstance::semantic3(Scope *sc) +{ +#if LOG + printf("TemplateInstance::semantic3('%s'), semanticRun = %d\n", toChars(), semanticRun); +#endif +//if (toChars()[0] == 'D') *(char*)0=0; + if (semanticRun >= 3) + return; + semanticRun = 3; + if (!errors && members) + { + sc = tempdecl->scope; + sc = sc->push(argsym); + sc = sc->push(this); + sc->tinst = this; + int oldgag = global.gag; + int olderrors = global.errors; + /* If this is a speculative instantiation, gag errors. + * Future optimisation: If the results are actually needed, errors + * would already be gagged, so we don't really need to run semantic + * on the members. + */ + if (speculative && !oldgag) + olderrors = global.startGagging(); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic3(sc); + if (speculative && global.errors != olderrors) + break; + } + if (speculative && !oldgag) + { // If errors occurred, this instantiation failed + errors += global.errors - olderrors; + global.endGagging(olderrors); + } + sc = sc->pop(); + sc->pop(); + } +} + +/************************************** + * Given an error instantiating the TemplateInstance, + * give the nested TemplateInstance instantiations that got + * us here. Those are a list threaded into the nested scopes. + */ +void TemplateInstance::printInstantiationTrace() +{ + if (global.gag) + return; + + const unsigned max_shown = 6; + const char format[] = "instantiated from here: %s"; + + // determine instantiation depth and number of recursive instantiations + int n_instantiations = 1; + int n_totalrecursions = 0; + for (TemplateInstance *cur = this; cur; cur = cur->tinst) + { + ++n_instantiations; + // If two instantiations use the same declaration, they are recursive. + // (this works even if they are instantiated from different places in the + // same template). + // In principle, we could also check for multiple-template recursion, but it's + // probably not worthwhile. + if (cur->tinst && cur->tempdecl && cur->tinst->tempdecl + && cur->tempdecl->loc.equals(cur->tinst->tempdecl->loc)) + ++n_totalrecursions; + } + + // show full trace only if it's short or verbose is on + if (n_instantiations <= max_shown || global.params.verbose) + { + for (TemplateInstance *cur = this; cur; cur = cur->tinst) + { + errorSupplemental(cur->loc, format, cur->toChars()); + } + } + else if (n_instantiations - n_totalrecursions <= max_shown) + { + // By collapsing recursive instantiations into a single line, + // we can stay under the limit. + int recursionDepth=0; + for (TemplateInstance *cur = this; cur; cur = cur->tinst) + { + if (cur->tinst && cur->tempdecl && cur->tinst->tempdecl + && cur->tempdecl->loc.equals(cur->tinst->tempdecl->loc)) + { + ++recursionDepth; + } + else + { + if (recursionDepth) + errorSupplemental(cur->loc, "%d recursive instantiations from here: %s", recursionDepth+2, cur->toChars()); + else + errorSupplemental(cur->loc, format, cur->toChars()); + recursionDepth = 0; + } + } + } + else + { + // Even after collapsing the recursions, the depth is too deep. + // Just display the first few and last few instantiations. + unsigned i = 0; + for (TemplateInstance *cur = this; cur; cur = cur->tinst) + { + if (i == max_shown / 2) + errorSupplemental(cur->loc, "... (%d instantiations, -v to show) ...", n_instantiations - max_shown); + + if (i < max_shown / 2 || + i >= n_instantiations - max_shown + max_shown / 2) + errorSupplemental(cur->loc, format, cur->toChars()); + ++i; + } + } +} + +void TemplateInstance::toObjFile(int multiobj) +{ +#if LOG + printf("TemplateInstance::toObjFile('%s', this = %p)\n", toChars(), this); +#endif + if (!errors && members) + { + if (multiobj) + // Append to list of object files to be written later + obj_append(this); + else + { + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->toObjFile(multiobj); + } + } + } +} + +void TemplateInstance::inlineScan() +{ +#if LOG + printf("TemplateInstance::inlineScan('%s')\n", toChars()); +#endif + if (!errors && members) + { + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->inlineScan(); + } + } +} + +void TemplateInstance::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + int i; + + Identifier *id = name; + buf->writestring(id->toChars()); + buf->writestring("!("); + if (nest) + buf->writestring("..."); + else + { + nest++; + Objects *args = tiargs; + for (i = 0; i < args->dim; i++) + { + if (i) + buf->writeByte(','); + Object *oarg = args->tdata()[i]; + ObjectToCBuffer(buf, hgs, oarg); + } + nest--; + } + buf->writeByte(')'); +} + + +Dsymbol *TemplateInstance::toAlias() +{ +#if LOG + printf("TemplateInstance::toAlias()\n"); +#endif + if (!inst) + { error("cannot resolve forward reference"); + errors = 1; + return this; + } + + if (inst != this) + return inst->toAlias(); + + if (aliasdecl) + { + return aliasdecl->toAlias(); + } + + return inst; +} + +AliasDeclaration *TemplateInstance::isAliasDeclaration() +{ + return aliasdecl; +} + +const char *TemplateInstance::kind() +{ + return "template instance"; +} + +int TemplateInstance::oneMember(Dsymbol **ps, Identifier *ident) +{ + *ps = NULL; + return TRUE; +} + +char *TemplateInstance::toChars() +{ + OutBuffer buf; + HdrGenState hgs; + char *s; + + toCBuffer(&buf, &hgs); + s = buf.toChars(); + buf.data = NULL; + return s; +} + +/* ======================== TemplateMixin ================================ */ + +TemplateMixin::TemplateMixin(Loc loc, Identifier *ident, Type *tqual, + Identifiers *idents, Objects *tiargs) + : TemplateInstance(loc, idents->tdata()[idents->dim - 1]) +{ + //printf("TemplateMixin(ident = '%s')\n", ident ? ident->toChars() : ""); + this->ident = ident; + this->tqual = tqual; + this->idents = idents; + this->tiargs = tiargs ? tiargs : new Objects(); +} + +Dsymbol *TemplateMixin::syntaxCopy(Dsymbol *s) +{ TemplateMixin *tm; + + Identifiers *ids = new Identifiers(); + ids->setDim(idents->dim); + for (size_t i = 0; i < idents->dim; i++) + { // Matches TypeQualified::syntaxCopyHelper() + Identifier *id = idents->tdata()[i]; + if (id->dyncast() == DYNCAST_DSYMBOL) + { + TemplateInstance *ti = (TemplateInstance *)id; + + ti = (TemplateInstance *)ti->syntaxCopy(NULL); + id = (Identifier *)ti; + } + ids->tdata()[i] = id; + } + + tm = new TemplateMixin(loc, ident, + (Type *)(tqual ? tqual->syntaxCopy() : NULL), + ids, tiargs); + TemplateInstance::syntaxCopy(tm); + return tm; +} + +void TemplateMixin::semantic(Scope *sc) +{ +#if LOG + printf("+TemplateMixin::semantic('%s', this=%p)\n", toChars(), this); + fflush(stdout); +#endif + if (semanticRun) + { + // This for when a class/struct contains mixin members, and + // is done over because of forward references + if (parent && toParent()->isAggregateDeclaration()) + semanticRun = 1; // do over + else + { +#if LOG + printf("\tsemantic done\n"); +#endif + return; + } + } + if (!semanticRun) + semanticRun = 1; +#if LOG + printf("\tdo semantic\n"); +#endif + util_progress(); + + Scope *scx = NULL; + if (scope) + { sc = scope; + scx = scope; // save so we don't make redundant copies + scope = NULL; + } + + // Follow qualifications to find the TemplateDeclaration + if (!tempdecl) + { Dsymbol *s; + size_t i; + Identifier *id; + + if (tqual) + { s = tqual->toDsymbol(sc); + i = 0; + } + else + { + i = 1; + id = idents->tdata()[0]; + switch (id->dyncast()) + { + case DYNCAST_IDENTIFIER: + s = sc->search(loc, id, NULL); + break; + + case DYNCAST_DSYMBOL: + { + TemplateInstance *ti = (TemplateInstance *)id; + ti->semantic(sc); + s = ti; + break; + } + default: + assert(0); + } + } + + for (; i < idents->dim; i++) + { + if (!s) + break; + id = idents->tdata()[i]; + s = s->searchX(loc, sc, id); + } + if (!s) + { + error("is not defined"); + inst = this; + return; + } + tempdecl = s->toAlias()->isTemplateDeclaration(); + if (!tempdecl) + { + error("%s isn't a template", s->toChars()); + inst = this; + return; + } + } + + // Look for forward reference + assert(tempdecl); + for (TemplateDeclaration *td = tempdecl; td; td = td->overnext) + { + if (!td->semanticRun) + { + /* Cannot handle forward references if mixin is a struct member, + * because addField must happen during struct's semantic, not + * during the mixin semantic. + * runDeferred will re-run mixin's semantic outside of the struct's + * semantic. + */ + semanticRun = 0; + AggregateDeclaration *ad = toParent()->isAggregateDeclaration(); + if (ad) + ad->sizeok = 2; + else + { + // Forward reference + //printf("forward reference - deferring\n"); + scope = scx ? scx : new Scope(*sc); + scope->setNoFree(); + scope->module->addDeferredSemantic(this); + } + return; + } + } + + // Run semantic on each argument, place results in tiargs[] + semanticTiargs(sc); + if (errors || arrayObjectIsError(tiargs)) + return; + + tempdecl = findBestMatch(sc, NULL); + if (!tempdecl) + { inst = this; + return; // error recovery + } + + if (!ident) + ident = genIdent(tiargs); + + inst = this; + parent = sc->parent; + + /* Detect recursive mixin instantiations. + */ + for (Dsymbol *s = parent; s; s = s->parent) + { + //printf("\ts = '%s'\n", s->toChars()); + TemplateMixin *tm = s->isTemplateMixin(); + if (!tm || tempdecl != tm->tempdecl) + continue; + + /* Different argument list lengths happen with variadic args + */ + if (tiargs->dim != tm->tiargs->dim) + continue; + + for (size_t i = 0; i < tiargs->dim; i++) + { Object *o = tiargs->tdata()[i]; + Type *ta = isType(o); + Expression *ea = isExpression(o); + Dsymbol *sa = isDsymbol(o); + Object *tmo = tm->tiargs->tdata()[i]; + if (ta) + { + Type *tmta = isType(tmo); + if (!tmta) + goto Lcontinue; + if (!ta->equals(tmta)) + goto Lcontinue; + } + else if (ea) + { Expression *tme = isExpression(tmo); + if (!tme || !ea->equals(tme)) + goto Lcontinue; + } + else if (sa) + { + Dsymbol *tmsa = isDsymbol(tmo); + if (sa != tmsa) + goto Lcontinue; + } + else + assert(0); + } + error("recursive mixin instantiation"); + return; + + Lcontinue: + continue; + } + + // Copy the syntax trees from the TemplateDeclaration + members = Dsymbol::arraySyntaxCopy(tempdecl->members); + if (!members) + return; + + symtab = new DsymbolTable(); + + for (Scope *sce = sc; 1; sce = sce->enclosing) + { + ScopeDsymbol *sds = (ScopeDsymbol *)sce->scopesym; + if (sds) + { + sds->importScope(this, PROTpublic); + break; + } + } + +#if LOG + printf("\tcreate scope for template parameters '%s'\n", toChars()); +#endif + Scope *scy = sc; + scy = sc->push(this); + scy->parent = this; + + argsym = new ScopeDsymbol(); + argsym->parent = scy->parent; + Scope *argscope = scy->push(argsym); + + unsigned errorsave = global.errors; + + // Declare each template parameter as an alias for the argument type + declareParameters(argscope); + + // Add members to enclosing scope, as well as this scope + for (unsigned i = 0; i < members->dim; i++) + { Dsymbol *s; + + s = members->tdata()[i]; + s->addMember(argscope, this, i); + //sc->insert(s); + //printf("sc->parent = %p, sc->scopesym = %p\n", sc->parent, sc->scopesym); + //printf("s->parent = %s\n", s->parent->toChars()); + } + + // Do semantic() analysis on template instance members +#if LOG + printf("\tdo semantic() on template instance members '%s'\n", toChars()); +#endif + Scope *sc2; + sc2 = argscope->push(this); + sc2->offset = sc->offset; + + static int nest; + //printf("%d\n", nest); + if (++nest > 500) + { + global.gag = 0; // ensure error message gets printed + error("recursive expansion"); + fatal(); + } + + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic(sc2); + } + + nest--; + + sc->offset = sc2->offset; + + /* The problem is when to parse the initializer for a variable. + * Perhaps VarDeclaration::semantic() should do it like it does + * for initializers inside a function. + */ +// if (sc->parent->isFuncDeclaration()) + + semantic2(sc2); + + if (sc->func) + { + semantic3(sc2); + } + + // Give additional context info if error occurred during instantiation + if (global.errors != errorsave) + { + error("error instantiating"); + } + + sc2->pop(); + + argscope->pop(); + +// if (!isAnonymous()) + { + scy->pop(); + } +#if LOG + printf("-TemplateMixin::semantic('%s', this=%p)\n", toChars(), this); +#endif +} + +void TemplateMixin::semantic2(Scope *sc) +{ + if (semanticRun >= 2) + return; + semanticRun = 2; +#if LOG + printf("+TemplateMixin::semantic2('%s')\n", toChars()); +#endif + if (members) + { + assert(sc); + sc = sc->push(argsym); + sc = sc->push(this); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; +#if LOG + printf("\tmember '%s', kind = '%s'\n", s->toChars(), s->kind()); +#endif + s->semantic2(sc); + } + sc = sc->pop(); + sc->pop(); + } +#if LOG + printf("-TemplateMixin::semantic2('%s')\n", toChars()); +#endif +} + +void TemplateMixin::semantic3(Scope *sc) +{ + if (semanticRun >= 3) + return; + semanticRun = 3; +#if LOG + printf("TemplateMixin::semantic3('%s')\n", toChars()); +#endif + if (members) + { + sc = sc->push(argsym); + sc = sc->push(this); + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = members->tdata()[i]; + s->semantic3(sc); + } + sc = sc->pop(); + sc->pop(); + } +} + +void TemplateMixin::inlineScan() +{ + TemplateInstance::inlineScan(); +} + +const char *TemplateMixin::kind() +{ + return "mixin"; +} + +int TemplateMixin::oneMember(Dsymbol **ps, Identifier *ident) +{ + return Dsymbol::oneMember(ps, ident); +} + +int TemplateMixin::hasPointers() +{ + //printf("TemplateMixin::hasPointers() %s\n", toChars()); + + if (members) + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *s = (*members)[i]; + //printf(" s = %s %s\n", s->kind(), s->toChars()); + if (s->hasPointers()) + { + return 1; + } + } + return 0; +} + +char *TemplateMixin::toChars() +{ + OutBuffer buf; + HdrGenState hgs; + char *s; + + TemplateInstance::toCBuffer(&buf, &hgs); + s = buf.toChars(); + buf.data = NULL; + return s; +} + +void TemplateMixin::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("mixin "); + + for (size_t i = 0; i < idents->dim; i++) + { Identifier *id = idents->tdata()[i]; + + if (i) + buf->writeByte('.'); + buf->writestring(id->toChars()); + } + buf->writestring("!("); + if (tiargs) + { + for (size_t i = 0; i < tiargs->dim; i++) + { if (i) + buf->writebyte(','); + Object *oarg = tiargs->tdata()[i]; + Type *t = isType(oarg); + Expression *e = isExpression(oarg); + Dsymbol *s = isDsymbol(oarg); + if (t) + t->toCBuffer(buf, NULL, hgs); + else if (e) + e->toCBuffer(buf, hgs); + else if (s) + { + char *p = s->ident ? s->ident->toChars() : s->toChars(); + buf->writestring(p); + } + else if (!oarg) + { + buf->writestring("NULL"); + } + else + { + assert(0); + } + } + } + buf->writebyte(')'); + if (ident) + { + buf->writebyte(' '); + buf->writestring(ident->toChars()); + } + buf->writebyte(';'); + buf->writenl(); +} + + +void TemplateMixin::toObjFile(int multiobj) +{ + //printf("TemplateMixin::toObjFile('%s')\n", toChars()); + TemplateInstance::toObjFile(multiobj); +} + diff --git a/template.h b/template.h new file mode 100644 index 00000000..60bcd1b1 --- /dev/null +++ b/template.h @@ -0,0 +1,375 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_TEMPLATE_H +#define DMD_TEMPLATE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "root.h" +#include "arraytypes.h" +#include "dsymbol.h" + + +struct OutBuffer; +struct Identifier; +struct TemplateInstance; +struct TemplateParameter; +struct TemplateTypeParameter; +struct TemplateThisParameter; +struct TemplateValueParameter; +struct TemplateAliasParameter; +struct TemplateTupleParameter; +struct Type; +struct TypeTypeof; +struct Scope; +struct Expression; +struct AliasDeclaration; +struct FuncDeclaration; +struct HdrGenState; +enum MATCH; + +struct Tuple : Object +{ + Objects objects; + + int dyncast() { return DYNCAST_TUPLE; } // kludge for template.isType() +}; + + +struct TemplateDeclaration : ScopeDsymbol +{ + TemplateParameters *parameters; // array of TemplateParameter's + + TemplateParameters *origParameters; // originals for Ddoc + Expression *constraint; + TemplateInstances instances; // array of TemplateInstance's + + TemplateDeclaration *overnext; // next overloaded TemplateDeclaration + TemplateDeclaration *overroot; // first in overnext list + + int semanticRun; // 1 semantic() run + + Dsymbol *onemember; // if !=NULL then one member of this template + + int literal; // this template declaration is a literal + int ismixin; // template declaration is only to be used as a mixin + + struct Previous + { Previous *prev; + Scope *sc; + Objects *dedargs; + }; + Previous *previous; // threaded list of previous instantiation attempts on stack + + TemplateDeclaration(Loc loc, Identifier *id, TemplateParameters *parameters, + Expression *constraint, Dsymbols *decldefs, int ismixin); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc); + int overloadInsert(Dsymbol *s); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + bool hasStaticCtorOrDtor(); + const char *kind(); + char *toChars(); + + void emitComment(Scope *sc); + void toJsonBuffer(OutBuffer *buf); +// void toDocBuffer(OutBuffer *buf); + + MATCH matchWithInstance(TemplateInstance *ti, Objects *atypes, Expressions *fargs, int flag); + MATCH leastAsSpecialized(TemplateDeclaration *td2, Expressions *fargs); + + MATCH deduceFunctionTemplateMatch(Scope *sc, Loc loc, Objects *targsi, Expression *ethis, Expressions *fargs, Objects *dedargs); + FuncDeclaration *deduceFunctionTemplate(Scope *sc, Loc loc, Objects *targsi, Expression *ethis, Expressions *fargs, int flags = 0); + void declareParameter(Scope *sc, TemplateParameter *tp, Object *o); + FuncDeclaration *doHeaderInstantiation(Scope *sc, Objects *tdargs, Expressions *fargs); + + TemplateDeclaration *isTemplateDeclaration() { return this; } + + TemplateTupleParameter *isVariadic(); + int isOverloadable(); + + void makeParamNamesVisibleInConstraint(Scope *paramscope, Expressions *fargs); +}; + +struct TemplateParameter +{ + /* For type-parameter: + * template Foo(ident) // specType is set to NULL + * template Foo(ident : specType) + * For value-parameter: + * template Foo(valType ident) // specValue is set to NULL + * template Foo(valType ident : specValue) + * For alias-parameter: + * template Foo(alias ident) + * For this-parameter: + * template Foo(this ident) + */ + + Loc loc; + Identifier *ident; + + Declaration *sparam; + + TemplateParameter(Loc loc, Identifier *ident); + + virtual TemplateTypeParameter *isTemplateTypeParameter(); + virtual TemplateValueParameter *isTemplateValueParameter(); + virtual TemplateAliasParameter *isTemplateAliasParameter(); +#if DMDV2 + virtual TemplateThisParameter *isTemplateThisParameter(); +#endif + virtual TemplateTupleParameter *isTemplateTupleParameter(); + + virtual TemplateParameter *syntaxCopy() = 0; + virtual void declareParameter(Scope *sc) = 0; + virtual void semantic(Scope *) = 0; + virtual void print(Object *oarg, Object *oded) = 0; + virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs) = 0; + virtual Object *specialization() = 0; + virtual Object *defaultArg(Loc loc, Scope *sc) = 0; + + /* If TemplateParameter's match as far as overloading goes. + */ + virtual int overloadMatch(TemplateParameter *) = 0; + + /* Match actual argument against parameter. + */ + virtual MATCH matchArg(Scope *sc, Objects *tiargs, size_t i, TemplateParameters *parameters, Objects *dedtypes, Declaration **psparam) = 0; + + /* Create dummy argument based on parameter. + */ + virtual void *dummyArg() = 0; +}; + +struct TemplateTypeParameter : TemplateParameter +{ + /* Syntax: + * ident : specType = defaultType + */ + Type *specType; // type parameter: if !=NULL, this is the type specialization + Type *defaultType; + + static Type *tdummy; + + TemplateTypeParameter(Loc loc, Identifier *ident, Type *specType, Type *defaultType); + + TemplateTypeParameter *isTemplateTypeParameter(); + TemplateParameter *syntaxCopy(); + void declareParameter(Scope *sc); + void semantic(Scope *); + void print(Object *oarg, Object *oded); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Object *specialization(); + Object *defaultArg(Loc loc, Scope *sc); + int overloadMatch(TemplateParameter *); + MATCH matchArg(Scope *sc, Objects *tiargs, size_t i, TemplateParameters *parameters, Objects *dedtypes, Declaration **psparam); + void *dummyArg(); +}; + +#if DMDV2 +struct TemplateThisParameter : TemplateTypeParameter +{ + /* Syntax: + * this ident : specType = defaultType + */ + Type *specType; // type parameter: if !=NULL, this is the type specialization + Type *defaultType; + + TemplateThisParameter(Loc loc, Identifier *ident, Type *specType, Type *defaultType); + + TemplateThisParameter *isTemplateThisParameter(); + TemplateParameter *syntaxCopy(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); +}; +#endif + +struct TemplateValueParameter : TemplateParameter +{ + /* Syntax: + * valType ident : specValue = defaultValue + */ + + Type *valType; + Expression *specValue; + Expression *defaultValue; + + static AA *edummies; + + TemplateValueParameter(Loc loc, Identifier *ident, Type *valType, Expression *specValue, Expression *defaultValue); + + TemplateValueParameter *isTemplateValueParameter(); + TemplateParameter *syntaxCopy(); + void declareParameter(Scope *sc); + void semantic(Scope *); + void print(Object *oarg, Object *oded); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Object *specialization(); + Object *defaultArg(Loc loc, Scope *sc); + int overloadMatch(TemplateParameter *); + MATCH matchArg(Scope *sc, Objects *tiargs, size_t i, TemplateParameters *parameters, Objects *dedtypes, Declaration **psparam); + void *dummyArg(); +}; + +struct TemplateAliasParameter : TemplateParameter +{ + /* Syntax: + * specType ident : specAlias = defaultAlias + */ + + Type *specType; + Object *specAlias; + Object *defaultAlias; + + static Dsymbol *sdummy; + + TemplateAliasParameter(Loc loc, Identifier *ident, Type *specType, Object *specAlias, Object *defaultAlias); + + TemplateAliasParameter *isTemplateAliasParameter(); + TemplateParameter *syntaxCopy(); + void declareParameter(Scope *sc); + void semantic(Scope *); + void print(Object *oarg, Object *oded); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Object *specialization(); + Object *defaultArg(Loc loc, Scope *sc); + int overloadMatch(TemplateParameter *); + MATCH matchArg(Scope *sc, Objects *tiargs, size_t i, TemplateParameters *parameters, Objects *dedtypes, Declaration **psparam); + void *dummyArg(); +}; + +struct TemplateTupleParameter : TemplateParameter +{ + /* Syntax: + * ident ... + */ + + TemplateTupleParameter(Loc loc, Identifier *ident); + + TemplateTupleParameter *isTemplateTupleParameter(); + TemplateParameter *syntaxCopy(); + void declareParameter(Scope *sc); + void semantic(Scope *); + void print(Object *oarg, Object *oded); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Object *specialization(); + Object *defaultArg(Loc loc, Scope *sc); + int overloadMatch(TemplateParameter *); + MATCH matchArg(Scope *sc, Objects *tiargs, size_t i, TemplateParameters *parameters, Objects *dedtypes, Declaration **psparam); + void *dummyArg(); +}; + +struct TemplateInstance : ScopeDsymbol +{ + /* Given: + * foo!(args) => + * name = foo + * tiargs = args + */ + Identifier *name; + //Identifiers idents; + Objects *tiargs; // Array of Types/Expressions of template + // instance arguments [int*, char, 10*10] + + Objects tdtypes; // Array of Types/Expressions corresponding + // to TemplateDeclaration.parameters + // [int, char, 100] + + TemplateDeclaration *tempdecl; // referenced by foo.bar.abc + TemplateInstance *inst; // refer to existing instance + TemplateInstance *tinst; // enclosing template instance + ScopeDsymbol *argsym; // argument symbol table + AliasDeclaration *aliasdecl; // !=NULL if instance is an alias for its + // sole member + WithScopeSymbol *withsym; // if a member of a with statement + int semanticRun; // has semantic() been done? + int semantictiargsdone; // has semanticTiargs() been done? + int nest; // for recursion detection + int havetempdecl; // 1 if used second constructor + Dsymbol *isnested; // if referencing local symbols, this is the context + int errors; // 1 if compiled with errors + int speculative; // 1 if only instantiated with errors gagged +#ifdef IN_GCC + /* On some targets, it is necessary to know whether a symbol + will be emitted in the output or not before the symbol + is used. This can be different from getModule(). */ + Module * objFileModule; +#endif + + TemplateInstance(Loc loc, Identifier *temp_id); + TemplateInstance(Loc loc, TemplateDeclaration *tempdecl, Objects *tiargs); + static Objects *arraySyntaxCopy(Objects *objs); + Dsymbol *syntaxCopy(Dsymbol *); + void semantic(Scope *sc, Expressions *fargs); + void semantic(Scope *sc); + void semantic2(Scope *sc); + void semantic3(Scope *sc); + void inlineScan(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + Dsymbol *toAlias(); // resolve real symbol + const char *kind(); + int oneMember(Dsymbol **ps, Identifier *ident); + int needsTypeInference(Scope *sc); + char *toChars(); + char *mangle(); + void printInstantiationTrace(); + + void toObjFile(int multiobj); // compile to .obj file + + // Internal + static void semanticTiargs(Loc loc, Scope *sc, Objects *tiargs, int flags); + void semanticTiargs(Scope *sc); + TemplateDeclaration *findTemplateDeclaration(Scope *sc); + TemplateDeclaration *findBestMatch(Scope *sc, Expressions *fargs); + void declareParameters(Scope *sc); + int hasNestedArgs(Objects *tiargs); + Identifier *genIdent(Objects *args); + + TemplateInstance *isTemplateInstance() { return this; } + AliasDeclaration *isAliasDeclaration(); +}; + +struct TemplateMixin : TemplateInstance +{ + Identifiers *idents; + Type *tqual; + + TemplateMixin(Loc loc, Identifier *ident, Type *tqual, Identifiers *idents, Objects *tiargs); + Dsymbol *syntaxCopy(Dsymbol *s); + void semantic(Scope *sc); + void semantic2(Scope *sc); + void semantic3(Scope *sc); + void inlineScan(); + const char *kind(); + int oneMember(Dsymbol **ps, Identifier *ident); + int hasPointers(); + char *toChars(); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + + void toObjFile(int multiobj); // compile to .obj file + + TemplateMixin *isTemplateMixin() { return this; } +}; + +Expression *isExpression(Object *o); +Dsymbol *isDsymbol(Object *o); +Type *isType(Object *o); +Tuple *isTuple(Object *o); +int arrayObjectIsError(Objects *args); +int isError(Object *o); +Type *getType(Object *o); +Dsymbol *getDsymbol(Object *o); + +void ObjectToCBuffer(OutBuffer *buf, HdrGenState *hgs, Object *oarg); +Object *objectSyntaxCopy(Object *o); + +#endif /* DMD_TEMPLATE_H */ diff --git a/tk.c b/tk.c new file mode 100644 index 00000000..8989b90b --- /dev/null +++ b/tk.c @@ -0,0 +1,30 @@ + +// Copyright (c) 1999-2002 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#include +#include +#include + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +#include "mem.h" +#include "filespec.c" + +#if 0 +#define malloc ph_malloc +#define calloc(x,y) ph_calloc((x) * (y)) +#define realloc ph_realloc +#define free ph_free +#endif + +#if !MEM_DEBUG +#define MEM_NOMEMCOUNT 1 +#define MEM_NONEW 1 +#endif +#include "mem.c" +#include "list.c" +#include "vec.c" diff --git a/tk/filespec.c b/tk/filespec.c new file mode 100644 index 00000000..7fc4d454 --- /dev/null +++ b/tk/filespec.c @@ -0,0 +1,424 @@ +/*_ filespec.c Mon Jul 3 1989 Modified by: Walter Bright */ +/* Copyright (C) 1986-1987 by Northwest Software */ +/* All Rights Reserved */ +/* Written by Walter Bright */ + +/* Package with which to manipulate filespecs */ + +#include +#include "filespec.h" + +#ifndef MEM_H +#include "mem.h" +#endif + +#ifndef VAX11C +#include +#endif + +#if BSDUNIX +#include +#endif + +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#include +#include +#endif + +#if M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#include +#include +#endif + +#ifndef assert +#include +#endif + +/* Macro to determine if char is a path or drive delimiter */ +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#define ispathdelim(c) ((c) == '\\' || (c) == ':' || (c) == '/') +#else +#ifdef VMS +#define ispathdelim(c) ((c)==':' || (c)=='[' || (c)==']' ) +#else +#ifdef MPW +#define ispathdelim(c) ((c) == ':') +#else +#define ispathdelim(c) ((c) == '/') +#endif /* MPW */ +#endif /* VMS */ +#endif + +/**********************/ + +char * filespecaddpath(const char *path,const char *filename) +{ register char *filespec; + register unsigned pathlen; + + if (!path || (pathlen = strlen(path)) == 0) + filespec = mem_strdup(filename); + else + { + filespec = (char *) mem_malloc(pathlen + 1 + strlen(filename) + 1); + if (filespec) + { strcpy(filespec,path); +#if MSDOS || __OS2__ || __NT__ || _WIN32 + if (!ispathdelim(filespec[pathlen - 1])) + strcat(filespec,"\\"); +#else +#if VMS +#else +#if MPW + if (!ispathdelim(filespec[pathlen - 1])) + strcat(filespec,":"); +#else + if (!ispathdelim(filespec[pathlen - 1])) + strcat(filespec,"/"); +#endif /* MPW */ +#endif /* VMS */ +#endif + strcat(filespec,filename); + } + } + return filespec; +} + +#ifndef MPW +/**********************/ +char * filespecrootpath(char *filespec) +{ +#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +#define DIRCHAR '/' +#endif +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#define DIRCHAR '\\' +#endif +#ifdef MPW +#define DIRCHAR ':' +#endif + + char *cwd, *cwd_t; + char *p, *p2; + + if (!filespec) + return filespec; +#if MSDOS || __OS2__ || __NT__ || _WIN32 + /* if already absolute (with \ or drive:) ... */ + if (*filespec == DIRCHAR || (isalpha((unsigned char)*filespec) && *(filespec+1) == ':')) + return filespec; /* ... return input string */ +#else + if (*filespec == DIRCHAR) /* already absolute ... */ + return filespec; /* ... return input string */ +#endif + + /* get current working directory path */ +#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + cwd_t = (char *)getcwd(NULL, 256); +#endif +#if MSDOS || __OS2__ || __NT__ || _WIN32 + char cwd_d[132]; + if (getcwd(cwd_d, sizeof(cwd_d))) + cwd_t = cwd_d; + else + cwd_t = NULL; +#endif + + if (cwd_t == NULL) + { + mem_free(filespec); + return NULL; /* error - path too long (more than 256 chars !)*/ + } + cwd = mem_strdup(cwd_t); /* convert cwd to mem package */ +#if MSDOS + assert(strlen(cwd) > 0); + if (cwd[strlen(cwd) - 1] == DIRCHAR) + cwd[strlen(cwd) - 1] = '\0'; +#endif +#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + free(cwd_t); +#endif + p = filespec; + while (p != NULL) + { + p2 = (char *)strchr(p, DIRCHAR); + if (p2 != NULL) + { + *p2 = '\0'; + if (strcmp(p, "..") == 0) /* move up cwd */ + /* remove last directory from cwd */ + *((char *)strrchr(cwd, DIRCHAR)) = '\0'; + else if (strcmp(p, ".") != 0) /* not current directory */ + { + cwd_t = cwd; + cwd = (char *)mem_calloc(strlen(cwd_t) + 1 + strlen(p) + 1); +#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + sprintf(cwd, "%s/%s", cwd_t, p); /* add relative directory */ +#endif +#if MSDOS || __OS2__ || __NT__ || _WIN32 + sprintf(cwd, "%s\\%s", cwd_t, p); /* add relative directory */ +#endif + mem_free(cwd_t); + } + /* else if ".", then ignore - it means current directory */ + *p2 = DIRCHAR; + p2++; + } + else if (strcmp(p,"..") == 0) /* move up cwd */ + { + /* remove last directory from cwd */ + *((char *)strrchr(cwd, DIRCHAR)) = '\0'; + } + else if (strcmp(p,".") != 0) /* no more subdirectories ... */ + { /* ... save remaining string */ + cwd_t = cwd; + cwd = (char *)mem_calloc(strlen(cwd_t) + 1 + strlen(p) + 1); +#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + sprintf(cwd, "%s/%s", cwd_t, p); /* add relative directory */ +#endif +#if MSDOS || __OS2__ || __NT__ || _WIN32 + sprintf(cwd, "%s\\%s", cwd_t, p); /* add relative directory */ +#endif + mem_free(cwd_t); + } + p = p2; + } + mem_free(filespec); + + return cwd; +#ifdef VMS + assert(0); +#endif +} +#endif + +/**********************/ + +char * filespecdotext(const char *filespec) +{ register const char *p; + register int len; + + if ((p = filespec) != NULL) + { p += (len = strlen(p)); + while (1) + { if (*p == '.') + break; + if (p <= filespec || ispathdelim(*p)) + { p = filespec + len; + break; + } + p--; + } + } + return (char *)p; +} + +/**********************/ + +char * filespecname(const char *filespec) +{ register const char *p; + + /* Start at end of string and back up till we find the beginning */ + /* of the filename or a path. */ + for (p = filespec + strlen(filespec); + p != filespec && !ispathdelim(*(p - 1)); + p-- + ) + ; + return (char *)p; +} + +/***********************/ + +char * filespecgetroot(const char *name) +{ char *root,*p,c; + + p = filespecdotext(name); + c = *p; + *p = 0; + root = mem_strdup(name); + *p = c; + return root; +} + +/*****************************/ + +char * filespecforceext(const char *filespec,const char *ext) +{ register char *p; + register const char *pext; + + if (*ext == '.') + ext++; + if ((p = (char *)filespec) != NULL) + { pext = filespecdotext(filespec); + if (ext) + { int n = pext - filespec; + p = (char *) mem_malloc(n + 1 + strlen(ext) + 1); + if (p) + { memcpy(p,filespec,n); + p[n] = '.'; + strcpy(&p[n + 1],ext); + } + } + else + p = mem_strdup(filespec); + } + return p; +} + +/*****************************/ + +char * filespecdefaultext(const char *filespec,const char *ext) +{ register char *p; + register const char *pext; + + pext = filespecdotext(filespec); + if (*pext == '.') /* if already got an extension */ + { + p = mem_strdup(filespec); + } + else + { int n = pext - filespec; + p = (char *) mem_malloc(n + 1 + strlen(ext) + 1); + if (p) + { + memcpy(p,filespec,n); + p[n] = '.'; + strcpy(&p[n + 1],ext); + } + } + return p; +} + +/************************************/ + +#if !(MSDOS || __OS2__ || __NT__ || _WIN32) + +char *filespectilde(char *filespec) +{ +#if BSDUNIX + struct passwd *passwdPtr; + register char *f; + + if (filespec && *filespec == '~') + { + passwdPtr = NULL; + if (filespec[1] == '/' || filespec[1] == 0) /* if ~/... or ~ */ + { f = filespec + 1; + passwdPtr = getpwuid(getuid()); + } + else /* else ~name */ + { + char c; + + f = strpbrk(filespec," /"); + if (!f) + f = filespec + strlen(filespec); /* point at trailing 0 */ + c = *f; + *f = 0; + passwdPtr = getpwnam(filespec + 1); + *f = c; + } + if (passwdPtr) + { char *p; + + p = (char *) mem_malloc(strlen(passwdPtr->pw_dir) + strlen(f) + 1); + if (p) + { + strcpy(p,passwdPtr->pw_dir); + strcat(p,f); + mem_free(filespec); + filespec = p; + } + } + } +#endif +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#endif +#if VMS + assert(0); +#endif + return filespec; +} + +/************************************/ + +char *filespecmultitilde(char *string) +{ + register char *p, *p2, *p3, *p4; + + string = filespectilde(string); /* expand if first character is a '~' */ + + if (string) + { + for (p = string; *p != '\0'; p++) + { + if (*p == '~') + { + *p = '\0'; /* terminate sub string */ + p2 = mem_strdup(string); /* get new sub string from old string */ + *p = '~'; /* reset ~ character */ + for (p3 = p + 1; *p3 != ' ' && *p3 != '\0'; p3++) + ; /* scan to next name, or end of the string */ + p4 = NULL; + if (*p3 == ' ') + { + p4 = mem_strdup(p3); /* save reminder of the string */ + *p3 = '\0'; + } + p = mem_strdup(p); /* get tilde string */ + mem_free(string); + p = filespectilde(p); + + /* reconstruct the string from pieces */ + if (p4) + { + string = (char *) + mem_calloc(strlen(p2) + strlen(p) + strlen(p4) + 1); + sprintf(string, "%s%s%s", p2, p, p4); + } + else + { + string = (char *) + mem_calloc(strlen(p2) + strlen(p) + 1); + sprintf(string, "%s%s", p2, p); + } + mem_free(p); + p = string + strlen(p2) + 2; + mem_free(p2); + if (p4) + mem_free(p4); + } + } + } + return string; +} + +#endif + +#ifndef MPW +/************************************/ + +char * filespecbackup(const char *filespec) +{ +#if MSDOS || __OS2__ || __NT__ || _WIN32 + return filespecforceext(filespec,"BAK"); +#endif +#if BSDUNIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + char *p,*f; + + /* Prepend .B to file name, if it isn't already there */ + if (!filespec) + return (char *)filespec; + p = filespecname(filespec); + if (p[0] == '.' && p[1] == 'B') + return mem_strdup(filespec); + f = (char *) mem_malloc(strlen(filespec) + 2 + 1); + if (f) + { strcpy(f,filespec); + strcpy(&f[p - filespec],".B"); + strcat(f,p); + } + return f; +#endif +} +#endif diff --git a/tk/filespec.h b/tk/filespec.h new file mode 100644 index 00000000..97012be3 --- /dev/null +++ b/tk/filespec.h @@ -0,0 +1,136 @@ +/*_ filespec.h Fri Jul 8 1988 Modified by: bright */ +/* Copyright (C) 1986-1987 by Northwest Software */ +/* All Rights Reserved */ +/* Written by Walter Bright */ + +#ifndef FILESPEC_H +#define FILESPEC_H 1 + +/********************************* + * String compare of filenames. + */ + +#if MSDOS || __OS2__ || _WIN32 +#define filespeccmp(f1,f2) stricmp((f1),(f2)) +#define filespecmemcmp(f1,f2,n) memicmp((f1),(f2),(n)) +#endif +#if BSDUNIX || M_UNIX || M_XENIX +#define filespeccmp(f1,f2) strcmp((f1),(f2)) +#define filespecmemcmp(f1,f2,n) memcmp((f1),(f2),(n)) +#endif + +/**************************** + * Combine path and filename to form a filespec. + * Input: + * path Path, with or without trailing / + * (can be NULL) + * filename Cannot be NULL + * Returns: + * filespec mem_malloc'd file specification + * NULL Out of memory + */ + +char *filespecaddpath(const char *,const char *); + +/******************************* filespecrootpath ************************** + * Purpose: To expand a relative path into an absolute path. + * + * Side Effects: mem_frees input string. + * + * Returns: mem_malloced string with absolute path. + * NULL if some failure. + */ + +char *filespecrootpath(char *); + +/***************************** + * Add extension onto filespec, if one isn't already there. + * Input: + * filespec Cannot be NULL + * ext Extension (without the .) + * Returns: + * mem_malloc'ed string (NULL if error) + */ + +char *filespecdefaultext(const char *,const char *); + +/********************** + * Return string that is the dot and extension. + * The string returned is NOT mem_malloc'ed. + * Return pointer to the 0 at the end of filespec if dot isn't found. + * Return NULL if filespec is NULL. + */ + +char *filespecdotext(const char *); + +/***************************** + * Force extension onto filespec. + * Input: + * filespec String that may or may not contain an extension + * ext Extension that doesn't contain a . + * Returns: + * mem_malloc'ed string (NULL if error) + * NULL if filespec is NULL + * If ext is NULL, return mem_strdup(filespec) + */ + +char *filespecforceext(const char *,const char *); + +/*********************** + * Get root name of file name. + * That is, return a mem_strdup()'d version of the filename without + * the .ext. + */ + +char *filespecgetroot(const char *); + +/********************** + * Return string that is the filename plus dot and extension. + * The string returned is NOT mem_malloc'ed. + */ + +char *filespecname(const char *); + +/************************************ + * If first character of filespec is a ~, perform tilde-expansion. + * Output: + * Input filespec is mem_free'd. + * Returns: + * mem_malloc'd string + */ + +#if MSDOS || __OS2__ || __NT__ +#define filespectilde(f) (f) +#else +char *filespectilde(char *); +#endif + +/************************************ + * Expand all ~ in the given string. + * + * Output: + * Input filespec is mem_free'd. + * Returns: + * mem_malloc'd string + */ + +#if MSDOS || __OS2__ || __NT__ +#define filespecmultitilde(f) (f) +#else +char *filespecmultitilde(char *); +#endif + +/***************************** + * Convert filespec into a backup filename appropriate for the + * operating system. For instance, under MS-DOS path\filename.ext will + * be converted to path\filename.bak. + * Input: + * filespec String that may or may not contain an extension + * Returns: + * mem_malloc'ed string (NULL if error) + * NULL if filespec is NULL + */ + +char *filespecbackup(const char *); + +#endif /* FILESPEC_H */ diff --git a/tk/list.c b/tk/list.c new file mode 100644 index 00000000..3f45364a --- /dev/null +++ b/tk/list.c @@ -0,0 +1,462 @@ +/*_ list.c Mon Oct 31 1994 */ +/* Copyright (C) 1986-1994 by Symantec */ +/* All Rights Reserved */ +/* Written by Walter Bright */ + +#ifndef __STDIO_H +#include +#endif +#ifndef __STRING_H +#include +#endif +#ifndef __STDARG_H +#include +#endif +#ifndef assert +#include +#endif +#ifndef LIST_H +#include "list.h" +#endif +#ifndef MEM_H +#include "mem.h" +#endif + +#if MEM_DEBUG +#define fileline __FILE__,__LINE__ +#else +#define fileline +#endif + +#ifndef list_freelist +list_t list_freelist = NULL; /* list of free list entries */ +#endif +static int nlist; /* number of list items created */ +int list_inited = 0; /* 1 if initialized */ + +/* Free storage allocation */ +#ifndef list_new + +#if (__ZTC__ || __SC__) && !MEM_DEBUG +#define list_new() ((list_t) mem_fmalloc(sizeof(struct LIST))) +#define list_delete(list) mem_ffree(list) +#else +#if MEM_DEBUG +#define list_new() ((list_t) mem_calloc_debug(sizeof(struct LIST),file,line)) +#else +#define list_new() ((list_t) mem_malloc(sizeof(struct LIST))) +#endif +#define list_delete(list) mem_free(list) +#endif + +#endif + +/**********************/ + +void list_init() +{ +#ifdef DEBUG + assert(mem_inited); +#endif + if (list_inited == 0) + { nlist = 0; + list_inited++; + } +} + +/*******************/ + +void list_term() +{ + if (list_inited) + { +#ifdef DEBUG + printf("Max # of lists = %d\n",nlist); +#endif + while (list_freelist) + { list_t list; + + list = list_next(list_freelist); + list_delete(list_freelist); + list_freelist = list; + nlist--; + } +#ifdef DEBUG + if (nlist) + printf("nlist = %d\n",nlist); +#endif +#if !MEM_DEBUG + assert(nlist == 0); +#endif + list_inited = 0; + } +} + +/**************************** + * Allocate list item. + */ + +static list_t list_alloc +#if MEM_DEBUG + (char *file,int line) +#else + () +#endif +{ list_t list; + + if (list_freelist) + { list = list_freelist; + list_freelist = list_next(list); +#if MEM_DEBUG + mem_setnewfileline(list,file,line); +#endif + } + else + { nlist++; + list = list_new(); + } + return list; +} + +/******************************/ + +void list_free(list_t *plist,list_free_fp freeptr) +{ list_t list,listnext; + + list = *plist; + *plist = 0; /* block any circular reference bugs */ + while (list && --list->count == 0) + { listnext = list_next(list); + if (freeptr) + (*freeptr)(list_ptr(list)); +#if DEBUG + memset(list,0,sizeof(*list)); +#endif +#if 1 + list->next = list_freelist; + list_freelist = list; +#else + list_delete(list); + nlist--; +#endif + list = listnext; + } +} + +/***************************/ + +void *list_subtract(list_t *plist,void *ptr) +{ list_t list; + + while ((list = *plist) != 0) + { + if (list_ptr(list) == ptr) + { + if (--list->count == 0) + { *plist = list_next(list); + list->next = list_freelist; + list_freelist = list; + } + return ptr; + } + else + plist = &(list_next(list)); + } + return NULL; /* it wasn't in the list */ +} + +/*************************/ + +#if MEM_DEBUG +#undef list_append + +list_t list_append(list_t *plist,void *ptr) +{ + return list_append_debug(plist,ptr,__FILE__,__LINE__); +} + +list_t list_append_debug(list_t *plist,void *ptr,char *file,int line) +#else +list_t list_append(list_t *plist,void *ptr) +#endif +{ register list_t list; + + while (*plist) + plist = &(list_next(*plist)); /* find end of list */ + +#if MEM_DEBUG + list = list_alloc(file,line); +#else + list = list_alloc(); +#endif + if (list) + { *plist = list; + list_next(list) = 0; + list_ptr(list) = ptr; + list->count = 1; + } + return list; +} + +/*************************/ + +list_t list_prepend(list_t *plist,void *ptr) +{ register list_t list; + + list = list_alloc(fileline); + if (list) + { list_next(list) = *plist; + list_ptr(list) = ptr; + list->count = 1; + *plist = list; + } + return list; +} + +/*************************/ + +#if __SC__ && __INTSIZE == 4 && _M_I86 && !_DEBUG_TRACE + +__declspec(naked) int __pascal list_nitems(list_t list) +{ + _asm + { + mov ECX,list-4[ESP] + xor EAX,EAX + test ECX,ECX + jz L1 + L2: + mov ECX,[ECX]LIST.next + inc EAX + test ECX,ECX + jnz L2 + L1: + ret 4 + } +} + +#else + +#if __DMC__ +int __pascal list_nitems(list_t list) +#else +int list_nitems(list_t list) +#endif +{ register int n; + + n = 0; + while (list) + { n++; + list = list_next(list); + } + return n; +} + +#endif + +/*************************/ + +list_t list_nth(list_t list,int n) +{ register int i; + + for (i = 0; i < n; i++) + { assert(list); + list = list_next(list); + } + return list; +} + +/*************************/ + +list_t list_last(list_t list) +{ + if (list) + while (list_next(list)) + list = list_next(list); + return list; +} + +/**************************/ + +list_t list_prev(list_t start,list_t list) +{ + if (start) + { if (start == list) + start = NULL; + else + while (list_next(start) != list) + { start = list_next(start); + assert(start); + } + } + return start; +} + +/****************************/ + +list_t list_copy(list_t list) +{ list_t c; + + c = NULL; + for (; list; list = list_next(list)) + list_append(&c,list_ptr(list)); + return c; +} + +/****************************/ + +int list_equal(list_t list1,list_t list2) +{ + while (list1 && list2) + { + if (list_ptr(list1) != list_ptr(list2)) + break; + list1 = list_next(list1); + list2 = list_next(list2); + } + return list1 == list2; +} + +/****************************/ + +int list_cmp(list_t list1,list_t list2,int (*func)(void *,void *)) +{ int result = 0; + + while (1) + { + if (!list1) + { if (list2) + result = -1; /* list1 < list2 */ + break; + } + if (!list2) + { result = 1; /* list1 > list2 */ + break; + } + result = (*func)(list_ptr(list1),list_ptr(list2)); + if (result) + break; + list1 = list_next(list1); + list2 = list_next(list2); + } + return result; +} + +/*****************************/ + +list_t list_inlist(list_t list,void *ptr) +{ + for (; list; list = list_next(list)) + if (list_ptr(list) == ptr) + break; + return list; +} + +/******************************/ + +list_t list_cat(list_t *pl1,list_t l2) +{ list_t *pl; + + for (pl = pl1; *pl; pl = &list_next(*pl)) + ; + *pl = l2; + return *pl1; +} + +/******************************/ + +list_t list_build(void *p,...) +{ list_t alist; + list_t *pe; + va_list ap; + + alist = NULL; + pe = &alist; + for (va_start(ap,p); p; p = va_arg(ap,void *)) + { list_t list; + + list = list_alloc(fileline); + if (list) + { list_next(list) = NULL; + list_ptr(list) = p; + list->count = 1; + *pe = list; + pe = &list_next(list); + } + } + va_end(ap); + return alist; +} + +/*************************************** + * Apply a function to each member of a list. + */ + +void list_apply(list_t *plist,void (*fp)(void *)) +{ + list_t l; + + if (fp) + for (l = *plist; l; l = list_next(l)) + { + (*fp)(list_ptr(l)); + } +} + +/********************************************* + * Reverse a list. + */ + +list_t list_reverse(list_t l) +{ list_t r; + list_t ln; + + r = NULL; + while (l) + { ln = list_next(l); + list_next(l) = r; + r = l; + l = ln; + } + return r; +} + +/********************************************** + * Copy list of pointers into an array of pointers. + */ + +void list_copyinto(list_t l, void *pa) +{ + void **ppa = (void **)pa; + for (; l; l = list_next(l)) + *(ppa)++ = list_ptr(l); +} + +/********************************************** + * Insert item into list at nth position. + */ + +list_t list_insert(list_t *pl,void *ptr,int n) +{ + list_t list; + + while (n) + { + pl = &list_next(*pl); + n--; + } + list = list_alloc(fileline); + if (list) + { + list_next(list) = *pl; + *pl = list; + list_ptr(list) = ptr; + list->count = 1; + } + return list; +} + +#ifdef __cplusplus +void list_free(list_t *l) { list_free(l,FPNULL); } +#endif + diff --git a/tk/list.h b/tk/list.h new file mode 100644 index 00000000..0941f3d4 --- /dev/null +++ b/tk/list.h @@ -0,0 +1,291 @@ +/*_ list.h Wed May 16 1990 Modified by: Walter Bright */ +/* Copyright (C) 1986-1990 by Northwest Software */ +/* All Rights Reserved */ +/* Written by Walter Bright */ + +#ifndef LIST_H +#define LIST_H 1 + +#if __SC__ +#pragma once +#endif + +/* + * List is a complete package of functions to deal with singly linked + * lists of pointers or integers. + * Features: + * o Uses mem package. + * o Has loop-back tests. + * o Each item in the list can have multiple predecessors, enabling + * different lists to 'share' a common tail. + */ + +/***************** TYPEDEFS AND DEFINES *******************/ + +typedef struct LIST +{ + /* Do not access items in this struct directly, use the */ + /* functions designed for that purpose. */ + struct LIST *next; /* next element in list */ + int count; /* when 0, element may be deleted */ + union + { void *ptr; /* data pointer */ + int data; + } L; +} *list_t; /* pointer to a list entry */ + +/* FPNULL is a null function pointer designed to be an argument to + * list_free(). + */ + +typedef void (*list_free_fp) (void *); + +#define FPNULL ((list_free_fp) 0) + +/***************** PUBLIC VARIABLES **********************/ + +extern int list_inited; /* != 0 if list package is initialized */ + +/***************** PUBLIC FUNCTIONS **********************/ + +/******************************** + * Create link to existing list, that is, share the list with + * somebody else. + * Use: + * list_t list_link(list_t list); + * Returns: + * pointer to that list entry. + */ + +#define list_link(list) (((list) && (list)->count++),(list)) + +/******************************** + * Return pointer to next entry in list. + * Use: + * list_t list_next(list_t list); + */ + +#define list_next(list) ((list)->next) + +/******************************** + * Return pointer to previous item in list. + * Use: + * list_t list_prev(list_t start,list_t list); + */ + +/******************************** + * Return ptr from list entry. + * Use: + * void *list_ptr(list_t list); + */ + +#define list_ptr(list) ((list)->L.ptr) + +/******************************** + * Return integer item from list entry. + * Use: + * int list_data(list_t list); + */ + +#define list_data(list) ((list)->L.data) + +/******************************** + * Append integer item to list. + * Use: + * void list_appenddata(list_t *plist,int d); + */ + +#define list_appenddata(plist,d) (list_data(list_append((plist),NULL)) = (d)) + +/******************************** + * Prepend integer item to list. + * Use: + * void list_prependdata(list_t *plist,int d); + */ + +#define list_prependdata(plist,d) (list_data(list_prepend((plist),NULL)) = (d)) + +/********************** + * Initialize list package. + * void list_init(void); + * Output: + * list_inited = 1 + */ + +/******************* + * Terminate list package. + * void list_term(void); + * Output: + * list_inited = 0 + */ + +/******************** + * Free list. + * Use: + * void list_free(list_t *plist,void (*freeptr)(void *)); + * Input: + * plist Pointer to list to free + * freeptr Pointer to freeing function for the data pointer + * (use FPNULL if none) + * Output: + * *plist is NULL + */ + +/*************************** + * Remove ptr from the list pointed to by *plist. + * Use: + * void *list_subtract(list_t *plist,void *ptr); + * Output: + * *plist is updated to be the start of the new list + * Returns: + * NULL if *plist is NULL + * otherwise ptr + */ + +/*************************** + * Remove first element in list pointed to by *plist. + * void *list_pop(list_t *plist); + * Returns: + * First element, NULL if *plist is NULL + */ + +#define list_pop(plist) list_subtract((plist),list_ptr(*(plist))) + +/************************* + * Append ptr to *plist. + * Use: + * list_t list_append(list_t *plist,void *ptr); + * Returns: + * pointer to list item created. + * NULL if out of memory + */ + +/************************* + * Prepend ptr to *plist. + * Use: + * list_t list_prepend(list_t *plist,void *ptr); + * Returns: + * pointer to list item created (which is also the start of the list). + * NULL if out of memory + */ + +/************************* + * Count up and return number of items in list. + * Use: + * int list_nitems(list_t list); + * Returns: + * # of entries in list + */ + +/************************* + * Return nth list entry in list. + * Use: + * list_t list_nth(list_t list,int n); + */ + +/*********************** + * Return last list entry in list. + * Use: + * list_t list_last(list_t list); + */ + +/*********************** + * Copy a list and return it. + * Use: + * list_t list_copy(list_t list); + */ + +/************************ + * Compare two lists. If they have the same ptrs, return 1 else 0. + * Use: + * int list_equal(list_t list1,list_t list2); + */ + +/************************ + * Compare two lists using the specified comparison function. + * If they compare equal, return 0 else value returned by func. + * The comparison function is the same as used for qsort(). + */ + +int list_cmp (list_t list1,list_t list2,int (*func) (void *,void *)); + +/************************* + * Search for ptr in list. If found, return list entry that it is, else NULL. + * Use: + * list_t list_inlist(list_t list,void *ptr); + */ + +/************************* + * Concatenate two lists (l2 appended to l1). + * Output: + * *pl1 updated to be start of concatenated list. + * Returns: + * *pl1 + */ + +list_t list_cat (list_t *pl1, list_t l2); + +/************************* + * Build a list out of the NULL-terminated argument list. + * Returns: + * generated list + */ + +list_t list_build (void *p, ...); + +/*************************************** + * Apply a function to each member of a list. + */ + +void list_apply (list_t *plist,void (*fp)(void *)); + +/******************************************** + * Reverse a list. + */ + +list_t list_reverse (list_t); + +/********************************************** + * Copy list of pointers into an array of pointers. + */ + +void list_copyinto(list_t, void *); + +/********************************************** + * Insert item into list at nth position. + */ + +list_t list_insert(list_t *,void *,int n); + +/*********************** IMPLEMENTATION **********************/ + +extern void list_init (void), + list_term (void), + list_free (list_t *,void (*)(void *)); +extern void *list_subtract (list_t *,void *); +extern list_t +#if MEM_DEBUG +#define list_append(a,b) list_append_debug(a,b,__FILE__,__LINE__) + list_append_debug (list_t *,void *,char *,int), +#else + list_append (list_t *,void *), +#endif + list_prepend (list_t *,void *), + list_nth (list_t,int), + list_last (list_t), + list_prev (list_t,list_t), + list_inlist (list_t,void *), + list_copy (list_t); +#if __DMC__ +extern int __pascal list_nitems (list_t), + list_equal (list_t,list_t); +#else +extern int list_nitems (list_t), + list_equal (list_t,list_t); +#endif + +#ifdef __cplusplus +void list_free(list_t *l); // { list_free(l,FPNULL); } +#endif + +#endif /* LIST_H */ diff --git a/tk/mem.c b/tk/mem.c new file mode 100644 index 00000000..5851e4f1 --- /dev/null +++ b/tk/mem.c @@ -0,0 +1,901 @@ +/*_ mem.c */ +/* Memory management package */ +/* Written by Walter Bright */ + +#include +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#include +#else +#define _near +#include +#include +#include +#endif +#include +#include + +#if __cplusplus +#if __DMC__ +#include +#else +#include +#endif +#endif + +#ifndef malloc +#if __SC__ || __DMC__ || _MSC_VER +#include +#else +#include +#endif +#endif + +#ifndef MEM_H +#include "mem.h" +#endif + +#ifndef MEM_NOMEMCOUNT +#define MEM_NOMEMCOUNT 0 +#endif + +#if !MEM_NONE + +#ifndef assert +#include +#endif + +#ifndef VAX11C +#ifdef BSDUNIX +#include +#else +#include +#endif +#else +extern char *strcpy(),*memcpy(); +extern int strlen(); +#endif /* VAX11C */ + +int mem_inited = 0; /* != 0 if initialized */ + +static int mem_behavior = MEM_ABORTMSG; +static int (*oom_fp)(void) = NULL; /* out-of-memory handler */ +static int mem_count; /* # of allocs that haven't been free'd */ +static int mem_scount; /* # of sallocs that haven't been free'd */ + +/* Determine where to send error messages */ +#if _WINDLL +void err_message(const char *,...); +#define PRINT err_message( +#elif MSDOS +#define PRINT printf( /* stderr can't be redirected with MS-DOS */ +#else +#define ferr stderr +#define PRINT fprintf(ferr, +#endif + +/*******************************/ + +void mem_setexception(enum MEM_E flag,...) +{ va_list ap; + typedef int (*fp_t)(void); + + mem_behavior = flag; + va_start(ap,flag); + oom_fp = (mem_behavior == MEM_CALLFP) ? va_arg(ap,fp_t) : 0; + va_end(ap); +#if MEM_DEBUG + assert(0 <= flag && flag <= MEM_RETRY); +#endif +} + +/************************* + * This is called when we're out of memory. + * Returns: + * 1: try again to allocate the memory + * 0: give up and return NULL + */ + +int mem_exception() +{ int behavior; + + behavior = mem_behavior; + while (1) + { + switch (behavior) + { + case MEM_ABORTMSG: +#if MSDOS || __OS2__ || __NT__ || _WIN32 + /* Avoid linking in buffered I/O */ + { static char msg[] = "Fatal error: out of memory\r\n"; + + write(1,msg,sizeof(msg) - 1); + } +#else + PRINT "Fatal error: out of memory\n"); +#endif + /* FALL-THROUGH */ + case MEM_ABORT: + exit(EXIT_FAILURE); + /* NOTREACHED */ + case MEM_CALLFP: + assert(oom_fp); + behavior = (*oom_fp)(); + break; + case MEM_RETNULL: + return 0; + case MEM_RETRY: + return 1; + default: + assert(0); + } + } +} + +/****************************/ + +#if MEM_DEBUG + +#undef mem_strdup + +char *mem_strdup(const char *s) +{ + return mem_strdup_debug(s,__FILE__,__LINE__); +} + +char *mem_strdup_debug(const char *s,const char *file,int line) +{ + char *p; + + p = s + ? (char *) mem_malloc_debug((unsigned) strlen(s) + 1,file,line) + : NULL; + return p ? strcpy(p,s) : p; +} +#else +char *mem_strdup(const char *s) +{ + char *p; + int len; + + if (s) + { len = strlen(s) + 1; + p = (char *) mem_malloc(len); + if (p) + return (char *)memcpy(p,s,len); + } + return NULL; +} + +#endif /* MEM_DEBUG */ + +/************* C++ Implementation ***************/ + +#if __cplusplus && !MEM_NONE +extern "C++" +{ + +/* Cause initialization and termination functions to be called */ +#if 0 +static struct cMemDebug +{ + cMemDebug() { mem_init(); } + ~cMemDebug() { mem_term(); } +} dummy; +#endif + +int __mem_line; +char *__mem_file; + +/******************** + */ + +#if __GNUC__ +int (*_new_handler)(void); +#else +void (*_new_handler)(void); +#endif + +/***************************** + * Replacement for the standard C++ library operator new(). + */ + +#if !MEM_NONEW + +#if __GNUC__ +void * operator new(size_t size) +#else +#undef new +void * __cdecl operator new(size_t size) +#endif +{ void *p; + + while (1) + { + if (size == 0) + size++; +#if MEM_DEBUG + assert(mem_inited); + p = mem_malloc_debug(size,__mem_file,__mem_line); +#else + p = mem_malloc((unsigned)size); +#endif + if (p != NULL || _new_handler == NULL) + break; + (*_new_handler)(); + } + return p; +} + +#if __GNUC__ +void * operator new[](size_t size) +#else +void * __cdecl operator new[](size_t size) +#endif +{ void *p; + + while (1) + { + if (size == 0) + size++; +#if MEM_DEBUG + assert(mem_inited); + p = mem_malloc_debug(size,__mem_file,__mem_line); +#else + p = mem_malloc((unsigned)size); +#endif + if (p != NULL || _new_handler == NULL) + break; + (*_new_handler)(); + } + return p; +} + +/*********************** + * Replacement for the standard C++ library operator delete(). + */ + +#undef delete +void __cdecl operator delete(void *p) +{ +#if MEM_DEBUG + assert(mem_inited); + mem_free_debug(p,__mem_file,__mem_line); +#else + mem_free(p); +#endif +} + +void __cdecl operator delete[](void *p) +{ +#if MEM_DEBUG + assert(mem_inited); + mem_free_debug(p,__mem_file,__mem_line); +#else + mem_free(p); +#endif +} +#endif +} +#endif + +#if MEM_DEBUG + +static long mem_maxalloc; /* max # of bytes allocated */ +static long mem_numalloc; /* current # of bytes allocated */ + +#define BEFOREVAL 0x4F464542 /* value to detect underrun */ +#define AFTERVAL 0x45544641 /* value to detect overrun */ + +#if SUN || SUN386 +static long afterval = AFTERVAL; /* so we can do &afterval */ +#endif + +/* The following should be selected to give maximum probability that */ +/* pointers loaded with these values will cause an obvious crash. On */ +/* Unix machines, a large value will cause a segment fault. */ +/* MALLOCVAL is the value to set malloc'd data to. */ + +#if MSDOS || __OS2__ || __NT__ || _WIN32 +#define BADVAL 0xFF +#define MALLOCVAL 0xEE +#else +#define BADVAL 0x7A +#define MALLOCVAL 0xEE +#endif + +/* Disable mapping macros */ +#undef mem_malloc +#undef mem_calloc +#undef mem_realloc +#undef mem_free + +/* Create a list of all alloc'ed pointers, retaining info about where */ +/* each alloc came from. This is a real memory and speed hog, but who */ +/* cares when you've got obscure pointer bugs. */ + +static struct mem_debug +{ + struct mem_debug *Mnext; /* next in list */ + struct mem_debug *Mprev; /* previous value in list */ + const char *Mfile; /* filename of where allocated */ + int Mline; /* line number of where allocated */ + unsigned Mnbytes; /* size of the allocation */ + unsigned long Mbeforeval; /* detect underrun of data */ + char data[1]; /* the data actually allocated */ +} mem_alloclist = +{ + (struct mem_debug *) NULL, + (struct mem_debug *) NULL, + NULL, + 11111, + 0, + BEFOREVAL, +#if !(linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4) + AFTERVAL +#endif +}; + +/* Determine allocation size of a mem_debug */ +#define mem_debug_size(n) (sizeof(struct mem_debug) - 1 + (n) + sizeof(AFTERVAL)) + +/* Convert from a void *to a mem_debug struct. */ +#define mem_ptrtodl(p) ((struct mem_debug *) ((char *)p - offsetof(struct mem_debug,data[0]))) + +/* Convert from a mem_debug struct to a mem_ptr. */ +#define mem_dltoptr(dl) ((void *) &((dl)->data[0])) + +/***************************** + * Set new value of file,line + */ + +void mem_setnewfileline( void *ptr, const char *fil, int lin) +{ + struct mem_debug *dl; + + dl = mem_ptrtodl(ptr); + dl->Mfile = fil; + dl->Mline = lin; +} + +/**************************** + * Print out struct mem_debug. + */ + +static void _near mem_printdl(struct mem_debug *dl) +{ + PRINT "alloc'd from file '%s' line %d nbytes %d ptr %p\n", + dl->Mfile,dl->Mline,dl->Mnbytes,(long)mem_dltoptr(dl)); +} + +/**************************** + * Print out file and line number. + */ + +static void _near mem_fillin(const char *fil, int lin) +{ + PRINT "File '%s' line %d\n",fil,lin); +#ifdef ferr + fflush(ferr); +#endif +} + +/**************************** + * If MEM_DEBUG is not on for some modules, these routines will get + * called. + */ + +void *mem_calloc(unsigned u) +{ + return mem_calloc_debug(u,__FILE__,__LINE__); +} + +void *mem_malloc(unsigned u) +{ + return mem_malloc_debug(u,__FILE__,__LINE__); +} + +void *mem_realloc(void *p, unsigned u) +{ + return mem_realloc_debug(p,u,__FILE__,__LINE__); +} + +void mem_free(void *p) +{ + mem_free_debug(p,__FILE__,__LINE__); +} + + +/**************************/ + +void mem_freefp(void *p) +{ + mem_free(p); +} + +/*********************** + * Debug versions of mem_calloc(), mem_free() and mem_realloc(). + */ + +void *mem_malloc_debug(unsigned n, const char *fil, int lin) +{ void *p; + + p = mem_calloc_debug(n,fil,lin); + if (p) + memset(p,MALLOCVAL,n); + return p; +} + +void *mem_calloc_debug(unsigned n, const char *fil, int lin) +{ + struct mem_debug *dl; + + do + dl = (struct mem_debug *) calloc(mem_debug_size(n),1); + while (dl == NULL && mem_exception()); + if (dl == NULL) + return NULL; + dl->Mfile = fil; + dl->Mline = lin; + dl->Mnbytes = n; + dl->Mbeforeval = BEFOREVAL; +#if SUN || SUN386 /* bus error if we store a long at an odd address */ + memcpy(&(dl->data[n]),&afterval,sizeof(AFTERVAL)); +#else + *(long *) &(dl->data[n]) = AFTERVAL; +#endif + + /* Add dl to start of allocation list */ + dl->Mnext = mem_alloclist.Mnext; + dl->Mprev = &mem_alloclist; + mem_alloclist.Mnext = dl; + if (dl->Mnext != NULL) + dl->Mnext->Mprev = dl; + + mem_count++; + mem_numalloc += n; + if (mem_numalloc > mem_maxalloc) + mem_maxalloc = mem_numalloc; + return mem_dltoptr(dl); +} + +void mem_free_debug(void *ptr, const char *fil, int lin) +{ + struct mem_debug *dl; + + if (ptr == NULL) + return; + if (mem_count <= 0) + { PRINT "More frees than allocs at "); + goto err; + } + dl = mem_ptrtodl(ptr); + if (dl->Mbeforeval != BEFOREVAL) + { + PRINT "Pointer x%lx underrun\n",(long)ptr); + PRINT "'%s'(%d)\n",fil,lin); + goto err2; + } +#if SUN || SUN386 /* Bus error if we read a long from an odd address */ + if (memcmp(&dl->data[dl->Mnbytes],&afterval,sizeof(AFTERVAL)) != 0) +#else + if (*(long *) &dl->data[dl->Mnbytes] != AFTERVAL) +#endif + { + PRINT "Pointer x%lx overrun\n",(long)ptr); + goto err2; + } + mem_numalloc -= dl->Mnbytes; + if (mem_numalloc < 0) + { PRINT "error: mem_numalloc = %ld, dl->Mnbytes = %d\n", + mem_numalloc,dl->Mnbytes); + goto err2; + } + + /* Remove dl from linked list */ + if (dl->Mprev) + dl->Mprev->Mnext = dl->Mnext; + if (dl->Mnext) + dl->Mnext->Mprev = dl->Mprev; + + /* Stomp on the freed storage to help detect references */ + /* after the storage was freed. */ + memset((void *) dl,BADVAL,sizeof(*dl) + dl->Mnbytes); + mem_count--; + + free((void *) dl); + return; + +err2: + mem_printdl(dl); +err: + PRINT "free'd from "); + mem_fillin(fil,lin); + assert(0); + /* NOTREACHED */ +} + +/******************* + * Debug version of mem_realloc(). + */ + +void *mem_realloc_debug(void *oldp, unsigned n, const char *fil, int lin) +{ void *p; + struct mem_debug *dl; + + if (n == 0) + { mem_free_debug(oldp,fil,lin); + p = NULL; + } + else if (oldp == NULL) + p = mem_malloc_debug(n,fil,lin); + else + { + p = mem_malloc_debug(n,fil,lin); + if (p != NULL) + { + dl = mem_ptrtodl(oldp); + if (dl->Mnbytes < n) + n = dl->Mnbytes; + memcpy(p,oldp,n); + mem_free_debug(oldp,fil,lin); + } + } + return p; +} + +/***************************/ + +static void mem_checkdl(struct mem_debug *dl) +{ void *p; +#if (__SC__ || __DMC__) && !_WIN32 + unsigned u; + + /* Take advantage of fact that SC's allocator stores the size of the + * alloc in the unsigned immediately preceding the allocation. + */ + u = ((unsigned *)dl)[-1] - sizeof(unsigned); + assert((u & (sizeof(unsigned) - 1)) == 0 && u >= mem_debug_size(dl->Mnbytes)); +#endif + p = mem_dltoptr(dl); + if (dl->Mbeforeval != BEFOREVAL) + { + PRINT "Pointer x%lx underrun\n",(long)p); + goto err2; + } +#if SUN || SUN386 /* Bus error if we read a long from an odd address */ + if (memcmp(&dl->data[dl->Mnbytes],&afterval,sizeof(AFTERVAL)) != 0) +#else + if (*(long *) &dl->data[dl->Mnbytes] != AFTERVAL) +#endif + { + PRINT "Pointer x%lx overrun\n",(long)p); + goto err2; + } + return; + +err2: + mem_printdl(dl); + assert(0); +} + +/***************************/ + +void mem_check() +{ register struct mem_debug *dl; + +#if (__SC__ || _MSC_VER) && !defined(malloc) + int i; + + i = _heapset(0xF4); + assert(i == _HEAPOK); +#endif + for (dl = mem_alloclist.Mnext; dl != NULL; dl = dl->Mnext) + mem_checkdl(dl); +} + +/***************************/ + +void mem_checkptr(void *p) +{ register struct mem_debug *dl; + + for (dl = mem_alloclist.Mnext; dl != NULL; dl = dl->Mnext) + { + if (p >= (void *) &(dl->data[0]) && + p < (void *)((char *)dl + sizeof(struct mem_debug)-1 + dl->Mnbytes)) + goto L1; + } + assert(0); + +L1: + mem_checkdl(dl); +} + +#else + +/***************************/ + +void *mem_malloc(unsigned numbytes) +{ void *p; + + if (numbytes == 0) + return NULL; + while (1) + { + p = malloc(numbytes); + if (p == NULL) + { if (mem_exception()) + continue; + } +#if !MEM_NOMEMCOUNT + else + mem_count++; +#endif + break; + } + /*printf("malloc(%d) = x%lx, mem_count = %d\n",numbytes,p,mem_count);*/ + return p; +} + +/***************************/ + +void *mem_calloc(unsigned numbytes) +{ void *p; + + if (numbytes == 0) + return NULL; + while (1) + { + p = calloc(numbytes,1); + if (p == NULL) + { if (mem_exception()) + continue; + } +#if !MEM_NOMEMCOUNT + else + mem_count++; +#endif + break; + } + /*printf("calloc(%d) = x%lx, mem_count = %d\n",numbytes,p,mem_count);*/ + return p; +} + +/***************************/ + +void *mem_realloc(void *oldmem_ptr,unsigned newnumbytes) +{ void *p; + + if (oldmem_ptr == NULL) + p = mem_malloc(newnumbytes); + else if (newnumbytes == 0) + { mem_free(oldmem_ptr); + p = NULL; + } + else + { + do + p = realloc(oldmem_ptr,newnumbytes); + while (p == NULL && mem_exception()); + } + /*printf("realloc(x%lx,%d) = x%lx, mem_count = %d\n",oldmem_ptr,newnumbytes,p,mem_count);*/ + return p; +} + +/***************************/ + +void mem_free(void *ptr) +{ + /*printf("free(x%lx) mem_count=%d\n",ptr,mem_count);*/ + if (ptr != NULL) + { +#if !MEM_NOMEMCOUNT + assert(mem_count != 0); + mem_count--; +#endif + free(ptr); + } +} + +/***************************/ +/* This is our low-rent fast storage allocator */ + +static char *heap; +static size_t heapleft; + +/***************************/ + +#if 0 && __SC__ && __INTSIZE == 4 && __I86__ && !_DEBUG_TRACE && _WIN32 && (SCC || SCPP || JAVA) + +__declspec(naked) void *mem_fmalloc(unsigned numbytes) +{ + __asm + { + mov EDX,4[ESP] + mov EAX,heap + add EDX,3 + mov ECX,heapleft + and EDX,~3 + je L5A + cmp EDX,ECX + ja L2D + sub ECX,EDX + add EDX,EAX + mov heapleft,ECX + mov heap,EDX + ret 4 + +L2D: push EBX + mov EBX,EDX +// add EDX,03FFFh +// and EDX,~03FFFh + add EDX,03C00h + mov heapleft,EDX +L3D: push heapleft + call mem_malloc + test EAX,EAX + mov heap,EAX + jne L18 + call mem_exception + test EAX,EAX + jne L3D + pop EBX +L5A: xor EAX,EAX + ret 4 + +L18: add heap,EBX + sub heapleft,EBX + pop EBX + ret 4 + } +} + +#else + +void *mem_fmalloc(unsigned numbytes) +{ void *p; + + //printf("fmalloc(%d)\n",numbytes); +#if defined(__llvm__) && (defined(__GNUC__) || defined(__clang__)) + // LLVM-GCC and Clang assume some types, notably elem (see DMD issue 6215), + // to be 16-byte aligned. Because we do not have any type information + // available here, we have to 16 byte-align everything. + numbytes = (numbytes + 0xF) & ~0xF; +#else + if (sizeof(size_t) == 2) + numbytes = (numbytes + 1) & ~1; /* word align */ + else + numbytes = (numbytes + 3) & ~3; /* dword align */ +#endif + + /* This ugly flow-of-control is so that the most common case + drops straight through. + */ + + if (!numbytes) + return NULL; + + if (numbytes <= heapleft) + { + L2: + p = (void *)heap; + heap += numbytes; + heapleft -= numbytes; + return p; + } + +#if 1 + heapleft = numbytes + 0x3C00; + if (heapleft >= 16372) + heapleft = numbytes; +#elif _WIN32 + heapleft = (numbytes + 0x3FFF) & ~0x3FFF; /* round to next boundary */ +#else + heapleft = 0x3F00; + assert(numbytes <= heapleft); +#endif +L1: + heap = (char *)malloc(heapleft); + if (!heap) + { if (mem_exception()) + goto L1; + return NULL; + } + goto L2; +} + +#endif + +/***************************/ + +void *mem_fcalloc(unsigned numbytes) +{ void *p; + + p = mem_fmalloc(numbytes); + return p ? memset(p,0,numbytes) : p; +} + +/***************************/ + +char *mem_fstrdup(const char *s) +{ + char *p; + int len; + + if (s) + { len = strlen(s) + 1; + p = (char *) mem_fmalloc(len); + if (p) + return (char *)memcpy(p,s,len); + } + return NULL; +} + +#endif + +/***************************/ + +void mem_init() +{ + if (mem_inited == 0) + { mem_count = 0; + mem_scount = 0; + oom_fp = NULL; + mem_behavior = MEM_ABORTMSG; +#if MEM_DEBUG + mem_numalloc = 0; + mem_maxalloc = 0; + mem_alloclist.Mnext = NULL; +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 + *(long *) &(mem_alloclist.data[0]) = AFTERVAL; +#endif +#endif +#if (__ZTC__ || __SC__ || __DMC__) && !defined(malloc) + free(malloc(1)); /* initialize storage allocator */ +#endif +#if MEM_DEBUG && (__SC__ || _MSC_VER) && !defined(malloc) + { int i; + + i = _heapset(0xF4); + assert(i == _HEAPOK); + } +#endif + } + mem_inited++; +} + +/***************************/ + +void mem_term() +{ + if (mem_inited) + { +#if MEM_DEBUG + struct mem_debug *dl; + + for (dl = mem_alloclist.Mnext; dl; dl = dl->Mnext) + { PRINT "Unfreed pointer: "); + mem_printdl(dl); + } +#if 0 + PRINT "Max amount ever allocated == %ld bytes\n", + mem_maxalloc); +#endif +#if (__SC__ || _MSC_VER) && !defined(malloc) + { int i; + + i = _heapset(0xF4); + assert(i == _HEAPOK); + } +#endif +#else + if (mem_count) + PRINT "%d unfreed items\n",mem_count); + if (mem_scount) + PRINT "%d unfreed s items\n",mem_scount); +#endif /* MEM_DEBUG */ + assert(mem_count == 0 && mem_scount == 0); + } + mem_inited = 0; +} + +#endif /* !MEM_NONE */ diff --git a/tk/mem.h b/tk/mem.h new file mode 100644 index 00000000..f743cd15 --- /dev/null +++ b/tk/mem.h @@ -0,0 +1,271 @@ +/*_ mem.h */ +/* Copyright 1986-1997 by Walter Bright */ +/* All Rights Reserved */ +/* Written by Walter Bright */ + +#ifndef MEM_H +#define MEM_H 1 + +#if __SC__ +#pragma once +#endif + +/* + * Memory management routines. + * + * Compiling: + * + * #define MEM_DEBUG 1 when compiling to enable extended debugging + * features. + * + * #define MEM_NONE 1 to compile out mem, i.e. have it all drop + * directly to calls to malloc, free, etc. + * + * #define MEM_NOMEMCOUNT 1 to remove checks on the number of free's + * matching the number of alloc's. + * + * Features always enabled: + * + * o mem_init() is called at startup, and mem_term() at + * close, which checks to see that the number of alloc's is + * the same as the number of free's. + * o Behavior on out-of-memory conditions can be controlled + * via mem_setexception(). + * + * Extended debugging features: + * + * o Enabled by #define MEM_DEBUG 1 when compiling. + * o Check values are inserted before and after the alloc'ed data + * to detect pointer underruns and overruns. + * o Free'd pointers are checked against alloc'ed pointers. + * o Free'd storage is cleared to smoke out references to free'd data. + * o Realloc'd pointers are always changed, and the previous storage + * is cleared, to detect erroneous dependencies on the previous + * pointer. + * o The routine mem_checkptr() is provided to check an alloc'ed + * pointer. + */ + +/********************* GLOBAL VARIABLES *************************/ + +extern int mem_inited; /* != 0 if mem package is initialized. */ + /* Test this if you have other packages */ + /* that depend on mem being initialized */ + +/********************* PUBLIC FUNCTIONS *************************/ + +/*********************************** + * Set behavior when mem runs out of memory. + * Input: + * flag = MEM_ABORTMSG: Abort the program with the message + * 'Fatal error: out of memory' sent + * to stdout. This is the default behavior. + * MEM_ABORT: Abort the program with no message. + * MEM_RETNULL: Return NULL back to caller. + * MEM_CALLFP: Call application-specified function. + * fp must be supplied. + * fp Optional function pointer. Supplied if + * (flag == MEM_CALLFP). This function returns + * MEM_XXXXX, indicating what mem should do next. + * The function could do things like swap + * data out to disk to free up more memory. + * fp could also return: + * MEM_RETRY: Try again to allocate the space. Be + * careful not to go into an infinite loop. + * The type of fp is: + * int (*handler)(void) + */ + +#if !MEM_NONE +#if __SC__ || __DMC__ || __GNUC__ +enum MEM_E { MEM_ABORTMSG, MEM_ABORT, MEM_RETNULL, MEM_CALLFP, MEM_RETRY }; +void mem_setexception(enum MEM_E,...); +#else +#define MEM_ABORTMSG 0 +#define MEM_ABORT 1 +#define MEM_RETNULL 2 +#define MEM_CALLFP 3 +#define MEM_RETRY 4 +void mem_setexception(int,...); +#endif +#endif + +/**************************** + * Allocate space for string, copy string into it, and + * return pointer to the new string. + * This routine doesn't really belong here, but it is used so often + * that I gave up and put it here. + * Use: + * char *mem_strdup(const char *s); + * Returns: + * pointer to copied string if succussful. + * else returns NULL (if MEM_RETNULL) + */ + +char *mem_strdup(const char *); + +/************************** + * Function so we can have a pointer to function mem_free(). + * This is needed since mem_free is sometimes defined as a macro, + * and then the preprocessor screws up. + * The pointer to mem_free() is used frequently with the list package. + * Use: + * void mem_freefp(void *p); + */ + +/*************************** + * Check for errors. This routine does a consistency check on the + * storage allocator, looking for corrupted data. It should be called + * when the application has CPU cycles to burn. + * Use: + * void mem_check(void); + */ + +void mem_check(void); + +/*************************** + * Check ptr to see if it is in the range of allocated data. + * Cause assertion failure if it isn't. + */ + +void mem_checkptr(void *ptr); + +/*************************** + * Allocate and return a pointer to numbytes of storage. + * Use: + * void *mem_malloc(unsigned numbytes); + * void *mem_calloc(unsigned numbytes); allocated memory is cleared + * Input: + * numbytes Number of bytes to allocate + * Returns: + * if (numbytes > 0) + * pointer to allocated data, NULL if out of memory + * else + * return NULL + */ + +void *mem_malloc(unsigned); +void *mem_calloc(unsigned); + +/***************************** + * Reallocate memory. + * Use: + * void *mem_realloc(void *ptr,unsigned numbytes); + */ + +void *mem_realloc(void *,unsigned); + +/***************************** + * Free memory allocated by mem_malloc(), mem_calloc() or mem_realloc(). + * Use: + * void mem_free(void *ptr); + */ + +void mem_free(void *); + +/*************************** + * Initialize memory handler. + * Use: + * void mem_init(void); + * Output: + * mem_inited = 1 + */ + +void mem_init(void); + +/*************************** + * Terminate memory handler. Useful for checking for errors. + * Use: + * void mem_term(void); + * Output: + * mem_inited = 0 + */ + +void mem_term(void); + +/******************************* + * The mem_fxxx() functions are for allocating memory that will persist + * until program termination. The trick is that if the memory is never + * free'd, we can do a very fast allocation. If MEM_DEBUG is on, they + * act just like the regular mem functions, so it can be debugged. + */ + +#if MEM_NONE +#define mem_fmalloc(u) malloc(u) +#define mem_fcalloc(u) calloc((u),1) +#define mem_ffree(p) ((void)0) +#define mem_fstrdup(p) strdup(p) +#else +#if MEM_DEBUG +#define mem_fmalloc mem_malloc +#define mem_fcalloc mem_calloc +#define mem_ffree mem_free +#define mem_fstrdup mem_strdup +#else +void *mem_fmalloc(unsigned); +void *mem_fcalloc(unsigned); +#define mem_ffree(p) ((void)0) +char *mem_fstrdup(const char *); +#endif +#endif + +/*********************************** + * C++ stuff. + */ + +#if !MEM_NONE && MEM_DEBUG +#define mem_new !(__mem_line=__LINE__,__mem_file=__FILE__)? 0 : new +#define mem_delete (__mem_line=__LINE__,__mem_file=__FILE__), delete + +extern int __mem_line; +extern char *__mem_file; +#endif + +/* The following stuff forms the implementation rather than the + * definition, so ignore it. + */ + +#if MEM_NONE + +#define mem_inited 1 +#define mem_strdup(p) strdup(p) +#define mem_malloc(u) malloc(u) +#define mem_calloc(u) calloc((u),1) +#define mem_realloc(p,u) realloc((p),(u)) +#define mem_free(p) free(p) +#define mem_freefp free +#define mem_check() ((void)0) +#define mem_checkptr(p) ((void)(p)) +#define mem_init() ((void)0) +#define mem_term() ((void)0) + +#include + +#else + +#if MEM_DEBUG /* if creating debug version */ +#define mem_strdup(p) mem_strdup_debug((p),__FILE__,__LINE__) +#define mem_malloc(u) mem_malloc_debug((u),__FILE__,__LINE__) +#define mem_calloc(u) mem_calloc_debug((u),__FILE__,__LINE__) +#define mem_realloc(p,u) mem_realloc_debug((p),(u),__FILE__,__LINE__) +#define mem_free(p) mem_free_debug((p),__FILE__,__LINE__) + +char *mem_strdup_debug (const char *,const char *,int); +void *mem_calloc_debug (unsigned,const char *,int); +void *mem_malloc_debug (unsigned,const char *,int); +void *mem_realloc_debug (void *,unsigned,const char *,int); +void mem_free_debug (void *,const char *,int); +void mem_freefp (void *); + +void mem_setnewfileline (void *,const char *,int); + +#else + +#define mem_freefp mem_free +#define mem_check() +#define mem_checkptr(p) + +#endif /* MEM_DEBUG */ +#endif /* MEM_NONE */ + +#endif /* MEM_H */ diff --git a/tk/vec.c b/tk/vec.c new file mode 100644 index 00000000..9f8c04f5 --- /dev/null +++ b/tk/vec.c @@ -0,0 +1,655 @@ +/*_ vec.c Mon Oct 31 1994 */ +/* Copyright (C) 1986-2000 by Digital Mars */ +/* Written by Walter Bright */ +/* Bit vector package */ + +#include +#include +#ifndef assert +#include +#endif +#include "vec.h" +#include "mem.h" + +static int vec_count; /* # of vectors allocated */ +static int vec_initcount = 0; /* # of times package is initialized */ + +#define VECMAX 20 +static vec_t vecfreelist[VECMAX]; + +#if 1 +#define MASK(b) (1 << ((b) & VECMASK)) +#else +#define MASK(b) bmask[(b) & VECMASK] +static unsigned bmask[VECMASK + 1] = +{ + 1,2,4,8,0x10,0x20,0x40,0x80, + 0x100,0x200,0x400,0x800,0x1000,0x2000,0x4000,0x8000, +#if __INTSIZE == 4 + 0x10000,0x20000,0x40000,0x80000,0x100000,0x200000,0x400000,0x800000, + 0x1000000,0x2000000,0x4000000,0x8000000, + 0x10000000,0x20000000,0x40000000,0x80000000 +#endif +}; +#endif + +/************************** + * Initialize package. + */ + +void vec_init() +{ + assert(sizeof(vec_base_t)==2&&VECSHIFT==4||sizeof(vec_base_t)==4&&VECSHIFT== 5); + if (vec_initcount++ == 0) + vec_count = 0; +} + +/************************** + * Terminate package. + */ + +void vec_term() +{ + if (--vec_initcount == 0) + { + +#ifdef DEBUG + if (vec_count != 0) + { + printf("vec_count = %d\n",vec_count); + assert(0); + } +#else + assert(vec_count == 0); +#endif +#if TERMCODE + int i; + for (i = 0; i < VECMAX; i++) + { void **v; + void **vn; + + for (v = (void **)vecfreelist[i]; v; v = vn) + { + vn = (void **)(*v); + mem_free(v); + } + vecfreelist[i] = NULL; + } +#endif + } +} + +/******************************** + * Allocate a vector given # of bits in it. + * Clear the vector. + */ + +vec_t vec_calloc(unsigned numbits) +{ vec_t v; + int dim; + + if (numbits == 0) + return (vec_t) NULL; + dim = (numbits + (VECBITS - 1)) >> VECSHIFT; + if (dim < VECMAX && (v = vecfreelist[dim]) != NULL) + { + vecfreelist[dim] = *(vec_t *)v; + v += 2; + switch (dim) + { + case 5: v[4] = 0; + case 4: v[3] = 0; + case 3: v[2] = 0; + case 2: v[1] = 0; + case 1: v[0] = 0; + break; + default: memset(v,0,dim * sizeof(vec_base_t)); + break; + } + goto L1; + } + else + { + v = (vec_t) mem_calloc((dim + 2) * sizeof(vec_base_t)); + } + if (v) + { + v += 2; + L1: + vec_dim(v) = dim; + vec_numbits(v) = numbits; + /*printf("vec_calloc(%d): v = %p vec_numbits = %d vec_dim = %d\n", + numbits,v,vec_numbits(v),vec_dim(v));*/ + vec_count++; + } + return v; +} + +/******************************** + * Allocate copy of existing vector. + */ + +vec_t vec_clone(vec_t v) +{ vec_t vc; + int dim; + unsigned nbytes; + + if (v) + { dim = vec_dim(v); + nbytes = (dim + 2) * sizeof(vec_base_t); + if (dim < VECMAX && (vc = vecfreelist[dim]) != NULL) + { + vecfreelist[dim] = *(vec_t *)vc; + goto L1; + } + else + { + vc = (vec_t) mem_calloc(nbytes); + } + if (vc) + { + L1: + memcpy(vc,v - 2,nbytes); + vec_count++; + v = vc + 2; + } + else + v = NULL; + } + return v; +} + +/************************** + * Free a vector. + */ + +void vec_free(vec_t v) +{ + /*printf("vec_free(%p)\n",v);*/ + if (v) + { int dim = vec_dim(v); + + v -= 2; + if (dim < VECMAX) + { + *(vec_t *)v = vecfreelist[dim]; + vecfreelist[dim] = v; + } + else + mem_free(v); + vec_count--; + } +} + +/************************** + * Realloc a vector to have numbits bits in it. + * Extra bits are set to 0. + */ + +vec_t vec_realloc(vec_t v,unsigned numbits) +{ vec_t newv; + unsigned vbits; + + /*printf("vec_realloc(%p,%d)\n",v,numbits);*/ + if (!v) + return vec_calloc(numbits); + if (!numbits) + { vec_free(v); + return NULL; + } + vbits = vec_numbits(v); + if (numbits == vbits) + return v; + newv = vec_calloc(numbits); + if (newv) + { unsigned nbytes; + + nbytes = (vec_dim(v) < vec_dim(newv)) ? vec_dim(v) : vec_dim(newv); + memcpy(newv,v,nbytes * sizeof(vec_base_t)); + vec_clearextrabits(newv); + } + vec_free(v); + return newv; +} + +/************************** + * Set bit b in vector v. + */ + +#ifndef vec_setbit + +#if _M_I86 && __INTSIZE == 4 && __SC__ +__declspec(naked) void __pascal vec_setbit(unsigned b,vec_t v) +{ + _asm + { + mov EAX,b-4[ESP] + mov ECX,v-4[ESP] + bts [ECX],EAX + ret 8 + } +} +#else +void vec_setbit(unsigned b,vec_t v) +{ +#ifdef DEBUG + if (!(v && b < vec_numbits(v))) + printf("vec_setbit(v = %p,b = %d): numbits = %d dim = %d\n", + v,b,v ? vec_numbits(v) : 0, v ? vec_dim(v) : 0); +#endif + assert(v && b < vec_numbits(v)); + *(v + (b >> VECSHIFT)) |= MASK(b); +} +#endif + +#endif + +/************************** + * Clear bit b in vector v. + */ + +#ifndef vec_clearbit + +#if _M_I86 && __INTSIZE == 4 && __SC__ +__declspec(naked) void __pascal vec_clearbit(unsigned b,vec_t v) +{ + _asm + { + mov EAX,b-4[ESP] + mov ECX,v-4[ESP] + btr [ECX],EAX + ret 8 + } +} +#else +void vec_clearbit(unsigned b,vec_t v) +{ + assert(v && b < vec_numbits(v)); + *(v + (b >> VECSHIFT)) &= ~MASK(b); +} +#endif + +#endif + +/************************** + * Test bit b in vector v. + */ + +#ifndef vec_testbit + +#if _M_I86 && __INTSIZE == 4 && __SC__ +__declspec(naked) int __pascal vec_testbit(unsigned b,vec_t v) +{ + _asm + { + mov EAX,v-4[ESP] + mov ECX,b-4[ESP] + test EAX,EAX + jz L1 + bt [EAX],ECX + sbb EAX,EAX + L1: ret 8 + } +} +#else +int vec_testbit(unsigned b,vec_t v) +{ + if (!v) + return 0; +#ifdef DEBUG + if (b >= vec_numbits(v)) + { printf("vec_testbit(v = %p,b = %d): numbits = %d dim = %d\n", + v,b,vec_numbits(v),vec_dim(v)); + b = (unsigned)-1; + } +#endif + assert(b < vec_numbits(v)); +#if __I86__ >= 3 && __SC__ + _asm + { +#if __INTSIZE == 4 + mov EAX,b + mov ECX,v + bt [ECX],EAX + sbb EAX,EAX +#elif __COMPACT__ || __LARGE__ || __VCM__ + mov AX,b + les BX,v + bt ES:[BX],AX + sbb AX,AX +#else + mov AX,b + mov CX,v + bt [CX],AX + sbb AX,AX +#endif + } +#ifdef DEBUG + { int x = _AX; + assert((x != 0) == ((*(v + (b >> VECSHIFT)) & MASK(b)) != 0)); + } +#endif +#else + return *(v + (b >> VECSHIFT)) & MASK(b); +#endif +} +#endif + +#endif + +/******************************** + * Find first set bit starting from b in vector v. + * If no bit is found, return vec_numbits(v). + */ + +unsigned vec_index(unsigned b,vec_t vec) +{ register unsigned starv; + register vec_t v,vtop; + unsigned bit; + + if (!vec) + return 0; + v = vec; + if (b < vec_numbits(v)) + { vtop = &vec[vec_dim(v)]; + bit = b & VECMASK; + if (bit != b) /* if not starting in first word */ + v += b >> VECSHIFT; + starv = *v >> bit; + while (1) + { + while (starv) + { if (starv & 1) + return b; + b++; + starv >>= 1; + } + b = (b + VECBITS) & ~VECMASK; /* round up to next word */ + if (++v >= vtop) + break; + starv = *v; + } + } + return vec_numbits(vec); +} + +/******************************** + * Compute v1 &= v2. + */ + +void vec_andass(vec_t v1,vec_t v2) +{ vec_t vtop; + + if (v1) + { + assert(v2); + assert(vec_numbits(v1)==vec_numbits(v2)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++) + *v1 &= *v2; + } + else + assert(!v2); +} + +/******************************** + * Compute v1 = v2 & v3. + */ + +void vec_and(vec_t v1,vec_t v2,vec_t v3) +{ vec_t vtop; + + if (v1) + { + assert(v2 && v3); + assert(vec_numbits(v1)==vec_numbits(v2) && vec_numbits(v1)==vec_numbits(v3)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++,v3++) + *v1 = *v2 & *v3; + } + else + assert(!v2 && !v3); +} + +/******************************** + * Compute v1 ^= v2. + */ + +void vec_xorass(vec_t v1,vec_t v2) +{ vec_t vtop; + + if (v1) + { + assert(v2); + assert(vec_numbits(v1)==vec_numbits(v2)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++) + *v1 ^= *v2; + } + else + assert(!v2); +} + +/******************************** + * Compute v1 = v2 ^ v3. + */ + +void vec_xor(vec_t v1,vec_t v2,vec_t v3) +{ vec_t vtop; + + if (v1) + { + assert(v2 && v3); + assert(vec_numbits(v1)==vec_numbits(v2) && vec_numbits(v1)==vec_numbits(v3)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++,v3++) + *v1 = *v2 ^ *v3; + } + else + assert(!v2 && !v3); +} + +/******************************** + * Compute v1 |= v2. + */ + +void vec_orass(vec_t v1,vec_t v2) +{ vec_t vtop; + + if (v1) + { +#ifdef DEBUG + assert(v2); + assert(vec_numbits(v1)==vec_numbits(v2)); +#endif + vtop = &v1[vec_dim(v1)]; +#if __INTSIZE == 2 && __I86__ && (__COMPACT__ || __LARGE__ || __VCM__) + _asm + { + push DS + lds SI,v2 + les DI,v1 + mov CX,word ptr vtop + cmp CX,DI + jz L1 + L2: mov AX,[SI] + add SI,2 + or ES:[DI],AX + add DI,2 + cmp DI,CX + jb L2 + L1: pop DS + #if __SC__ <= 0x610 + jmp Lret + #endif + } +#else + for (; v1 < vtop; v1++,v2++) + *v1 |= *v2; +#endif + } + else + assert(!v2); +} + +/******************************** + * Compute v1 = v2 | v3. + */ + +void vec_or(vec_t v1,vec_t v2,vec_t v3) +{ vec_t vtop; + + if (v1) + { + assert(v2 && v3); + assert(vec_numbits(v1)==vec_numbits(v2) && vec_numbits(v1)==vec_numbits(v3)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++,v3++) + *v1 = *v2 | *v3; + } + else + assert(!v2 && !v3); +} + +/******************************** + * Compute v1 -= v2. + */ + +void vec_subass(vec_t v1,vec_t v2) +{ vec_t vtop; + + if (v1) + { + assert(v2); + assert(vec_numbits(v1)==vec_numbits(v2)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++) + *v1 &= ~*v2; + } + else + assert(!v2); +} + +/******************************** + * Compute v1 = v2 - v3. + */ + +void vec_sub(vec_t v1,vec_t v2,vec_t v3) +{ vec_t vtop; + + if (v1) + { + assert(v2 && v3); + assert(vec_numbits(v1)==vec_numbits(v2) && vec_numbits(v1)==vec_numbits(v3)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++,v3++) + *v1 = *v2 & ~*v3; + } + else + assert(!v2 && !v3); +} + +/**************** + * Clear vector. + */ + +void vec_clear(vec_t v) +{ + if (v) + memset(v,0,sizeof(v[0]) * vec_dim(v)); +} + +/**************** + * Set vector. + */ + +void vec_set(vec_t v) +{ + if (v) + { memset(v,~0,sizeof(v[0]) * vec_dim(v)); + vec_clearextrabits(v); + } +} + +/*************** + * Copy vector. + */ + +void vec_copy(vec_t to,vec_t from) +{ + if (to != from) + { +#ifdef DEBUG + if (!(to && from && vec_numbits(to) == vec_numbits(from))) + printf("to = x%lx, from = x%lx, numbits(to) = %d, numbits(from) = %d\n", + (long)to,(long)from,to ? vec_numbits(to) : 0, from ? vec_numbits(from): 0); +#endif + assert(to && from && vec_numbits(to) == vec_numbits(from)); + memcpy(to,from,sizeof(to[0]) * vec_dim(to)); + } +} + +/**************** + * Return 1 if vectors are equal. + */ + +int vec_equal(vec_t v1,vec_t v2) +{ + if (v1 == v2) + return 1; + assert(v1 && v2 && vec_numbits(v1) == vec_numbits(v2)); + return !memcmp(v1,v2,sizeof(v1[0]) * vec_dim(v1)); +} + +/******************************** + * Return 1 if (v1 & v2) == 0 + */ + +int vec_disjoint(vec_t v1,vec_t v2) +{ vec_t vtop; + + assert(v1 && v2); + assert(vec_numbits(v1)==vec_numbits(v2)); + vtop = &v1[vec_dim(v1)]; + for (; v1 < vtop; v1++,v2++) + if (*v1 & *v2) + return 0; + return 1; +} + +/********************* + * Clear any extra bits in vector. + */ + +void vec_clearextrabits(vec_t v) +{ unsigned n; + + assert(v); + n = vec_numbits(v); + if (n & VECMASK) + v[vec_dim(v) - 1] &= MASK(n) - 1; +} + +/****************** + * Write out vector. + */ + +void vec_println(vec_t v) +{ +#ifdef DEBUG + vec_print(v); + fputc('\n',stdout); +#endif +} + +void vec_print(vec_t v) +{ +#ifdef DEBUG + printf(" Vec %p, numbits %d dim %d",v,vec_numbits(v),vec_dim(v)); + if (v) + { fputc('\t',stdout); + for (unsigned i = 0; i < vec_numbits(v); i++) + fputc((vec_testbit(i,v)) ? '1' : '0',stdout); + } +#endif +} diff --git a/tk/vec.h b/tk/vec.h new file mode 100644 index 00000000..77429c9c --- /dev/null +++ b/tk/vec.h @@ -0,0 +1,78 @@ +/*_ vec.h Mon Oct 31 1994 */ + +#ifndef VEC_H +#define VEC_H + +#if __SC__ +#pragma once +#endif + +typedef unsigned vec_base_t; /* base type of vector */ +typedef vec_base_t *vec_t; + +#define vec_numbits(v) ((v)[-1]) +#define vec_dim(v) ((v)[-2]) + +#define VECBITS (sizeof(vec_base_t)*8) /* # of bits per entry */ +#define VECMASK (VECBITS - 1) /* mask for bit position */ +#define VECSHIFT ((VECBITS == 16) ? 4 : 5) /* # of bits in VECMASK */ + +void vec_init (void); +void vec_term (void); +vec_t vec_calloc (unsigned numbits); +vec_t vec_clone (vec_t v); +void vec_free (vec_t v); +vec_t vec_realloc (vec_t v , unsigned numbits); +#if _M_I86 && __INTSIZE == 4 && __SC__ +void __pascal vec_setbit (unsigned b , vec_t v); +void __pascal vec_clearbit (unsigned b , vec_t v); +int __pascal vec_testbit (unsigned b , vec_t v); +#else +void vec_setbit (unsigned b , vec_t v); +void vec_clearbit (unsigned b , vec_t v); +int vec_testbit (unsigned b , vec_t v); +#endif +unsigned vec_index (unsigned b , vec_t vec); +void vec_andass (vec_t v1 , vec_t v2); +void vec_and (vec_t v1 , vec_t v2 , vec_t v3); +void vec_xorass (vec_t v1 , vec_t v2); +void vec_xor (vec_t v1 , vec_t v2 , vec_t v3); +void vec_orass (vec_t v1 , vec_t v2); +void vec_or (vec_t v1 , vec_t v2 , vec_t v3); +void vec_subass (vec_t v1 , vec_t v2); +void vec_sub (vec_t v1 , vec_t v2 , vec_t v3); +void vec_clear (vec_t v); +void vec_set (vec_t v); +void vec_copy (vec_t to , vec_t from); +int vec_equal (vec_t v1 , vec_t v2); +int vec_disjoint (vec_t v1 , vec_t v2); +void vec_clearextrabits (vec_t v); +void vec_print (vec_t v); +void vec_println (vec_t v); + +#if _M_I86 && __INTSIZE == 4 +#define vec_setclear(b,vs,vc) { \ + __asm mov EAX,b \ + __asm mov ECX,vs \ + __asm bts [ECX],EAX \ + __asm mov ECX,vc \ + __asm btr [ECX],EAX \ + } +#else +#define vec_setclear(b,vs,vc) (vec_setbit((b),(vs)),vec_clearbit((b),(vc))) +#endif + +// Loop through all the bits that are set in vector v of size t: +#define foreach(i,t,v) for((i)=0;((i)=vec_index((i),(v))), (i) < (t); (i)++) + +#if __DMC__ +// Digital Mars inlines some bit operations +#include + +#define vec_setbit(b, v) _inline_bts(v, b) +#define vec_clearbit(b, v) _inline_btr(v, b) +#define vec_testbit(b, v) (v && _inline_bt(v, b)) +#endif + +#endif /* VEC_H */ + diff --git a/tocsym.c b/tocsym.c new file mode 100644 index 00000000..1d614a1c --- /dev/null +++ b/tocsym.c @@ -0,0 +1,804 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "lexer.h" +#include "dsymbol.h" +#include "id.h" + +#include "rmem.h" + +// Back end +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +void slist_add(Symbol *s); +void slist_reset(); + +Classsym *fake_classsym(Identifier *id); + +/********************************* SymbolDeclaration ****************************/ + +SymbolDeclaration::SymbolDeclaration(Loc loc, Symbol *s, StructDeclaration *dsym) + : Declaration(new Identifier(s->Sident, TOKidentifier)) +{ + this->loc = loc; + sym = s; + this->dsym = dsym; + storage_class |= STCconst; +} + +Symbol *SymbolDeclaration::toSymbol() +{ + return sym; +} + +/************************************* + * Helper + */ + +Symbol *Dsymbol::toSymbolX(const char *prefix, int sclass, type *t, const char *suffix) +{ + Symbol *s; + char *id; + const char *n; + size_t nlen; + + //printf("Dsymbol::toSymbolX('%s')\n", prefix); + n = mangle(); + assert(n); + nlen = strlen(n); +#if 0 + if (nlen > 2 && n[0] == '_' && n[1] == 'D') + { + nlen -= 2; + n += 2; + } +#endif + id = (char *) alloca(2 + nlen + sizeof(size_t) * 3 + strlen(prefix) + strlen(suffix) + 1); + sprintf(id,"_D%s%zu%s%s", n, strlen(prefix), prefix, suffix); +#if 0 + if (global.params.isWindows && + (type_mangle(t) == mTYman_c || type_mangle(t) == mTYman_std)) + id++; // Windows C mangling will put the '_' back in +#endif + s = symbol_name(id, sclass, t); + //printf("-Dsymbol::toSymbolX() %s\n", id); + return s; +} + +/************************************* + */ + +Symbol *Dsymbol::toSymbol() +{ + printf("Dsymbol::toSymbol() '%s', kind = '%s'\n", toChars(), kind()); +#ifdef DEBUG + halt(); +#endif + assert(0); // BUG: implement + return NULL; +} + +/********************************* + * Generate import symbol from symbol. + */ + +Symbol *Dsymbol::toImport() +{ + if (!isym) + { + if (!csym) + csym = toSymbol(); + isym = toImport(csym); + } + return isym; +} + +/************************************* + */ + +Symbol *Dsymbol::toImport(Symbol *sym) +{ + char *id; + char *n; + Symbol *s; + type *t; + + //printf("Dsymbol::toImport('%s')\n", sym->Sident); + n = sym->Sident; + id = (char *) alloca(6 + strlen(n) + 1 + sizeof(type_paramsize(sym->Stype))*3 + 1); + if (sym->Stype->Tmangle == mTYman_std && tyfunc(sym->Stype->Tty)) + { + sprintf(id,"_imp__%s@%lu",n,(unsigned long)type_paramsize(sym->Stype)); + } + else if (sym->Stype->Tmangle == mTYman_d) + sprintf(id,"_imp_%s",n); + else + sprintf(id,"_imp__%s",n); + t = type_alloc(TYnptr | mTYconst); + t->Tnext = sym->Stype; + t->Tnext->Tcount++; + t->Tmangle = mTYman_c; + t->Tcount++; + s = symbol_calloc(id); + s->Stype = t; + s->Sclass = SCextern; + s->Sfl = FLextern; + slist_add(s); + return s; +} + +/************************************* + */ + +Symbol *VarDeclaration::toSymbol() +{ + //printf("VarDeclaration::toSymbol(%s)\n", toChars()); + //if (needThis()) *(char*)0=0; + assert(!needThis()); + if (!csym) + { Symbol *s; + TYPE *t; + const char *id; + + if (isDataseg()) + id = mangle(); + else + id = ident->toChars(); + s = symbol_calloc(id); + + if (storage_class & (STCout | STCref)) + { + if (global.params.symdebug && storage_class & STCparameter) + { + t = type_alloc(TYnptr); // should be TYref, but problems in back end + t->Tnext = type->toCtype(); + t->Tnext->Tcount++; + } + else + t = type_fake(TYnptr); + } + else if (storage_class & STClazy) + t = type_fake(TYdelegate); // Tdelegate as C type + else if (isParameter()) + t = type->toCParamtype(); + 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(stdmsg, "%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; + break; + + default: + printf("linkage = %d\n", linkage); + assert(0); + } + type_setmangle(&t, m); + s->Stype = t; + + csym = s; + } + return csym; +} + +/************************************* + */ + +Symbol *ClassInfoDeclaration::toSymbol() +{ + return cd->toSymbol(); +} + +/************************************* + */ + +Symbol *ModuleInfoDeclaration::toSymbol() +{ + return mod->toSymbol(); +} + +/************************************* + */ + +Symbol *TypeInfoDeclaration::toSymbol() +{ + //printf("TypeInfoDeclaration::toSymbol(%s), linkage = %d\n", toChars(), linkage); + return VarDeclaration::toSymbol(); +} + +/************************************* + */ + +Symbol *TypeInfoClassDeclaration::toSymbol() +{ + //printf("TypeInfoClassDeclaration::toSymbol(%s), linkage = %d\n", toChars(), linkage); + assert(tinfo->ty == Tclass); + TypeClass *tc = (TypeClass *)tinfo; + return tc->sym->toSymbol(); +} + +/************************************* + */ + +Symbol *FuncAliasDeclaration::toSymbol() +{ + return funcalias->toSymbol(); +} + +/************************************* + */ + +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()) + f->Fflags |= Fvirtual; + else if (isMember2()) + 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 TARGET_WINDOS + if (isThis()) + t->Tty = TYmfunc; +#endif + s->Sflags |= SFLpublic; + Dsymbol *parent = toParent(); + ClassDeclaration *cd = parent->isClassDeclaration(); + if (cd) + { + ::type *tc = cd->type->toCtype(); + s->Sscope = tc->Tnext->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 *FuncDeclaration::toThunkSymbol(int offset) +{ + Symbol *sthunk; + + toSymbol(); + +#if 0 + char *id; + char *n; + type *t; + + n = sym->Sident; + id = (char *) alloca(8 + 5 + strlen(n) + 1); + sprintf(id,"_thunk%d__%s", offset, n); + s = symbol_calloc(id); + slist_add(s); + s->Stype = csym->Stype; + s->Stype->Tcount++; +#endif + sthunk = symbol_generate(SCstatic, csym->Stype); + sthunk->Sflags |= SFLimplem; + cod3_thunk(sthunk, csym, 0, TYnptr, -offset, -1, 0); + return sthunk; +} + + +/**************************************** + * Create a static symbol we can hang DT initializers onto. + */ + +Symbol *static_sym() +{ + Symbol *s; + type *t; + + t = type_alloc(TYint); + t->Tcount++; + s = symbol_calloc("internal"); + s->Sclass = SCstatic; + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + s->Stype = t; +#if ELFOBJ || MACHOBJ + s->Sseg = DATA; +#endif + slist_add(s); + return s; +} + +/************************************** + * Fake a struct symbol. + */ + +Classsym *fake_classsym(Identifier *id) +{ TYPE *t; + Classsym *scc; + + scc = (Classsym *)symbol_calloc(id->toChars()); + scc->Sclass = SCstruct; + scc->Sstruct = struct_calloc(); + scc->Sstruct->Sstructalign = 8; + //scc->Sstruct->ptrtype = TYnptr; + scc->Sstruct->Sflags = STRglobal; + + t = type_alloc(TYstruct); + t->Tflags |= TFsizeunknown | TFforward; + t->Ttag = scc; // structure tag name + assert(t->Tmangle == 0); + t->Tmangle = mTYman_d; + t->Tcount++; + scc->Stype = t; + slist_add(scc); + return scc; +} + +/************************************* + * Create the "ClassInfo" symbol + */ + +static Classsym *scc; + +Symbol *ClassDeclaration::toSymbol() +{ + if (!csym) + { + Symbol *s; + + if (!scc) + scc = fake_classsym(Id::ClassInfo); + + s = toSymbolX("__Class", SCextern, scc->Stype, "Z"); + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + csym = s; + slist_add(s); + } + return csym; +} + +/************************************* + * Create the "InterfaceInfo" symbol + */ + +Symbol *InterfaceDeclaration::toSymbol() +{ + if (!csym) + { + Symbol *s; + + if (!scc) + scc = fake_classsym(Id::ClassInfo); + + s = toSymbolX("__Interface", SCextern, scc->Stype, "Z"); + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + csym = s; + slist_add(s); + } + return csym; +} + +/************************************* + * Create the "ModuleInfo" symbol + */ + +Symbol *Module::toSymbol() +{ + if (!csym) + { + if (!scc) + scc = fake_classsym(Id::ClassInfo); + + Symbol *s = toSymbolX("__ModuleInfo", SCextern, scc->Stype, "Z"); + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + csym = s; + slist_add(s); + } + return csym; +} + +/************************************* + * This is accessible via the ClassData, but since it is frequently + * needed directly (like for rtti comparisons), make it directly accessible. + */ + +Symbol *ClassDeclaration::toVtblSymbol() +{ + if (!vtblsym) + { + Symbol *s; + TYPE *t; + + if (!csym) + toSymbol(); + + t = type_alloc(TYnptr | mTYconst); + t->Tnext = tsvoid; + t->Tnext->Tcount++; + t->Tmangle = mTYman_d; + s = toSymbolX("__vtbl", SCextern, t, "Z"); + s->Sflags |= SFLnodebug; + s->Sfl = FLextern; + vtblsym = s; + slist_add(s); + } + return vtblsym; +} + +/********************************** + * Create the static initializer for the struct/class. + */ + +Symbol *AggregateDeclaration::toInitializer() +{ + Symbol *s; + Classsym *stag; + + if (!sinit) + { + stag = fake_classsym(Id::ClassInfo); + s = toSymbolX("__init", SCextern, stag->Stype, "Z"); + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + slist_add(s); + sinit = s; + } + return sinit; +} + +Symbol *TypedefDeclaration::toInitializer() +{ + Symbol *s; + Classsym *stag; + + if (!sinit) + { + stag = fake_classsym(Id::ClassInfo); + s = toSymbolX("__init", SCextern, stag->Stype, "Z"); + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + slist_add(s); + sinit = s; + } + return sinit; +} + +Symbol *EnumDeclaration::toInitializer() +{ + Symbol *s; + Classsym *stag; + + if (!sinit) + { + stag = fake_classsym(Id::ClassInfo); + Identifier *ident_save = ident; + if (!ident) + ident = Lexer::uniqueId("__enum"); + s = toSymbolX("__init", SCextern, stag->Stype, "Z"); + ident = ident_save; + s->Sfl = FLextern; + s->Sflags |= SFLnodebug; + slist_add(s); + sinit = s; + } + return sinit; +} + + +/****************************************** + */ + +Symbol *Module::toModuleAssert() +{ + if (!massert) + { + type *t; + + t = type_alloc(TYjfunc); + t->Tflags |= TFprototype | TFfixed; + t->Tmangle = mTYman_d; + t->Tnext = tsvoid; + tsvoid->Tcount++; + + massert = toSymbolX("__assert", SCextern, t, "FiZv"); + massert->Sfl = FLextern; + massert->Sflags |= SFLnodebug; + slist_add(massert); + } + return massert; +} + +Symbol *Module::toModuleUnittest() +{ + if (!munittest) + { + type *t; + + t = type_alloc(TYjfunc); + t->Tflags |= TFprototype | TFfixed; + t->Tmangle = mTYman_d; + t->Tnext = tsvoid; + tsvoid->Tcount++; + + munittest = toSymbolX("__unittest_fail", SCextern, t, "FiZv"); + munittest->Sfl = FLextern; + munittest->Sflags |= SFLnodebug; + slist_add(munittest); + } + return munittest; +} + +/****************************************** + */ + +Symbol *Module::toModuleArray() +{ + if (!marray) + { + type *t; + + t = type_alloc(TYjfunc); + t->Tflags |= TFprototype | TFfixed; + t->Tmangle = mTYman_d; + t->Tnext = tsvoid; + tsvoid->Tcount++; + + marray = toSymbolX("__array", SCextern, t, "Z"); + marray->Sfl = FLextern; + marray->Sflags |= SFLnodebug; + slist_add(marray); + } + return marray; +} + +/******************************************** + * Determine the right symbol to look up + * an associative array element. + * Input: + * flags 0 don't add value signature + * 1 add value signature + */ + +Symbol *TypeAArray::aaGetSymbol(const char *func, int flags) +#if __DMC__ + __in + { + assert(func); + assert((flags & ~1) == 0); + } + __out (result) + { + assert(result); + } + __body +#endif + { + // Dumb linear symbol table - should use associative array! + static Symbols *sarray = NULL; + + //printf("aaGetSymbol(func = '%s', flags = %d, key = %p)\n", func, flags, key); +#if 0 + OutBuffer buf; + key->toKeyBuffer(&buf); + + sz = next->size(); // it's just data, so we only care about the size + sz = (sz + 3) & ~3; // reduce proliferation of library routines + char *id = (char *)alloca(3 + strlen(func) + buf.offset + sizeof(sz) * 3 + 1); + buf.writeByte(0); + if (flags & 1) + sprintf(id, "_aa%s%s%d", func, buf.data, sz); + else + sprintf(id, "_aa%s%s", func, buf.data); +#else + char *id = (char *)alloca(3 + strlen(func) + 1); + sprintf(id, "_aa%s", func); +#endif + if (!sarray) + sarray = new Symbols(); + + // See if symbol is already in sarray + for (size_t i = 0; i < sarray->dim; i++) + { Symbol *s = (*sarray)[i]; + if (strcmp(id, s->Sident) == 0) + return s; // use existing Symbol + } + + // Create new Symbol + + Symbol *s = symbol_calloc(id); + slist_add(s); + s->Sclass = SCextern; + s->Ssymnum = -1; + symbol_func(s); + + type *t = type_alloc(TYnfunc); + t->Tflags = TFprototype | TFfixed; + t->Tmangle = mTYman_c; + t->Tparamtypes = NULL; + t->Tnext = next->toCtype(); + t->Tnext->Tcount++; + t->Tcount++; + s->Stype = t; + + sarray->push(s); // remember it + return s; + } + diff --git a/toctype.c b/toctype.c new file mode 100644 index 00000000..db41b3b4 --- /dev/null +++ b/toctype.c @@ -0,0 +1,517 @@ + +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// http://www.dsource.org/projects/dmd/browser/trunk/src/toctype.c +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#if __sun&&__SVR4 +#include +#endif + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "id.h" +#include "import.h" +#include "template.h" + +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +void out_config_init(); +void slist_add(Symbol *s); +void slist_reset(); + + +/*************************************** + * Convert from D type to C type. + * This is done so C debug info can be generated. + */ + +type *Type::toCtype() +{ + if (!ctype) + { ctype = type_fake(totym()); + ctype->Tcount++; + } + return ctype; +} + +type *Type::toCParamtype() +{ + return toCtype(); +} + +type *TypeSArray::toCParamtype() +{ +#if SARRAYVALUE + return toCtype(); +#else + // arrays are passed as pointers + return next->pointerTo()->toCtype(); +#endif +} + +type *TypeSArray::toCtype() +{ + if (!ctype) + { type *tn; + + tn = next->toCtype(); + ctype = type_allocn(TYarray, tn); + ctype->Tdim = dim->toInteger(); + } + return ctype; +} + +type *TypeDArray::toCtype() +{ type *t; + + if (ctype) + return ctype; + + if (0 && global.params.symdebug) + { + /* Create a C type out of: + * struct _Array_T { size_t length; T* data; } + */ + Symbol *s; + char *id; + + assert(next->deco); + id = (char *) alloca(7 + strlen(next->deco) + 1); + sprintf(id, "_Array_%s", next->deco); + s = symbol_calloc(id); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= 0; + s->Sstruct->Salignsize = alignsize(); + s->Sstruct->Sstructalign = global.structalign; + s->Sstruct->Sstructsize = size(0); + slist_add(s); + + Symbol *s1 = symbol_name("length", SCmember, Type::tsize_t->toCtype()); + list_append(&s->Sstruct->Sfldlst, s1); + + Symbol *s2 = symbol_name("data", SCmember, next->pointerTo()->toCtype()); + s2->Smemoff = Type::tsize_t->size(); + list_append(&s->Sstruct->Sfldlst, s2); + + t = type_alloc(TYstruct); + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + s->Stype = t; + } + else + { + if (global.params.symdebug == 1) + { + // Generate D symbolic debug info, rather than C + t = type_allocn(TYdarray, next->toCtype()); + } + else + t = type_fake(TYdarray); + } + t->Tcount++; + ctype = t; + return t; +} + + +type *TypeAArray::toCtype() +{ type *t; + + if (ctype) + return ctype; + + if (0 && global.params.symdebug) + { + /* An associative array is represented by: + * struct AArray { size_t length; void* ptr; } + */ + + static Symbol *s; + + if (!s) + { + s = symbol_calloc("_AArray"); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= 0; + s->Sstruct->Salignsize = alignsize(); + s->Sstruct->Sstructalign = global.structalign; + s->Sstruct->Sstructsize = size(0); + slist_add(s); + + Symbol *s1 = symbol_name("length", SCmember, Type::tsize_t->toCtype()); + list_append(&s->Sstruct->Sfldlst, s1); + + Symbol *s2 = symbol_name("data", SCmember, Type::tvoidptr->toCtype()); + s2->Smemoff = Type::tsize_t->size(); + list_append(&s->Sstruct->Sfldlst, s2); + } + + t = type_alloc(TYstruct); + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + s->Stype = t; + } + else + { + if (global.params.symdebug == 1) + { + /* Generate D symbolic debug info, rather than C + * Tnext: element type + * Tkey: key type + */ + t = type_allocn(TYaarray, next->toCtype()); + t->Tkey = index->toCtype(); + t->Tkey->Tcount++; + } + else + t = type_fake(TYaarray); + } + t->Tcount++; + ctype = t; + return t; +} + + +type *TypePointer::toCtype() +{ type *tn; + type *t; + + //printf("TypePointer::toCtype() %s\n", toChars()); + if (ctype) + return ctype; + + if (1 || global.params.symdebug) + { /* Need to always do this, otherwise C++ name mangling + * goes awry. + */ + t = type_alloc(TYnptr); + ctype = t; + tn = next->toCtype(); + t->Tnext = tn; + tn->Tcount++; + } + else + t = type_fake(totym()); + t->Tcount++; + ctype = t; + return t; +} + +type *TypeFunction::toCtype() +{ type *t; + + if (ctype) + return ctype; + + if (1) + { + param_t *paramtypes = NULL; + size_t nparams = Parameter::dim(parameters); + for (size_t i = 0; i < nparams; i++) + { Parameter *arg = Parameter::getNth(parameters, i); + type *tp = arg->type->toCtype(); + if (arg->storageClass & (STCout | STCref)) + { // C doesn't have reference types, so it's really a pointer + // to the parameter type + tp = type_allocn(TYref, tp); + } + param_append_type(¶mtypes,tp); + } + tym_t tyf = totym(); + t = type_alloc(tyf); + t->Tflags |= TFprototype; + if (varargs != 1) + t->Tflags |= TFfixed; + ctype = t; + assert(next); // function return type should exist + t->Tnext = next->toCtype(); + t->Tnext->Tcount++; + t->Tparamtypes = paramtypes; + } + ctype = t; + return t; +} + +type *TypeDelegate::toCtype() +{ type *t; + + if (ctype) + return ctype; + + if (0 && global.params.symdebug) + { + /* A delegate consists of: + * _Delegate { void* frameptr; Function *funcptr; } + */ + + static Symbol *s; + + if (!s) + { + s = symbol_calloc("_Delegate"); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= 0; + s->Sstruct->Salignsize = alignsize(); + s->Sstruct->Sstructalign = global.structalign; + s->Sstruct->Sstructsize = size(0); + slist_add(s); + + Symbol *s1 = symbol_name("frameptr", SCmember, Type::tvoidptr->toCtype()); + list_append(&s->Sstruct->Sfldlst, s1); + + Symbol *s2 = symbol_name("funcptr", SCmember, Type::tvoidptr->toCtype()); + s2->Smemoff = Type::tvoidptr->size(); + list_append(&s->Sstruct->Sfldlst, s2); + } + + t = type_alloc(TYstruct); + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + s->Stype = t; + } + else + { + if (global.params.symdebug == 1) + { + // Generate D symbolic debug info, rather than C + t = type_allocn(TYdelegate, next->toCtype()); + } + else + t = type_fake(TYdelegate); + } + + t->Tcount++; + ctype = t; + return t; +} + + +type *TypeStruct::toCtype() +{ + if (ctype) + return ctype; + + //printf("TypeStruct::toCtype() '%s'\n", sym->toChars()); + type *t = type_alloc(TYstruct); + Type *tm = mutableOf(); + if (tm->ctype) + { + Symbol *s = tm->ctype->Ttag; + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + // Add modifiers + switch (mod) + { + case 0: + assert(0); + break; + case MODconst: + case MODwild: + t->Tty |= mTYconst; + break; + case MODimmutable: + t->Tty |= mTYimmutable; + break; + case MODshared: + t->Tty |= mTYshared; + break; + case MODshared | MODwild: + case MODshared | MODconst: + t->Tty |= mTYshared | mTYconst; + break; + default: + assert(0); + } + ctype = t; + } + else + { + Symbol *s = symbol_calloc(sym->toPrettyChars()); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= 0; + s->Sstruct->Salignsize = sym->alignsize; + s->Sstruct->Sstructalign = sym->alignsize; + s->Sstruct->Sstructsize = sym->structsize; + + if (sym->isUnionDeclaration()) + s->Sstruct->Sflags |= STRunion; + + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + s->Stype = t; + slist_add(s); + tm->ctype = t; + ctype = t; + + /* Add in fields of the struct + * (after setting ctype to avoid infinite recursion) + */ + if (global.params.symdebug) + for (size_t i = 0; i < sym->fields.dim; i++) + { VarDeclaration *v = sym->fields.tdata()[i]; + + Symbol *s2 = symbol_name(v->ident->toChars(), SCmember, v->type->toCtype()); + s2->Smemoff = v->offset; + list_append(&s->Sstruct->Sfldlst, s2); + } + } + + //printf("t = %p, Tflags = x%x\n", t, t->Tflags); + return t; +} + +type *TypeEnum::toCtype() +{ + if (ctype) + return ctype; + + //printf("TypeEnum::toCtype() '%s'\n", sym->toChars()); + type *t; + Type *tm = mutableOf(); + if (tm->ctype && tybasic(tm->ctype->Tty) == TYenum) + { + Symbol *s = tm->ctype->Ttag; + assert(s); + t = type_alloc(TYenum); + t->Ttag = (Classsym *)s; // enum tag name + t->Tcount++; + t->Tnext = tm->ctype->Tnext; + t->Tnext->Tcount++; + // Add modifiers + switch (mod) + { + case 0: + assert(0); + break; + case MODconst: + case MODwild: + t->Tty |= mTYconst; + break; + case MODimmutable: + t->Tty |= mTYimmutable; + break; + case MODshared: + t->Tty |= mTYshared; + break; + case MODshared | MODwild: + case MODshared | MODconst: + t->Tty |= mTYshared | mTYconst; + break; + default: + assert(0); + } + ctype = t; + } + else if (sym->memtype->toBasetype()->ty == Tint32) + { + Symbol *s = symbol_calloc(sym->toPrettyChars()); + s->Sclass = SCenum; + s->Senum = (enum_t *) MEM_PH_CALLOC(sizeof(enum_t)); + s->Senum->SEflags |= SENforward; // forward reference + slist_add(s); + + t = type_alloc(TYenum); + t->Ttag = (Classsym *)s; // enum tag name + t->Tcount++; + t->Tnext = sym->memtype->toCtype(); + t->Tnext->Tcount++; + s->Stype = t; + slist_add(s); + tm->ctype = t; + ctype = t; + } + else + { + t = ctype = sym->memtype->toCtype(); + } + + //printf("t = %p, Tflags = x%x\n", t, t->Tflags); + return t; +} + +type *TypeTypedef::toCtype() +{ + return sym->basetype->toCtype(); +} + +type *TypeTypedef::toCParamtype() +{ + return sym->basetype->toCParamtype(); +} + +type *TypeClass::toCtype() +{ type *t; + Symbol *s; + + //printf("TypeClass::toCtype() %s\n", toChars()); + if (ctype) + return ctype; + + /* Need this symbol to do C++ name mangling + */ + const char *name = sym->isCPPinterface() ? sym->ident->toChars() + : sym->toPrettyChars(); + s = symbol_calloc(name); + s->Sclass = SCstruct; + s->Sstruct = struct_calloc(); + s->Sstruct->Sflags |= STRclass; + s->Sstruct->Salignsize = sym->alignsize; + s->Sstruct->Sstructalign = sym->structalign; + s->Sstruct->Sstructsize = sym->structsize; + + t = type_alloc(TYstruct); + t->Ttag = (Classsym *)s; // structure tag name + t->Tcount++; + s->Stype = t; + slist_add(s); + + t = type_allocn(TYnptr, t); + + t->Tcount++; + ctype = t; + + /* Add in fields of the class + * (after setting ctype to avoid infinite recursion) + */ + if (global.params.symdebug) + for (size_t i = 0; i < sym->fields.dim; i++) + { VarDeclaration *v = sym->fields.tdata()[i]; + + Symbol *s2 = symbol_name(v->ident->toChars(), SCmember, v->type->toCtype()); + s2->Smemoff = v->offset; + list_append(&s->Sstruct->Sfldlst, s2); + } + + return t; +} + diff --git a/tocvdebug.c b/tocvdebug.c new file mode 100644 index 00000000..e54bfeb0 --- /dev/null +++ b/tocvdebug.c @@ -0,0 +1,821 @@ + +// Copyright (c) 2004-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com + +#include +#include +#include +#include + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "id.h" +#include "import.h" +#include "template.h" + +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cv4.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +/* The CV4 debug format is defined in: + * "CV4 Symbolic Debug Information Specification" + * rev 3.1 March 5, 1993 + * Languages Business Unit + * Microsoft + */ + +/****************************** + * CV4 pg. 25 + * Convert D protection attribute to cv attribute. + */ + +unsigned PROTtoATTR(enum PROT prot) +{ + unsigned attribute; + + switch (prot) + { + case PROTprivate: attribute = 1; break; + case PROTpackage: attribute = 2; break; + case PROTprotected: attribute = 2; break; + case PROTpublic: attribute = 3; break; + case PROTexport: attribute = 3; break; + + case PROTundefined: + case PROTnone: + default: + //printf("prot = %d\n", prot); + assert(0); + } + return attribute; +} + +unsigned cv4_memfunctypidx(FuncDeclaration *fd) +{ type *t; + debtyp_t *d; + unsigned char *p; + AggregateDeclaration *ad; + + //printf("cv4_memfunctypidx(fd = '%s')\n", fd->toChars()); + t = fd->type->toCtype(); + ad = fd->isMember2(); + if (ad) + { + unsigned nparam; + idx_t paramidx; + idx_t thisidx; + unsigned char call; + + // It's a member function, which gets a special type record + + if (fd->isStatic()) + thisidx = dttab4[TYvoid]; + else + { + assert(ad->handle); + thisidx = cv4_typidx(ad->handle->toCtype()); + } + + paramidx = cv4_arglist(t,&nparam); + call = cv4_callconv(t); + + d = debtyp_alloc(18); + p = d->data; + TOWORD(p,LF_MFUNCTION); + TOWORD(p + 2,cv4_typidx(t->Tnext)); + TOWORD(p + 4,cv4_typidx(ad->type->toCtype())); + TOWORD(p + 6,thisidx); + p[8] = call; + p[9] = 0; // reserved + TOWORD(p + 10,nparam); + TOWORD(p + 12,paramidx); + TOLONG(p + 14,0); // thisadjust + + return cv_debtyp(d); + } + return cv4_typidx(t); +} + +unsigned cv4_Denum(EnumDeclaration *e) +{ + debtyp_t *d,*dt; + unsigned nfields,fnamelen; + unsigned len; + unsigned property; + unsigned attribute; + const char *id; + idx_t typidx; + + //dbg_printf("cv4_Denum(%s)\n", e->toChars()); + property = 0; + if (!e->members || !e->memtype) + property |= 0x80; // enum is forward referenced + + id = e->toPrettyChars(); + len = 10; + d = debtyp_alloc(len + cv_stringbytes(id)); + TOWORD(d->data,LF_ENUM); + TOWORD(d->data + 4,e->memtype ? cv4_typidx(e->memtype->toCtype()) : 0); + TOWORD(d->data + 8,property); + len += cv_namestring(d->data + len,id); + + d->length = 0; // so cv_debtyp() will allocate new + typidx = cv_debtyp(d); + d->length = len; // restore length + + // Compute the number of fields, and the length of the fieldlist record + nfields = 0; + fnamelen = 2; + if (!property) + { + for (size_t i = 0; i < e->members->dim; i++) + { EnumMember *sf = (e->members->tdata()[i])->isEnumMember(); + dinteger_t value; + + if (sf) + { + value = sf->value->toInteger(); + unsigned fnamelen1 = fnamelen; + // store only member's simple name + fnamelen += 4 + cv4_numericbytes(value) + cv_stringbytes(sf->toChars()); + + /* Optlink dies on longer ones, so just truncate + */ + if (fnamelen > 0xB000) // 0xB000 found by trial and error + { fnamelen = fnamelen1; // back up + break; // and skip the rest + } + + nfields++; + } + } + } + + TOWORD(d->data + 2,nfields); + + // If forward reference, then field list is 0 + if (property) + { + TOWORD(d->data + 6,0); + return typidx; + } + + // Generate fieldlist type record + dt = debtyp_alloc(fnamelen); + TOWORD(dt->data,LF_FIELDLIST); + + // And fill it in + unsigned j = 2; + unsigned fieldi = 0; + for (size_t i = 0; i < e->members->dim; i++) + { EnumMember *sf = (e->members->tdata()[i])->isEnumMember(); + dinteger_t value; + + if (sf) + { + fieldi++; + if (fieldi > nfields) + break; // chop off the rest + + value = sf->value->toInteger(); + TOWORD(dt->data + j,LF_ENUMERATE); + attribute = 0; + TOWORD(dt->data + j + 2,attribute); + cv4_storenumeric(dt->data + j + 4,value); + j += 4 + cv4_numericbytes(value); + // store only member's simple name + j += cv_namestring(dt->data + j, sf->toChars()); + + // If enum is not a member of a class, output enum members as constants +// if (!isclassmember(s)) +// { +// cv4_outsym(sf); +// } + } + } + assert(j == fnamelen); + TOWORD(d->data + 6,cv_debtyp(dt)); + +// cv4_outsym(s); + return typidx; +} + +/* ==================================================================== */ + +/**************************** + * Emit symbolic debug info in CV format. + */ + +void TypedefDeclaration::toDebug() +{ + //printf("TypedefDeclaration::toDebug('%s')\n", toChars()); + + assert(config.fulltypes >= CV4); + + // If it is a member, it is handled by cvMember() + if (!isMember()) + { + if (basetype->ty == Ttuple) + return; + + unsigned length; + const char *id = toPrettyChars(); + idx_t typidx = cv4_typidx(basetype->toCtype()); + unsigned len = strlen(id); + unsigned char *debsym = (unsigned char *) alloca(39 + IDOHD + len); + + // Output a 'user-defined type' for the tag name + TOWORD(debsym + 2,S_UDT); + TOIDX(debsym + 4,typidx); + length = 2 + 2 + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + + assert(length <= 40 + len); + obj_write_bytes(SegData[DEBSYM],length,debsym); + } +} + + +void EnumDeclaration::toDebug() +{ + //printf("EnumDeclaration::toDebug('%s')\n", toChars()); + + assert(config.fulltypes >= CV4); + + // If it is a member, it is handled by cvMember() + if (!isMember()) + { + unsigned length; + const char *id = toPrettyChars(); + idx_t typidx = cv4_Denum(this); + unsigned len = strlen(id); + unsigned char *debsym = (unsigned char *) alloca(39 + IDOHD + len); + + // Output a 'user-defined type' for the tag name + TOWORD(debsym + 2,S_UDT); + TOIDX(debsym + 4,typidx); + length = 2 + 2 + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + + assert(length <= 40 + len); + obj_write_bytes(SegData[DEBSYM],length,debsym); + } +} + + +void StructDeclaration::toDebug() +{ + unsigned leaf; + unsigned property; + unsigned nfields; + unsigned fnamelen; + const char *id; + targ_size_t size; + unsigned numidx; + debtyp_t *d,*dt; + unsigned len; + int count; // COUNT field in LF_CLASS + unsigned char *p; + idx_t typidx = 0; + + //printf("StructDeclaration::toDebug('%s')\n", toChars()); + + assert(config.fulltypes >= CV4); + if (isAnonymous()) + return /*0*/; + + if (typidx) // if reference already generated + return /*typidx*/; // use already existing reference + + property = 0; + if (!members) + { size = 0; + property |= 0x80; // forward reference + } + else + size = structsize; + + if (parent->isAggregateDeclaration()) // if class is nested + property |= 8; +// if (st->Sctor || st->Sdtor) +// property |= 2; // class has ctors and/or dtors +// if (st->Sopoverload) +// property |= 4; // class has overloaded operators +// if (st->Scastoverload) +// property |= 0x40; // class has casting methods +// if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug)) +// property |= 0x20; // class has overloaded assignment + + id = toPrettyChars(); + numidx = isUnionDeclaration() ? 8 : 12; + len = numidx + cv4_numericbytes(size); + d = debtyp_alloc(len + cv_stringbytes(id)); + cv4_storenumeric(d->data + numidx,size); + len += cv_namestring(d->data + len,id); + + leaf = isUnionDeclaration() ? LF_UNION : LF_STRUCTURE; + if (!isUnionDeclaration()) + { + TOWORD(d->data + 8,0); // dList + TOWORD(d->data + 10,0); // vshape is 0 (no virtual functions) + } + TOWORD(d->data,leaf); + + // Assign a number to prevent infinite recursion if a struct member + // references the same struct. + d->length = 0; // so cv_debtyp() will allocate new + typidx = cv_debtyp(d); + d->length = len; // restore length + + if (!members) // if reference only + { + TOWORD(d->data + 2,0); // count: number of fields is 0 + TOWORD(d->data + 4,0); // field list is 0 + TOWORD(d->data + 6,property); + return /*typidx*/; + } + + // Compute the number of fields, and the length of the fieldlist record + nfields = 0; + fnamelen = 2; + + count = nfields; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + int nwritten; + + nwritten = s->cvMember(NULL); + if (nwritten) + { + fnamelen += nwritten; + nfields++; + count++; + } + } + + TOWORD(d->data + 2,count); + TOWORD(d->data + 6,property); + + // Generate fieldlist type record + dt = debtyp_alloc(fnamelen); + p = dt->data; + + // And fill it in + TOWORD(p,LF_FIELDLIST); + p += 2; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + p += s->cvMember(p); + } + + //dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data); + assert(p - dt->data == fnamelen); + TOWORD(d->data + 4,cv_debtyp(dt)); + +// cv4_outsym(s); + + unsigned char *debsym; + unsigned length; + + len = strlen(id); + debsym = (unsigned char *) alloca(39 + IDOHD + len); + + // Output a 'user-defined type' for the tag name + TOWORD(debsym + 2,S_UDT); + TOIDX(debsym + 4,typidx); + length = 2 + 2 + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + + assert(length <= 40 + len); + obj_write_bytes(SegData[DEBSYM],length,debsym); + +// return typidx; +} + + +void ClassDeclaration::toDebug() +{ + unsigned leaf; + unsigned property; + unsigned nfields; + unsigned fnamelen; + const char *id; + targ_size_t size; + unsigned numidx; + debtyp_t *d,*dt; + unsigned len; + int i; + int count; // COUNT field in LF_CLASS + unsigned char *p; + idx_t typidx = 0; + + //printf("ClassDeclaration::toDebug('%s')\n", toChars()); + + assert(config.fulltypes >= CV4); + if (isAnonymous()) + return /*0*/; + + if (typidx) // if reference already generated + return /*typidx*/; // use already existing reference + + property = 0; + if (!members) + { size = 0; + property |= 0x80; // forward reference + } + else + size = structsize; + + if (parent->isAggregateDeclaration()) // if class is nested + property |= 8; + if (ctor || dtors.dim) + property |= 2; // class has ctors and/or dtors +// if (st->Sopoverload) +// property |= 4; // class has overloaded operators +// if (st->Scastoverload) +// property |= 0x40; // class has casting methods +// if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug)) +// property |= 0x20; // class has overloaded assignment + + id = isCPPinterface() ? ident->toChars() : toPrettyChars(); + numidx = isUnionDeclaration() ? 8 : 12; + len = numidx + cv4_numericbytes(size); + d = debtyp_alloc(len + cv_stringbytes(id)); + cv4_storenumeric(d->data + numidx,size); + len += cv_namestring(d->data + len,id); + + leaf = LF_CLASS; + TOWORD(d->data + 8,0); // dList + + if (1) + { debtyp_t *vshape; + unsigned char descriptor; + + size_t n = vtbl.dim; // number of virtual functions + if (n == 0) + { + TOWORD(d->data + 10,0); // vshape is 0 + } + else + { + vshape = debtyp_alloc(4 + (n + 1) / 2); + TOWORD(vshape->data,LF_VTSHAPE); + TOWORD(vshape->data + 2,1); + + n = 0; + descriptor = 0; + for (size_t i = 0; i < vtbl.dim; i++) + { FuncDeclaration *fd = (FuncDeclaration *)vtbl.tdata()[i]; + + //if (intsize == 4) + descriptor |= 5; + vshape->data[4 + n / 2] = descriptor; + descriptor <<= 4; + n++; + } + TOWORD(d->data + 10,cv_debtyp(vshape)); // vshape + } + } + else + TOWORD(d->data + 10,0); // vshape is 0 (no virtual functions) + + TOWORD(d->data,leaf); + + // Assign a number to prevent infinite recursion if a struct member + // references the same struct. + d->length = 0; // so cv_debtyp() will allocate new + typidx = cv_debtyp(d); + d->length = len; // restore length + + if (!members) // if reference only + { + TOWORD(d->data + 2,0); // count: number of fields is 0 + TOWORD(d->data + 4,0); // field list is 0 + TOWORD(d->data + 6,property); + return /*typidx*/; + } + + // Compute the number of fields, and the length of the fieldlist record + nfields = 0; + fnamelen = 2; + + // Add in base classes + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *bc = baseclasses->tdata()[i]; + + nfields++; + fnamelen += 6 + cv4_numericbytes(bc->offset); + } + + count = nfields; + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + int nwritten; + + nwritten = s->cvMember(NULL); + if (nwritten) + { + fnamelen += nwritten; + nfields++; + count++; + } + } + + TOWORD(d->data + 2,count); + TOWORD(d->data + 6,property); + + // Generate fieldlist type record + dt = debtyp_alloc(fnamelen); + p = dt->data; + + // And fill it in + TOWORD(p,LF_FIELDLIST); + p += 2; + + // Add in base classes + for (size_t i = 0; i < baseclasses->dim; i++) + { BaseClass *bc = baseclasses->tdata()[i]; + idx_t typidx; + unsigned attribute; + + typidx = cv4_typidx(bc->base->type->toCtype()->Tnext); + + attribute = PROTtoATTR(bc->protection); + + TOWORD(p,LF_BCLASS); + TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + p += 6; + + cv4_storenumeric(p, bc->offset); + p += cv4_numericbytes(bc->offset); + } + + + + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *s = members->tdata()[i]; + + p += s->cvMember(p); + } + + //dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data); + assert(p - dt->data == fnamelen); + TOWORD(d->data + 4,cv_debtyp(dt)); + +// cv4_outsym(s); + + unsigned char *debsym; + unsigned length; + + len = strlen(id); + debsym = (unsigned char *) alloca(39 + IDOHD + len); + + // Output a 'user-defined type' for the tag name + TOWORD(debsym + 2,S_UDT); + TOIDX(debsym + 4,typidx); + length = 2 + 2 + cgcv.sz_idx; + length += cv_namestring(debsym + length,id); + TOWORD(debsym,length - 2); + + assert(length <= 40 + len); + obj_write_bytes(SegData[DEBSYM],length,debsym); + +// return typidx; +} + + +/* ===================================================================== */ + +/***************************************** + * Insert CV info into *p. + * Returns: + * number of bytes written, or that would be written if p==NULL + */ + +int Dsymbol::cvMember(unsigned char *p) +{ + return 0; +} + + +int TypedefDeclaration::cvMember(unsigned char *p) +{ + char *id; + idx_t typidx; + int nwritten = 0; + + //printf("TypedefDeclaration::cvMember() '%s'\n", toChars()); + id = toChars(); + + if (!p) + { + nwritten = 4 + cv_stringbytes(id); + } + else + { + TOWORD(p,LF_NESTTYPE); + typidx = cv4_typidx(basetype->toCtype()); + TOWORD(p + 2,typidx); + nwritten = 4 + cv_namestring(p + 4, id); + } + return nwritten; +} + + +int EnumDeclaration::cvMember(unsigned char *p) +{ + char *id; + idx_t typidx; + int nwritten = 0; + + //printf("EnumDeclaration::cvMember() '%s'\n", toChars()); + id = toChars(); + + if (!p) + { + nwritten = 4 + cv_stringbytes(id); + } + else + { + TOWORD(p,LF_NESTTYPE); + typidx = cv4_Denum(this); + TOWORD(p + 2,typidx); + nwritten = 4 + cv_namestring(p + 4, id); + } + return nwritten; +} + + +int FuncDeclaration::cvMember(unsigned char *p) +{ + char *id; + idx_t typidx; + unsigned attribute; + int nwritten = 0; + debtyp_t *d; + + //printf("FuncDeclaration::cvMember() '%s'\n", toChars()); + + if (!type) // if not compiled in, + return 0; // skip it + + id = toChars(); + + if (!p) + { + nwritten = 6 + cv_stringbytes(id); + } + else + { + int count; + int mlen; + unsigned char *q; + + count = 0; + mlen = 2; + { + if (introducing) + mlen += 4; + mlen += cgcv.sz_idx * 2; + count++; + } + + // Allocate and fill it in + d = debtyp_alloc(mlen); + q = d->data; + TOWORD(q,LF_METHODLIST); + q += 2; +// for (s = sf; s; s = s->Sfunc->Foversym) + { + attribute = PROTtoATTR(prot()); + + /* 0*4 vanilla method + * 1*4 virtual method + * 2*4 static method + * 3*4 friend method + * 4*4 introducing virtual method + * 5*4 pure virtual method + * 6*4 pure introducing virtual method + * 7*4 reserved + */ + + if (isStatic()) + attribute |= 2*4; + else if (isVirtual()) + { + if (introducing) + { + if (isAbstract()) + attribute |= 6*4; + else + attribute |= 4*4; + } + else + { + if (isAbstract()) + attribute |= 5*4; + else + attribute |= 1*4; + } + } + else + attribute |= 0*4; + + TOIDX(q,attribute); + q += cgcv.sz_idx; + TOIDX(q, cv4_memfunctypidx(this)); + q += cgcv.sz_idx; + if (introducing) + { TOLONG(q, vtblIndex * PTRSIZE); + q += 4; + } + } + assert(q - d->data == mlen); + + typidx = cv_debtyp(d); + if (typidx) + { + TOWORD(p,LF_METHOD); + TOWORD(p + 2,count); + nwritten = 4; + TOIDX(p + nwritten, typidx); + nwritten += cgcv.sz_idx; + nwritten += cv_namestring(p + nwritten, id); + } + } + return nwritten; +} + +int VarDeclaration::cvMember(unsigned char *p) +{ + char *id; + idx_t typidx; + unsigned attribute; + int nwritten = 0; + + //printf("VarDeclaration::cvMember(p = %p) '%s'\n", p, toChars()); + + if (type->toBasetype()->ty == Ttuple) + return 0; + + id = toChars(); + + if (!p) + { + if (storage_class & STCfield) + { + nwritten += 6 + + cv4_numericbytes(offset) + cv_stringbytes(id); + } + else if (isStatic()) + { + nwritten += 6 + cv_stringbytes(id); + } + } + else if (storage_class & STCfield) + { + TOWORD(p,LF_MEMBER); + typidx = cv_typidx(type->toCtype()); + attribute = PROTtoATTR(prot()); + assert((attribute & ~3) == 0); + TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + cv4_storenumeric(p + 6, offset); + nwritten = 6 + cv4_numericbytes( offset); + nwritten += cv_namestring(p + nwritten, id); + } + else if (isStatic()) + { + TOWORD(p,LF_STMEMBER); + typidx = cv_typidx(type->toCtype()); + attribute = PROTtoATTR(prot()); + assert((attribute & ~3) == 0); + TOWORD(p + 2,typidx); + TOWORD(p + 4,attribute); + nwritten = 6 + cv_namestring(p + 6, id); + } + return nwritten; +} + diff --git a/todt.c b/todt.c new file mode 100644 index 00000000..12a60333 --- /dev/null +++ b/todt.c @@ -0,0 +1,1051 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* A dt_t is a simple structure representing data to be added + * to the data segment of the output object file. As such, + * it is a list of initialized bytes, 0 data, and offsets from + * other symbols. + * Each D symbol and type can be converted into a dt_t so it can + * be written to the data segment. + */ + +#include +#include +#include +#include +#include + +#include "lexer.h" +#include "mtype.h" +#include "expression.h" +#include "init.h" +#include "enum.h" +#include "aggregate.h" +#include "declaration.h" + + +// Back end +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "dt.h" + +extern Symbol *static_sym(); + +typedef ArrayBase Dts; + +/* ================================================================ */ + +dt_t *Initializer::toDt() +{ + assert(0); + return NULL; +} + + +dt_t *VoidInitializer::toDt() +{ /* Void initializers are set to 0, just because we need something + * to set them to in the static data segment. + */ + dt_t *dt = NULL; + + dtnzeros(&dt, type->size()); + return dt; +} + + +dt_t *StructInitializer::toDt() +{ + Dts dts; + dt_t *dt; + dt_t *d; + dt_t **pdtend; + unsigned offset; + + //printf("StructInitializer::toDt('%s')\n", toChars()); + dts.setDim(ad->fields.dim); + dts.zero(); + + for (size_t i = 0; i < vars.dim; i++) + { + VarDeclaration *v = vars.tdata()[i]; + Initializer *val = value.tdata()[i]; + + //printf("vars[%d] = %s\n", i, v->toChars()); + + for (size_t j = 0; 1; j++) + { + assert(j < dts.dim); + //printf(" adfield[%d] = %s\n", j, (ad->fields.tdata()[j])->toChars()); + if (ad->fields.tdata()[j] == v) + { + if (dts.tdata()[j]) + error(loc, "field %s of %s already initialized", v->toChars(), ad->toChars()); + dts.tdata()[j] = val->toDt(); + break; + } + } + } + + dt = NULL; + pdtend = &dt; + offset = 0; + for (size_t j = 0; j < dts.dim; j++) + { + VarDeclaration *v = ad->fields.tdata()[j]; + + d = dts.tdata()[j]; + if (!d) + { // An instance specific initializer was not provided. + // Look to see if there's a default initializer from the + // struct definition + if (v->init) + { + d = v->init->toDt(); + } + else if (v->offset >= offset) + { + unsigned k; + unsigned offset2 = v->offset + v->type->size(); + // Make sure this field does not overlap any explicitly + // initialized field. + for (k = j + 1; 1; k++) + { + if (k == dts.dim) // didn't find any overlap + { + v->type->toDt(&d); + break; + } + VarDeclaration *v2 = ad->fields.tdata()[k]; + + if (v2->offset < offset2 && dts.tdata()[k]) + break; // overlap + } + } + } + if (d) + { + if (v->offset < offset) + error(loc, "duplicate union initialization for %s", v->toChars()); + else + { unsigned sz = dt_size(d); + unsigned vsz = v->type->size(); + unsigned voffset = v->offset; + + if (sz > vsz) + { assert(v->type->ty == Tsarray && vsz == 0); + error(loc, "zero length array %s has non-zero length initializer", v->toChars()); + } + + unsigned dim = 1; + for (Type *vt = v->type->toBasetype(); + vt->ty == Tsarray; + vt = vt->nextOf()->toBasetype()) + { TypeSArray *tsa = (TypeSArray *)vt; + dim *= tsa->dim->toInteger(); + } + //printf("sz = %d, dim = %d, vsz = %d\n", sz, dim, vsz); + assert(sz == vsz || sz * dim <= vsz); + + for (size_t i = 0; i < dim; i++) + { + if (offset < voffset) + pdtend = dtnzeros(pdtend, voffset - offset); + if (!d) + { + if (v->init) + d = v->init->toDt(); + else + v->type->toDt(&d); + } + pdtend = dtcat(pdtend, d); + d = NULL; + offset = voffset + sz; + voffset += vsz / dim; + if (sz == vsz) + break; + } + } + } + } + if (offset < ad->structsize) + dtnzeros(pdtend, ad->structsize - offset); + + return dt; +} + + +dt_t *ArrayInitializer::toDt() +{ + //printf("ArrayInitializer::toDt('%s')\n", toChars()); + Type *tb = type->toBasetype(); + Type *tn = tb->nextOf()->toBasetype(); + + Dts dts; + unsigned size; + unsigned length; + dt_t *dt; + dt_t *d; + dt_t **pdtend; + + //printf("\tdim = %d\n", dim); + dts.setDim(dim); + dts.zero(); + + size = tn->size(); + + length = 0; + for (size_t i = 0; i < index.dim; i++) + { Expression *idx; + Initializer *val; + + idx = index.tdata()[i]; + if (idx) + length = idx->toInteger(); + //printf("\tindex[%d] = %p, length = %u, dim = %u\n", i, idx, length, dim); + + assert(length < dim); + val = value.tdata()[i]; + dt = val->toDt(); + if (dts.tdata()[length]) + error(loc, "duplicate initializations for index %d", length); + dts.tdata()[length] = dt; + length++; + } + + Expression *edefault = tb->nextOf()->defaultInit(); + + unsigned n = 1; + for (Type *tbn = tn; tbn->ty == Tsarray; tbn = tbn->nextOf()->toBasetype()) + { TypeSArray *tsa = (TypeSArray *)tbn; + + n *= tsa->dim->toInteger(); + } + + d = NULL; + pdtend = &d; + for (size_t i = 0; i < dim; i++) + { + dt = dts.tdata()[i]; + if (dt) + pdtend = dtcat(pdtend, dt); + else + { + for (size_t j = 0; j < n; j++) + pdtend = edefault->toDt(pdtend); + } + } + switch (tb->ty) + { + case Tsarray: + { unsigned tadim; + TypeSArray *ta = (TypeSArray *)tb; + + tadim = ta->dim->toInteger(); + if (dim < tadim) + { + if (edefault->isBool(FALSE)) + // pad out end of array + pdtend = dtnzeros(pdtend, size * (tadim - dim)); + else + { + for (size_t i = dim; i < tadim; i++) + { for (size_t j = 0; j < n; j++) + pdtend = edefault->toDt(pdtend); + } + } + } + else if (dim > tadim) + { +#ifdef DEBUG + printf("1: "); +#endif + error(loc, "too many initializers, %d, for array[%d]", dim, tadim); + } + break; + } + + case Tpointer: + case Tarray: + { // Create symbol, and then refer to it + Symbol *s = static_sym(); + s->Sdt = d; + outdata(s); + + d = NULL; + if (tb->ty == Tarray) + dtsize_t(&d, dim); + dtxoff(&d, s, 0, TYnptr); + break; + } + + default: + assert(0); + } + return d; +} + + +dt_t *ArrayInitializer::toDtBit() +{ +#if DMDV1 + unsigned size; + unsigned length; + unsigned tadim; + dt_t *d; + dt_t **pdtend; + Type *tb = type->toBasetype(); + + //printf("ArrayInitializer::toDtBit('%s')\n", toChars()); + + Bits databits; + Bits initbits; + + if (tb->ty == Tsarray) + { + /* The 'dim' for ArrayInitializer is only the maximum dimension + * seen in the initializer, not the type. So, for static arrays, + * use instead the dimension of the type in order + * to get the whole thing. + */ + dinteger_t value = ((TypeSArray*)tb)->dim->toInteger(); + tadim = value; + assert(tadim == value); // truncation overflow should already be checked + databits.resize(tadim); + initbits.resize(tadim); + } + else + { + databits.resize(dim); + initbits.resize(dim); + } + + /* The default initializer may be something other than zero. + */ + if (tb->nextOf()->defaultInit()->toInteger()) + databits.set(); + + size = sizeof(databits.tdata()[0]); + + length = 0; + for (size_t i = 0; i < index.dim; i++) + { Expression *idx; + Initializer *val; + Expression *eval; + + idx = index.tdata()[i]; + if (idx) + { dinteger_t value; + value = idx->toInteger(); + length = value; + if (length != value) + { error(loc, "index overflow %llu", value); + length = 0; + } + } + assert(length < dim); + + val = value.tdata()[i]; + eval = val->toExpression(); + if (initbits.test(length)) + error(loc, "duplicate initializations for index %d", length); + initbits.set(length); + if (eval->toInteger()) // any non-zero value is boolean 'true' + databits.set(length); + else + databits.clear(length); // boolean 'false' + length++; + } + + d = NULL; + pdtend = dtnbytes(&d, databits.allocdim * size, (char *)databits.data); + switch (tb->ty) + { + case Tsarray: + { + if (dim > tadim) + { + error(loc, "too many initializers, %d, for array[%d]", dim, tadim); + } + else + { + tadim = (tadim + 31) / 32; + if (databits.allocdim < tadim) + pdtend = dtnzeros(pdtend, size * (tadim - databits.allocdim)); // pad out end of array + } + break; + } + + case Tpointer: + case Tarray: + // Create symbol, and then refer to it + Symbol *s; + s = static_sym(); + s->Sdt = d; + outdata(s); + + d = NULL; + if (tb->ty == Tarray) + dtsize_t(&d, dim); + dtxoff(&d, s, 0, TYnptr); + break; + + default: + assert(0); + } + return d; +#else + return NULL; +#endif +} + + +dt_t *ExpInitializer::toDt() +{ + //printf("ExpInitializer::toDt() %s\n", exp->toChars()); + dt_t *dt = NULL; + + exp = exp->optimize(WANTvalue); + exp->toDt(&dt); + return dt; +} + +/* ================================================================ */ + +dt_t **Expression::toDt(dt_t **pdt) +{ +#ifdef DEBUG + printf("Expression::toDt() %d\n", op); + dump(0); +#endif + error("non-constant expression %s", toChars()); + pdt = dtnzeros(pdt, 1); + return pdt; +} + +dt_t **IntegerExp::toDt(dt_t **pdt) +{ unsigned sz; + + //printf("IntegerExp::toDt() %d\n", op); + sz = type->size(); + if (value == 0) + pdt = dtnzeros(pdt, sz); + else + pdt = dtnbytes(pdt, sz, (char *)&value); + return pdt; +} + +static char zeropad[6]; + +dt_t **RealExp::toDt(dt_t **pdt) +{ + d_float32 fvalue; + d_float64 dvalue; + d_float80 evalue; + + //printf("RealExp::toDt(%Lg)\n", value); + switch (type->toBasetype()->ty) + { + case Tfloat32: + case Timaginary32: + fvalue = value; + pdt = dtnbytes(pdt,4,(char *)&fvalue); + break; + + case Tfloat64: + case Timaginary64: + dvalue = value; + pdt = dtnbytes(pdt,8,(char *)&dvalue); + break; + + case Tfloat80: + case Timaginary80: + evalue = value; + pdt = dtnbytes(pdt,REALSIZE - REALPAD,(char *)&evalue); + pdt = dtnbytes(pdt,REALPAD,zeropad); + assert(REALPAD <= sizeof(zeropad)); + break; + + default: + printf("%s\n", toChars()); + type->print(); + assert(0); + break; + } + return pdt; +} + +dt_t **ComplexExp::toDt(dt_t **pdt) +{ + //printf("ComplexExp::toDt() '%s'\n", toChars()); + d_float32 fvalue; + d_float64 dvalue; + d_float80 evalue; + + switch (type->toBasetype()->ty) + { + case Tcomplex32: + fvalue = creall(value); + pdt = dtnbytes(pdt,4,(char *)&fvalue); + fvalue = cimagl(value); + pdt = dtnbytes(pdt,4,(char *)&fvalue); + break; + + case Tcomplex64: + dvalue = creall(value); + pdt = dtnbytes(pdt,8,(char *)&dvalue); + dvalue = cimagl(value); + pdt = dtnbytes(pdt,8,(char *)&dvalue); + break; + + case Tcomplex80: + evalue = creall(value); + pdt = dtnbytes(pdt,REALSIZE - REALPAD,(char *)&evalue); + pdt = dtnbytes(pdt,REALPAD,zeropad); + evalue = cimagl(value); + pdt = dtnbytes(pdt,REALSIZE - REALPAD,(char *)&evalue); + pdt = dtnbytes(pdt,REALPAD,zeropad); + break; + + default: + assert(0); + break; + } + return pdt; +} + +dt_t **NullExp::toDt(dt_t **pdt) +{ + assert(type); + return dtnzeros(pdt, type->size()); +} + +dt_t **StringExp::toDt(dt_t **pdt) +{ + //printf("StringExp::toDt() '%s', type = %s\n", toChars(), type->toChars()); + Type *t = type->toBasetype(); + + // BUG: should implement some form of static string pooling + switch (t->ty) + { + case Tarray: + dtsize_t(pdt, len); + pdt = dtabytes(pdt, TYnptr, 0, (len + 1) * sz, (char *)string); + break; + + case Tsarray: + { TypeSArray *tsa = (TypeSArray *)type; + dinteger_t dim; + + pdt = dtnbytes(pdt, len * sz, (const char *)string); + if (tsa->dim) + { + dim = tsa->dim->toInteger(); + if (len < dim) + { + // Pad remainder with 0 + pdt = dtnzeros(pdt, (dim - len) * tsa->next->size()); + } + } + break; + } + case Tpointer: + pdt = dtabytes(pdt, TYnptr, 0, (len + 1) * sz, (char *)string); + break; + + default: + printf("StringExp::toDt(type = %s)\n", type->toChars()); + assert(0); + } + return pdt; +} + +dt_t **ArrayLiteralExp::toDt(dt_t **pdt) +{ + //printf("ArrayLiteralExp::toDt() '%s', type = %s\n", toChars(), type->toChars()); + + dt_t *d; + dt_t **pdtend; + + d = NULL; + pdtend = &d; + for (size_t i = 0; i < elements->dim; i++) + { Expression *e = elements->tdata()[i]; + + pdtend = e->toDt(pdtend); + } + Type *t = type->toBasetype(); + + switch (t->ty) + { + case Tsarray: + pdt = dtcat(pdt, d); + break; + + case Tpointer: + case Tarray: + if (t->ty == Tarray) + dtsize_t(pdt, elements->dim); + if (d) + { + // Create symbol, and then refer to it + Symbol *s; + s = static_sym(); + s->Sdt = d; + outdata(s); + + dtxoff(pdt, s, 0, TYnptr); + } + else + dtsize_t(pdt, 0); + + break; + + default: + assert(0); + } + return pdt; +} + +dt_t **StructLiteralExp::toDt(dt_t **pdt) +{ + Dts dts; + dt_t *dt; + dt_t *d; + unsigned offset; + + //printf("StructLiteralExp::toDt() %s)\n", toChars()); + dts.setDim(sd->fields.dim); + dts.zero(); + assert(elements->dim <= sd->fields.dim); + + for (size_t i = 0; i < elements->dim; i++) + { + Expression *e = elements->tdata()[i]; + if (!e) + continue; + dt = NULL; + e->toDt(&dt); + dts.tdata()[i] = dt; + } + + offset = 0; + for (size_t j = 0; j < dts.dim; j++) + { + VarDeclaration *v = sd->fields.tdata()[j]; + + d = dts.tdata()[j]; + if (!d) + { // An instance specific initializer was not provided. + // Look to see if there's a default initializer from the + // struct definition + if (v->init) + { + d = v->init->toDt(); + } + else if (v->offset >= offset) + { + unsigned offset2 = v->offset + v->type->size(); + // Make sure this field (v) does not overlap any explicitly + // initialized field. + for (size_t k = j + 1; 1; k++) + { + if (k == dts.dim) // didn't find any overlap + { + v->type->toDt(&d); + break; + } + VarDeclaration *v2 = sd->fields.tdata()[k]; + + if (v2->offset < offset2 && dts.tdata()[k]) + break; // overlap + } + } + } + if (d) + { + if (v->offset < offset) + error("duplicate union initialization for %s", v->toChars()); + else + { unsigned sz = dt_size(d); + unsigned vsz = v->type->size(); + unsigned voffset = v->offset; + + if (sz > vsz) + { assert(v->type->ty == Tsarray && vsz == 0); + error("zero length array %s has non-zero length initializer", v->toChars()); + } + + unsigned dim = 1; + Type *vt; + for (vt = v->type->toBasetype(); + vt->ty == Tsarray; + vt = vt->nextOf()->toBasetype()) + { TypeSArray *tsa = (TypeSArray *)vt; + dim *= tsa->dim->toInteger(); + } + //printf("sz = %d, dim = %d, vsz = %d\n", sz, dim, vsz); + assert(sz == vsz || sz * dim <= vsz); + + for (size_t i = 0; i < dim; i++) + { + if (offset < voffset) + pdt = dtnzeros(pdt, voffset - offset); + if (!d) + { + if (v->init) + d = v->init->toDt(); + else + vt->toDt(&d); + } + pdt = dtcat(pdt, d); + d = NULL; + offset = voffset + sz; + voffset += vsz / dim; + if (sz == vsz) + break; + } + } + } + } + if (offset < sd->structsize) + pdt = dtnzeros(pdt, sd->structsize - offset); + + return pdt; +} + + +dt_t **SymOffExp::toDt(dt_t **pdt) +{ + Symbol *s; + + //printf("SymOffExp::toDt('%s')\n", var->toChars()); + assert(var); + if (!(var->isDataseg() || var->isCodeseg()) || + var->needThis() || + var->isThreadlocal()) + { +#ifdef DEBUG + printf("SymOffExp::toDt()\n"); +#endif + error("non-constant expression %s", toChars()); + return pdt; + } + s = var->toSymbol(); + return dtxoff(pdt, s, offset, TYnptr); +} + +dt_t **VarExp::toDt(dt_t **pdt) +{ + //printf("VarExp::toDt() %d\n", op); + for (; *pdt; pdt = &((*pdt)->DTnext)) + ; + + VarDeclaration *v = var->isVarDeclaration(); + if (v && (v->isConst() || v->isImmutable()) && + type->toBasetype()->ty != Tsarray && v->init) + { + if (v->inuse) + { + error("recursive reference %s", toChars()); + return pdt; + } + v->inuse++; + *pdt = v->init->toDt(); + v->inuse--; + return pdt; + } + SymbolDeclaration *sd = var->isSymbolDeclaration(); + if (sd && sd->dsym) + { + sd->dsym->toDt(pdt); + return pdt; + } +#ifdef DEBUG + printf("VarExp::toDt(), kind = %s\n", var->kind()); +#endif + error("non-constant expression %s", toChars()); + pdt = dtnzeros(pdt, 1); + return pdt; +} + +dt_t **FuncExp::toDt(dt_t **pdt) +{ + //printf("FuncExp::toDt() %d\n", op); + Symbol *s = fd->toSymbol(); + if (fd->isNested()) + { error("non-constant nested delegate literal expression %s", toChars()); + return NULL; + } + fd->toObjFile(0); + return dtxoff(pdt, s, 0, TYnptr); +} + +/* ================================================================= */ + +// Generate the data for the static initializer. + +void ClassDeclaration::toDt(dt_t **pdt) +{ + //printf("ClassDeclaration::toDt(this = '%s')\n", toChars()); + + // Put in first two members, the vtbl[] and the monitor + dtxoff(pdt, toVtblSymbol(), 0, TYnptr); + dtsize_t(pdt, 0); // monitor + + // Put in the rest + toDt2(pdt, this); + + //printf("-ClassDeclaration::toDt(this = '%s')\n", toChars()); +} + +void ClassDeclaration::toDt2(dt_t **pdt, ClassDeclaration *cd) +{ + unsigned offset; + dt_t *dt; + unsigned csymoffset; + +#define LOG 0 + +#if LOG + printf("ClassDeclaration::toDt2(this = '%s', cd = '%s')\n", toChars(), cd->toChars()); +#endif + if (baseClass) + { + baseClass->toDt2(pdt, cd); + offset = baseClass->structsize; + } + else + { + offset = PTRSIZE * 2; + } + + // Note equivalence of this loop to struct's + for (size_t i = 0; i < fields.dim; i++) + { + VarDeclaration *v = fields.tdata()[i]; + Initializer *init; + + //printf("\t\tv = '%s' v->offset = %2d, offset = %2d\n", v->toChars(), v->offset, offset); + dt = NULL; + init = v->init; + if (init) + { //printf("\t\t%s has initializer %s\n", v->toChars(), init->toChars()); + ExpInitializer *ei = init->isExpInitializer(); + Type *tb = v->type->toBasetype(); + if (ei && tb->ty == Tsarray) + ((TypeSArray *)tb)->toDtElem(&dt, ei->exp); + else + dt = init->toDt(); + } + else if (v->offset >= offset) + { //printf("\t\tdefault initializer\n"); + v->type->toDt(&dt); + } + if (dt) + { + if (v->offset < offset) + error("duplicated union initialization for %s", v->toChars()); + else + { + if (offset < v->offset) + dtnzeros(pdt, v->offset - offset); + dtcat(pdt, dt); + offset = v->offset + v->type->size(); + } + } + } + + // Interface vptr initializations + toSymbol(); // define csym + + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + +#if 1 || INTERFACE_VIRTUAL + for (ClassDeclaration *cd2 = cd; 1; cd2 = cd2->baseClass) + { + assert(cd2); + csymoffset = cd2->baseVtblOffset(b); + if (csymoffset != ~0) + { + if (offset < b->offset) + dtnzeros(pdt, b->offset - offset); + dtxoff(pdt, cd2->toSymbol(), csymoffset, TYnptr); + break; + } + } +#else + csymoffset = baseVtblOffset(b); + assert(csymoffset != ~0); + dtxoff(pdt, csym, csymoffset, TYnptr); +#endif + offset = b->offset + PTRSIZE; + } + + if (offset < structsize) + dtnzeros(pdt, structsize - offset); + +#undef LOG +} + +void StructDeclaration::toDt(dt_t **pdt) +{ + unsigned offset; + dt_t *dt; + + //printf("StructDeclaration::toDt(), this='%s'\n", toChars()); + offset = 0; + + // Note equivalence of this loop to class's + for (size_t i = 0; i < fields.dim; i++) + { + VarDeclaration *v = fields.tdata()[i]; + //printf("\tfield '%s' voffset %d, offset = %d\n", v->toChars(), v->offset, offset); + dt = NULL; + int sz; + + if (v->storage_class & STCref) + { + sz = PTRSIZE; + if (v->offset >= offset) + dtnzeros(&dt, sz); + } + else + { + sz = v->type->size(); + Initializer *init = v->init; + if (init) + { //printf("\t\thas initializer %s\n", init->toChars()); + ExpInitializer *ei = init->isExpInitializer(); + Type *tb = v->type->toBasetype(); + if (ei && tb->ty == Tsarray) + ((TypeSArray *)tb)->toDtElem(&dt, ei->exp); + else + dt = init->toDt(); + } + else if (v->offset >= offset) + v->type->toDt(&dt); + } + if (dt) + { + if (v->offset < offset) + error("overlapping initialization for struct %s.%s", toChars(), v->toChars()); + else + { + if (offset < v->offset) + dtnzeros(pdt, v->offset - offset); + dtcat(pdt, dt); + offset = v->offset + sz; + } + } + } + + if (offset < structsize) + dtnzeros(pdt, structsize - offset); + + dt_optimize(*pdt); +} + +/* ================================================================= */ + +dt_t **Type::toDt(dt_t **pdt) +{ + //printf("Type::toDt()\n"); + Expression *e = defaultInit(); + return e->toDt(pdt); +} + +dt_t **TypeSArray::toDt(dt_t **pdt) +{ + return toDtElem(pdt, NULL); +} + +dt_t **TypeSArray::toDtElem(dt_t **pdt, Expression *e) +{ + unsigned len; + + //printf("TypeSArray::toDtElem()\n"); + len = dim->toInteger(); + if (len) + { + while (*pdt) + pdt = &((*pdt)->DTnext); + Type *tnext = next; + Type *tbn = tnext->toBasetype(); + while (tbn->ty == Tsarray && (!e || tbn != e->type->nextOf())) + { TypeSArray *tsa = (TypeSArray *)tbn; + + len *= tsa->dim->toInteger(); + tnext = tbn->nextOf(); + tbn = tnext->toBasetype(); + } + if (!e) // if not already supplied + e = tnext->defaultInit(); // use default initializer + e->toDt(pdt); + dt_optimize(*pdt); + if (e->op == TOKstring) + len /= ((StringExp *)e)->len; + if (e->op == TOKarrayliteral) + len /= ((ArrayLiteralExp *)e)->elements->dim; + if ((*pdt)->dt == DT_azeros && !(*pdt)->DTnext) + { + (*pdt)->DTazeros *= len; + pdt = &((*pdt)->DTnext); + } + else if ((*pdt)->dt == DT_1byte && (*pdt)->DTonebyte == 0 && !(*pdt)->DTnext) + { + (*pdt)->dt = DT_azeros; + (*pdt)->DTazeros = len; + pdt = &((*pdt)->DTnext); + } + else + { + for (size_t i = 1; i < len; i++) + { + if (tbn->ty == Tstruct) + { pdt = tnext->toDt(pdt); + while (*pdt) + pdt = &((*pdt)->DTnext); + } + else + pdt = e->toDt(pdt); + } + } + } + return pdt; +} + +dt_t **TypeStruct::toDt(dt_t **pdt) +{ + sym->toDt(pdt); + return pdt; +} + +dt_t **TypeTypedef::toDt(dt_t **pdt) +{ + if (sym->init) + { + dt_t *dt = sym->init->toDt(); + + while (*pdt) + pdt = &((*pdt)->DTnext); + *pdt = dt; + return pdt; + } + sym->basetype->toDt(pdt); + return pdt; +} + + + diff --git a/toelfdebug.c b/toelfdebug.c new file mode 100644 index 00000000..19a07552 --- /dev/null +++ b/toelfdebug.c @@ -0,0 +1,103 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 2004-2007 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + + +#include +#include +#include +#include + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "id.h" +#include "import.h" +#include "template.h" + +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cv4.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +/**************************** + * Emit symbolic debug info in Dwarf2 format. + */ + +void TypedefDeclaration::toDebug() +{ + //printf("TypedefDeclaration::toDebug('%s')\n", toChars()); +} + + +void EnumDeclaration::toDebug() +{ + //printf("EnumDeclaration::toDebug('%s')\n", toChars()); +} + + +void StructDeclaration::toDebug() +{ +} + + +void ClassDeclaration::toDebug() +{ +} + + +/* ===================================================================== */ + +/***************************************** + * Insert CV info into *p. + * Returns: + * number of bytes written, or that would be written if p==NULL + */ + +int Dsymbol::cvMember(unsigned char *p) +{ + return 0; +} + + +int TypedefDeclaration::cvMember(unsigned char *p) +{ + return 0; +} + + +int EnumDeclaration::cvMember(unsigned char *p) +{ + return 0; +} + + +int FuncDeclaration::cvMember(unsigned char *p) +{ + return 0; +} + +int VarDeclaration::cvMember(unsigned char *p) +{ + return 0; +} + diff --git a/toir.c b/toir.c new file mode 100644 index 00000000..b1ee5108 --- /dev/null +++ b/toir.c @@ -0,0 +1,912 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* Code to help convert to the intermediate representation + * of the compiler back end. + */ + +#include +#include +#include +#include + +#include "lexer.h" +#include "expression.h" +#include "mtype.h" +#include "dsymbol.h" +#include "declaration.h" +#include "enum.h" +#include "aggregate.h" +#include "attrib.h" +#include "module.h" +#include "init.h" +#include "template.h" + +#include "mem.h" // for mem_malloc + +#include "cc.h" +#include "el.h" +#include "oper.h" +#include "global.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "irstate.h" +#include "id.h" +#include "type.h" +#include "toir.h" + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +/********************************************* + * Produce elem which increments the usage count for a particular line. + * Used to implement -cov switch (coverage analysis). + */ + +elem *incUsageElem(IRState *irs, Loc loc) +{ + unsigned linnum = loc.linnum; + + if (!irs->blx->module->cov || !linnum || + loc.filename != irs->blx->module->srcfile->toChars()) + return NULL; + + //printf("cov = %p, covb = %p, linnum = %u\n", irs->blx->module->cov, irs->blx->module->covb, p, linnum); + + linnum--; // from 1-based to 0-based + + /* Set bit in covb[] indicating this is a valid code line number + */ + unsigned *p = irs->blx->module->covb; + if (p) // covb can be NULL if it has already been written out to its .obj file + { + p += linnum / (sizeof(*p) * 8); + *p |= 1 << (linnum & (sizeof(*p) * 8 - 1)); + } + + elem *e; + e = el_ptr(irs->blx->module->cov); + e = el_bin(OPadd, TYnptr, e, el_long(TYuint, linnum * 4)); + e = el_una(OPind, TYuint, e); + e = el_bin(OPaddass, TYuint, e, el_long(TYuint, 1)); + return e; +} + +/****************************************** + * Return elem that evaluates to the static frame pointer for function fd. + * If fd is a member function, the returned expression will compute the value + * of fd's 'this' variable. + * This routine is critical for implementing nested functions. + */ + +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; +} + + +/************************* + * Initialize the hidden aggregate member, vthis, with + * the context pointer. + * Returns: + * *(ey + ad.vthis.offset) = this; + */ +#if DMDV2 +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; +} +#endif + +/******************************************* + * Convert intrinsic function to operator. + * Returns that operator, -1 if not an intrinsic function. + */ + +int intrinsic_op(char *name) +{ + //printf("intrinsic_op(%s)\n", name); + static const char *std_namearray[] = + { +#if DMDV1 + "4math3cosFeZe", + "4math3sinFeZe", + "4math4fabsFeZe", + "4math4rintFeZe", + "4math4sqrtFdZd", + "4math4sqrtFeZe", + "4math4sqrtFfZf", + "4math4yl2xFeeZe", + "4math5ldexpFeiZe", + "4math6rndtolFeZl", + "4math6yl2xp1FeeZe", + + "9intrinsic2btFPkkZi", + "9intrinsic3bsfFkZi", + "9intrinsic3bsrFkZi", + "9intrinsic3btcFPkkZi", + "9intrinsic3btrFPkkZi", + "9intrinsic3btsFPkkZi", + "9intrinsic3inpFkZh", + "9intrinsic4inplFkZk", + "9intrinsic4inpwFkZt", + "9intrinsic4outpFkhZh", + "9intrinsic5bswapFkZk", + "9intrinsic5outplFkkZk", + "9intrinsic5outpwFktZt", +#elif DMDV2 + /* The names are mangled differently because of the pure and + * nothrow attributes. + */ + "4math3cosFNaNbNfeZe", + "4math3sinFNaNbNfeZe", + "4math4fabsFNaNbNfeZe", + "4math4rintFNaNbNfeZe", + "4math4sqrtFNaNbNfdZd", + "4math4sqrtFNaNbNfeZe", + "4math4sqrtFNaNbNffZf", + "4math4yl2xFNaNbNfeeZe", + "4math5ldexpFNaNbNfeiZe", + "4math6rndtolFNaNbNfeZl", + "4math6yl2xp1FNaNbNfeeZe", + + "9intrinsic2btFNaNbxPkkZi", + "9intrinsic3bsfFNaNbkZi", + "9intrinsic3bsrFNaNbkZi", + "9intrinsic3btcFNbPkkZi", + "9intrinsic3btrFNbPkkZi", + "9intrinsic3btsFNbPkkZi", + "9intrinsic3inpFNbkZh", + "9intrinsic4inplFNbkZk", + "9intrinsic4inpwFNbkZt", + "9intrinsic4outpFNbkhZh", + "9intrinsic5bswapFNaNbkZk", + "9intrinsic5outplFNbkkZk", + "9intrinsic5outpwFNbktZt", +#endif + }; + static const char *std_namearray64[] = + { +#if DMDV1 + "4math3cosFeZe", + "4math3sinFeZe", + "4math4fabsFeZe", + "4math4rintFeZe", + "4math4sqrtFdZd", + "4math4sqrtFeZe", + "4math4sqrtFfZf", + "4math4yl2xFeeZe", + "4math5ldexpFeiZe", + "4math6rndtolFeZl", + "4math6yl2xp1FeeZe", + + "9intrinsic2btFPmmZi", + "9intrinsic3bsfFkZi", + "9intrinsic3bsrFkZi", + "9intrinsic3btcFPmmZi", + "9intrinsic3btrFPmmZi", + "9intrinsic3btsFPmmZi", + "9intrinsic3inpFkZh", + "9intrinsic4inplFkZk", + "9intrinsic4inpwFkZt", + "9intrinsic4outpFkhZh", + "9intrinsic5bswapFkZk", + "9intrinsic5outplFkkZk", + "9intrinsic5outpwFktZt", +#elif DMDV2 + /* The names are mangled differently because of the pure and + * nothrow attributes. + */ + "4math3cosFNaNbNfeZe", + "4math3sinFNaNbNfeZe", + "4math4fabsFNaNbNfeZe", + "4math4rintFNaNbNfeZe", + "4math4sqrtFNaNbNfdZd", + "4math4sqrtFNaNbNfeZe", + "4math4sqrtFNaNbNffZf", + "4math4yl2xFNaNbNfeeZe", + "4math5ldexpFNaNbNfeiZe", + "4math6rndtolFNaNbNfeZl", + "4math6yl2xp1FNaNbNfeeZe", + + "9intrinsic2btFNaNbxPmmZi", + "9intrinsic3bsfFNaNbmZi", + "9intrinsic3bsrFNaNbmZi", + "9intrinsic3btcFNbPmmZi", + "9intrinsic3btrFNbPmmZi", + "9intrinsic3btsFNbPmmZi", + "9intrinsic3inpFNbkZh", + "9intrinsic4inplFNbkZk", + "9intrinsic4inpwFNbkZt", + "9intrinsic4outpFNbkhZh", + "9intrinsic5bswapFNaNbkZk", + "9intrinsic5outplFNbkkZk", + "9intrinsic5outpwFNbktZt", +#endif + }; + static unsigned char std_ioptab[] = + { + OPcos, + OPsin, + OPabs, + OPrint, + OPsqrt, + OPsqrt, + OPsqrt, + OPyl2x, + OPscale, + OPrndtol, + OPyl2xp1, + + OPbt, + OPbsf, + OPbsr, + OPbtc, + OPbtr, + OPbts, + OPinp, + OPinp, + OPinp, + OPoutp, + OPbswap, + OPoutp, + OPoutp, + }; + +#ifdef DMDV2 + static const char *core_namearray[] = + { + "4math3cosFNaNbNfeZe", + "4math3sinFNaNbNfeZe", + "4math4fabsFNaNbNfeZe", + "4math4rintFNaNbNfeZe", + "4math4sqrtFNaNbNfdZd", + "4math4sqrtFNaNbNfeZe", + "4math4sqrtFNaNbNffZf", + "4math4yl2xFNaNbNfeeZe", + "4math5ldexpFNaNbNfeiZe", + "4math6rndtolFNaNbNfeZl", + "4math6yl2xp1FNaNbNfeeZe", + + "4simd6__simdFNaNbNfE4core4simd3XMMNhG16vNhG16vZNhG16v", + + "5bitop2btFNaNbxPkkZi", + "5bitop3bsfFNaNbkZi", + "5bitop3bsrFNaNbkZi", + "5bitop3btcFNbPkkZi", + "5bitop3btrFNbPkkZi", + "5bitop3btsFNbPkkZi", + "5bitop3inpFNbkZh", + "5bitop4inplFNbkZk", + "5bitop4inpwFNbkZt", + "5bitop4outpFNbkhZh", + "5bitop5bswapFNaNbkZk", + "5bitop5outplFNbkkZk", + "5bitop5outpwFNbktZt", + }; + static const char *core_namearray64[] = + { + "4math3cosFNaNbNfeZe", + "4math3sinFNaNbNfeZe", + "4math4fabsFNaNbNfeZe", + "4math4rintFNaNbNfeZe", + "4math4sqrtFNaNbNfdZd", + "4math4sqrtFNaNbNfeZe", + "4math4sqrtFNaNbNffZf", + "4math4yl2xFNaNbNfeeZe", + "4math5ldexpFNaNbNfeiZe", + "4math6rndtolFNaNbNfeZl", + "4math6yl2xp1FNaNbNfeeZe", + + "4simd6__simdFNaNbNfE4core4simd3XMMNhG16vNhG16vZNhG16v", + + "5bitop2btFNaNbxPmmZi", + "5bitop3bsfFNaNbmZi", + "5bitop3bsrFNaNbmZi", + "5bitop3btcFNbPmmZi", + "5bitop3btrFNbPmmZi", + "5bitop3btsFNbPmmZi", + "5bitop3inpFNbkZh", + "5bitop4inplFNbkZk", + "5bitop4inpwFNbkZt", + "5bitop4outpFNbkhZh", + "5bitop5bswapFNaNbkZk", + "5bitop5outplFNbkkZk", + "5bitop5outpwFNbktZt", + }; + static unsigned char core_ioptab[] = + { + OPcos, + OPsin, + OPabs, + OPrint, + OPsqrt, + OPsqrt, + OPsqrt, + OPyl2x, + OPscale, + OPrndtol, + OPyl2xp1, + + OPvector, + + OPbt, + OPbsf, + OPbsr, + OPbtc, + OPbtr, + OPbts, + OPinp, + OPinp, + OPinp, + OPoutp, + OPbswap, + OPoutp, + OPoutp, + }; +#endif + +#ifdef DEBUG + assert(sizeof(std_namearray) == sizeof(std_namearray64)); + assert(sizeof(std_namearray) / sizeof(char *) == sizeof(std_ioptab)); + for (size_t i = 0; i < sizeof(std_namearray) / sizeof(char *) - 1; i++) + { + if (strcmp(std_namearray[i], std_namearray[i + 1]) >= 0) + { + printf("std_namearray[%ld] = '%s'\n", (long)i, std_namearray[i]); + assert(0); + } + } + assert(sizeof(std_namearray64) / sizeof(char *) == sizeof(std_ioptab)); + for (size_t i = 0; i < sizeof(std_namearray64) / sizeof(char *) - 1; i++) + { + if (strcmp(std_namearray64[i], std_namearray64[i + 1]) >= 0) + { + printf("std_namearray64[%ld] = '%s'\n", (long)i, std_namearray64[i]); + assert(0); + } + } +#ifdef DMDV2 + assert(sizeof(core_namearray) == sizeof(core_namearray64)); + assert(sizeof(core_namearray) / sizeof(char *) == sizeof(core_ioptab)); + for (size_t i = 0; i < sizeof(core_namearray) / sizeof(char *) - 1; i++) + { + if (strcmp(core_namearray[i], core_namearray[i + 1]) >= 0) + { + printf("core_namearray[%ld] = '%s'\n", (long)i, core_namearray[i]); + assert(0); + } + } + assert(sizeof(core_namearray64) / sizeof(char *) == sizeof(core_ioptab)); + for (size_t i = 0; i < sizeof(core_namearray64) / sizeof(char *) - 1; i++) + { + if (strcmp(core_namearray64[i], core_namearray64[i + 1]) >= 0) + { + printf("core_namearray64[%ld] = '%s'\n", (long)i, core_namearray64[i]); + assert(0); + } + } +#endif +#endif + size_t length = strlen(name); + + if (length > 10 && + (name[7] == 'm' || name[7] == 'i') && + !memcmp(name, "_D3std", 6)) + { + int i = binary(name + 6, I64 ? std_namearray64 : std_namearray, sizeof(std_namearray) / sizeof(char *)); + return (i == -1) ? i : std_ioptab[i]; + } +#ifdef DMDV2 + if (length > 12 && + (name[8] == 'm' || name[8] == 'b' || name[8] == 's') && + !memcmp(name, "_D4core", 7)) + { + int i = binary(name + 7, I64 ? core_namearray64 : core_namearray, sizeof(core_namearray) / sizeof(char *)); + return (i == -1) ? i : core_ioptab[i]; + } +#endif + return -1; +} + + +/************************************** + * Given an expression e that is an array, + * determine and set the 'length' variable. + * Input: + * lengthVar Symbol of 'length' variable + * &e expression that is the array + * t1 Type of the array + * Output: + * e is rewritten to avoid side effects + * Returns: + * expression that initializes 'length' + */ + +elem *resolveLengthVar(VarDeclaration *lengthVar, elem **pe, Type *t1) +{ + //printf("resolveLengthVar()\n"); + elem *einit = NULL; + + if (lengthVar && !(lengthVar->storage_class & STCconst)) + { elem *elength; + Symbol *slength; + + if (t1->ty == Tsarray) + { TypeSArray *tsa = (TypeSArray *)t1; + dinteger_t length = tsa->dim->toInteger(); + + elength = el_long(TYsize_t, length); + goto L3; + } + else if (t1->ty == Tarray) + { + elength = *pe; + *pe = el_same(&elength); + elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, elength); + + L3: + slength = lengthVar->toSymbol(); + //symbol_add(slength); + + einit = el_bin(OPeq, TYsize_t, el_var(slength), elength); + } + } + return einit; +} + +/************************************* + * Closures are implemented by taking the local variables that + * need to survive the scope of the function, and copying them + * into a gc allocated chuck of memory. That chunk, called the + * closure here, is inserted into the linked list of stack + * frames instead of the usual stack frame. + * + * buildClosure() inserts code just after the function prolog + * is complete. It allocates memory for the closure, allocates + * a local variable (sclosure) to point to it, inserts into it + * the link to the enclosing frame, and copies into it the parameters + * that are referred to in nested functions. + * In VarExp::toElem and SymOffExp::toElem, when referring to a + * variable that is in a closure, takes the offset from sclosure rather + * than from the frame pointer. + * + * getEthis() and NewExp::toElem need to use sclosure, if set, rather + * than the current frame pointer. + */ + +#if DMDV2 + +void FuncDeclaration::buildClosure(IRState *irs) +{ + if (needsClosure()) + { // Generate closure on the heap + // BUG: doesn't capture variadic arguments passed to this function + +#if DMDV2 + /* BUG: doesn't handle destructors for the local variables. + * The way to do it is to make the closure variables the fields + * of a class object: + * class Closure + * { vtbl[] + * monitor + * ptr to destructor + * sthis + * ... closure variables ... + * ~this() { call destructor } + * } + */ +#endif + //printf("FuncDeclaration::buildClosure()\n"); + Symbol *sclosure; + sclosure = symbol_name("__closptr",SCauto,Type::tvoidptr->toCtype()); + sclosure->Sflags |= SFLtrue | SFLfree; + symbol_add(sclosure); + irs->sclosure = sclosure; + + unsigned offset = PTRSIZE; // leave room for previous sthis + for (size_t i = 0; i < closureVars.dim; i++) + { VarDeclaration *v = closureVars.tdata()[i]; + assert(v->isVarDeclaration()); + +#if DMDV2 + if (v->needsAutoDtor()) + /* Because the value needs to survive the end of the scope! + */ + v->error("has scoped destruction, cannot build closure"); + if (v->isargptr) + /* See Bugzilla 2479 + * This is actually a bug, but better to produce a nice + * message at compile time rather than memory corruption at runtime + */ + v->error("cannot reference variadic arguments from closure"); +#endif + /* Align and allocate space for v in the closure + * just like AggregateDeclaration::addField() does. + */ + unsigned memsize; + unsigned memalignsize; + unsigned xalign; +#if DMDV2 + if (v->storage_class & STClazy) + { + /* Lazy variables are really delegates, + * so give same answers that TypeDelegate would + */ + memsize = PTRSIZE * 2; + memalignsize = memsize; + xalign = global.structalign; + } + else if (v->isRef() || v->isOut()) + { // reference parameters are just pointers + memsize = PTRSIZE; + memalignsize = memsize; + xalign = global.structalign; + } + else +#endif + { + memsize = v->type->size(); + memalignsize = v->type->alignsize(); + xalign = v->type->memalign(global.structalign); + } + AggregateDeclaration::alignmember(xalign, memalignsize, &offset); + v->offset = offset; + offset += memsize; + + /* Can't do nrvo if the variable is put in a closure, since + * what the shidden points to may no longer exist. + */ + if (nrvo_can && nrvo_var == v) + { + nrvo_can = 0; + } + } + // offset is now the size of the closure + + // Allocate memory for the closure + elem *e; + e = el_long(TYsize_t, offset); + e = el_bin(OPcall, TYnptr, el_var(rtlsym[RTLSYM_ALLOCMEMORY]), e); + + // Assign block of memory to sclosure + // sclosure = allocmemory(sz); + e = el_bin(OPeq, TYvoid, el_var(sclosure), e); + + // Set the first element to sthis + // *(sclosure + 0) = sthis; + elem *ethis; + if (irs->sthis) + ethis = el_var(irs->sthis); + else + ethis = el_long(TYnptr, 0); + elem *ex = el_una(OPind, TYnptr, el_var(sclosure)); + ex = el_bin(OPeq, TYnptr, ex, ethis); + e = el_combine(e, ex); + + // Copy function parameters into closure + for (size_t i = 0; i < closureVars.dim; i++) + { VarDeclaration *v = closureVars.tdata()[i]; + + if (!v->isParameter()) + continue; + tym_t tym = v->type->totym(); + if ( +#if !SARRAYVALUE + v->type->toBasetype()->ty == Tsarray || +#endif + v->isOut() || v->isRef()) + tym = TYnptr; // reference parameters are just pointers +#if DMDV2 + else if (v->storage_class & STClazy) + tym = TYdelegate; +#endif + ex = el_bin(OPadd, TYnptr, el_var(sclosure), el_long(TYsize_t, v->offset)); + ex = el_una(OPind, tym, ex); + if (tybasic(ex->Ety) == TYstruct || tybasic(ex->Ety) == TYarray) + { + ::type *t = v->type->toCtype(); + ex->ET = t; + ex = el_bin(OPstreq, tym, ex, el_var(v->toSymbol())); + ex->ET = t; + } + else + ex = el_bin(OPeq, tym, ex, el_var(v->toSymbol())); + + e = el_combine(e, ex); + } + + block_appendexp(irs->blx->curblock, e); + } +} + +#endif + +/*************************** + * Determine return style of function - whether in registers or + * through a hidden pointer to the caller's stack. + */ + +enum RET TypeFunction::retStyle() +{ + //printf("TypeFunction::retStyle() %s\n", toChars()); +#if DMDV2 + if (isref) + return RETregs; // returns a pointer +#endif + + Type *tn = next->toBasetype(); + Type *tns = tn; + d_uns64 sz = tn->size(); + +#if SARRAYVALUE + if (tn->ty == Tsarray) + { + do + { + tns = tns->nextOf()->toBasetype(); + } while (tns->ty == Tsarray); + if (tns->ty != Tstruct) + { + if (global.params.isLinux && linkage != LINKd) + ; + else + { + switch (sz) + { case 1: + case 2: + case 4: + case 8: + return RETregs; // return small structs in regs + // (not 3 byte structs!) + default: + break; + } + } + return RETstack; + } + } +#endif + + if (tns->ty == Tstruct) + { StructDeclaration *sd = ((TypeStruct *)tn)->sym; + if (global.params.isLinux && linkage != LINKd) + ; +#if DMDV2 + else if (sd->dtor || sd->cpctor) + ; +#endif + else + { + switch (sz) + { case 1: + case 2: + case 4: + case 8: + return RETregs; // return small structs in regs + // (not 3 byte structs!) + default: + break; + } + } + return RETstack; + } + else if ((global.params.isLinux || global.params.isOSX || global.params.isFreeBSD || global.params.isSolaris) && + linkage == LINKc && + tn->iscomplex()) + { + if (tn->ty == Tcomplex32) + return RETregs; // in EDX:EAX, not ST1:ST0 + else + return RETstack; + } + else + return RETregs; +} + + diff --git a/toir.h b/toir.h new file mode 100644 index 00000000..246d6128 --- /dev/null +++ b/toir.h @@ -0,0 +1,21 @@ + +// Copyright (c) 1999-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +/* Code to help convert to the intermediate representation + * of the compiler back end. + * It's specific to the Digital Mars back end, but can serve + * as a guide to hooking up to other back ends. + */ + +elem *incUsageElem(IRState *irs, Loc loc); +elem *getEthis(Loc loc, IRState *irs, Dsymbol *fd); +elem *setEthis(Loc loc, IRState *irs, elem *ey, AggregateDeclaration *ad); +int intrinsic_op(char *name); +elem *resolveLengthVar(VarDeclaration *lengthVar, elem **pe, Type *t1); + diff --git a/toobj.c b/toobj.c new file mode 100644 index 00000000..a8071e87 --- /dev/null +++ b/toobj.c @@ -0,0 +1,1408 @@ + +// Copyright (c) 1999-2012 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "declaration.h" +#include "statement.h" +#include "enum.h" +#include "aggregate.h" +#include "init.h" +#include "attrib.h" +#include "id.h" +#include "import.h" +#include "template.h" + +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" + +void obj_lzext(Symbol *s1,Symbol *s2); + +/* ================================================================== */ + +// Put out instance of ModuleInfo for this Module + +void Module::genmoduleinfo() +{ + //printf("Module::genmoduleinfo() %s\n", toChars()); + + Symbol *msym = toSymbol(); +#if DMDV2 + unsigned sizeof_ModuleInfo = 16 * PTRSIZE; +#else + unsigned sizeof_ModuleInfo = 14 * PTRSIZE; +#endif +#if !MODULEINFO_IS_STRUCT + sizeof_ModuleInfo -= 2 * PTRSIZE; +#endif + //printf("moduleinfo size = x%x\n", sizeof_ModuleInfo); + + ////////////////////////////////////////////// + + csym->Sclass = SCglobal; + csym->Sfl = FLdata; + +#if 1 + dt_t *dt = NULL; + ClassDeclarations aclasses; + + //printf("members->dim = %d\n", members->dim); + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *member = members->tdata()[i]; + + //printf("\tmember '%s'\n", member->toChars()); + member->addLocalClass(&aclasses); + } + + // importedModules[] + size_t aimports_dim = aimports.dim; + for (size_t i = 0; i < aimports.dim; i++) + { Module *m = aimports.tdata()[i]; + if (!m->needmoduleinfo) + aimports_dim--; + } + + FuncDeclaration *sgetmembers = findGetMembers(); + + // These must match the values in druntime/src/object_.d + #define MIstandalone 4 + #define MItlsctor 8 + #define MItlsdtor 0x10 + #define MIctor 0x20 + #define MIdtor 0x40 + #define MIxgetMembers 0x80 + #define MIictor 0x100 + #define MIunitTest 0x200 + #define MIimportedModules 0x400 + #define MIlocalClasses 0x800 + #define MInew 0x80000000 // it's the "new" layout + + unsigned flags = MInew; + if (sctor) + flags |= MItlsctor; + if (sdtor) + flags |= MItlsdtor; + if (ssharedctor) + flags |= MIctor; + if (sshareddtor) + flags |= MIdtor; + if (sgetmembers) + flags |= MIxgetMembers; + if (sictor) + flags |= MIictor; + if (stest) + flags |= MIunitTest; + if (aimports_dim) + flags |= MIimportedModules; + if (aclasses.dim) + flags |= MIlocalClasses; + + if (!needmoduleinfo) + flags |= MIstandalone; + + dtdword(&dt, flags); // n.flags + dtdword(&dt, 0); // n.index + + if (flags & MItlsctor) + dtxoff(&dt, sctor, 0, TYnptr); + if (flags & MItlsdtor) + dtxoff(&dt, sdtor, 0, TYnptr); + if (flags & MIctor) + dtxoff(&dt, ssharedctor, 0, TYnptr); + if (flags & MIdtor) + dtxoff(&dt, sshareddtor, 0, TYnptr); + if (flags & MIxgetMembers) + dtxoff(&dt, sgetmembers->toSymbol(), 0, TYnptr); + if (flags & MIictor) + dtxoff(&dt, sictor, 0, TYnptr); + if (flags & MIunitTest) + dtxoff(&dt, stest, 0, TYnptr); + if (flags & MIimportedModules) + { + dtsize_t(&dt, aimports_dim); + for (size_t i = 0; i < aimports.dim; i++) + { Module *m = aimports[i]; + + if (m->needmoduleinfo) + { Symbol *s = m->toSymbol(); + + /* Weak references don't pull objects in from the library, + * they resolve to 0 if not pulled in by something else. + * Don't pull in a module just because it was imported. + */ +#if !OMFOBJ // Optlink crashes with weak symbols at EIP 41AFE7, 402000 + s->Sflags |= SFLweak; +#endif + dtxoff(&dt, s, 0, TYnptr); + } + } + } + if (flags & MIlocalClasses) + { + dtsize_t(&dt, aclasses.dim); + for (size_t i = 0; i < aclasses.dim; i++) + { + ClassDeclaration *cd = aclasses.tdata()[i]; + dtxoff(&dt, cd->toSymbol(), 0, TYnptr); + } + } + + // Put out module name as a 0-terminated string, to save bytes + nameoffset = dt_size(dt); + const char *name = toPrettyChars(); + namelen = strlen(name); + dtnbytes(&dt, namelen + 1, name); + //printf("nameoffset = x%x\n", nameoffset); +#else + /* The layout is: + { + void **vptr; + monitor_t monitor; + char[] name; // class name + ModuleInfo importedModules[]; + ClassInfo localClasses[]; + uint flags; // initialization state + void *ctor; + void *dtor; + void *unitTest; + const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function + void *ictor; + void *sharedctor; + void *shareddtor; + uint index; + void*[1] reserved; + } + */ + dt_t *dt = NULL; + +#if !MODULEINFO_IS_STRUCT + if (moduleinfo) + dtxoff(&dt, moduleinfo->toVtblSymbol(), 0, TYnptr); // vtbl for ModuleInfo + else + { //printf("moduleinfo is null\n"); + dtdword(&dt, 0); // BUG: should be an assert() + } + dtdword(&dt, 0); // monitor +#endif + + // name[] + const char *name = toPrettyChars(); + size_t namelen = strlen(name); + dtdword(&dt, namelen); + dtabytes(&dt, TYnptr, 0, namelen + 1, name); + + ClassDeclarations aclasses; + + //printf("members->dim = %d\n", members->dim); + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *member = members->tdata()[i]; + + //printf("\tmember '%s'\n", member->toChars()); + member->addLocalClass(&aclasses); + } + + // importedModules[] + int aimports_dim = aimports.dim; + for (size_t i = 0; i < aimports.dim; i++) + { Module *m = aimports.tdata()[i]; + if (!m->needModuleInfo()) + aimports_dim--; + } + dtdword(&dt, aimports_dim); + if (aimports_dim) + dtxoff(&dt, csym, sizeof_ModuleInfo, TYnptr); + else + dtdword(&dt, 0); + + // localClasses[] + dtdword(&dt, aclasses.dim); + if (aclasses.dim) + dtxoff(&dt, csym, sizeof_ModuleInfo + aimports_dim * PTRSIZE, TYnptr); + else + dtdword(&dt, 0); + + if (needmoduleinfo) + dtdword(&dt, 8); // flags + else + dtdword(&dt, 8 | MIstandalone); // flags + + if (ssharedctor) + dtxoff(&dt, ssharedctor, 0, TYnptr); + else + dtdword(&dt, 0); + + if (sshareddtor) + dtxoff(&dt, sshareddtor, 0, TYnptr); + else + dtdword(&dt, 0); + + if (stest) + dtxoff(&dt, stest, 0, TYnptr); + else + dtdword(&dt, 0); + +#if DMDV2 + FuncDeclaration *sgetmembers = findGetMembers(); + if (sgetmembers) + dtxoff(&dt, sgetmembers->toSymbol(), 0, TYnptr); + else +#endif + dtdword(&dt, 0); // xgetMembers + + if (sictor) + dtxoff(&dt, sictor, 0, TYnptr); + else + dtdword(&dt, 0); + +#if DMDV2 + if (sctor) + dtxoff(&dt, sctor, 0, TYnptr); + else + dtdword(&dt, 0); + + if (sdtor) + dtxoff(&dt, sdtor, 0, TYnptr); + else + dtdword(&dt, 0); + + dtdword(&dt, 0); // index + + // void*[1] reserved; + dtdword(&dt, 0); +#endif + ////////////////////////////////////////////// + + for (size_t i = 0; i < aimports.dim; i++) + { Module *m = aimports.tdata()[i]; + + if (m->needModuleInfo()) + { Symbol *s = m->toSymbol(); + + /* Weak references don't pull objects in from the library, + * they resolve to 0 if not pulled in by something else. + * Don't pull in a module just because it was imported. + */ +#if !OMFOBJ // Optlink crashes with weak symbols at EIP 41AFE7, 402000 + s->Sflags |= SFLweak; +#endif + dtxoff(&dt, s, 0, TYnptr); + } + } + + for (size_t i = 0; i < aclasses.dim; i++) + { + ClassDeclaration *cd = aclasses.data()[i]; + dtxoff(&dt, cd->toSymbol(), 0, TYnptr); + } +#endif + + csym->Sdt = dt; +#if ELFOBJ || MACHOBJ + // Cannot be CONST because the startup code sets flag bits in it + csym->Sseg = DATA; +#endif + outdata(csym); + + ////////////////////////////////////////////// + + obj_moduleinfo(msym); +} + +/* ================================================================== */ + +void Dsymbol::toObjFile(int multiobj) +{ + //printf("Dsymbol::toObjFile('%s')\n", toChars()); + // ignore +} + +/* ================================================================== */ + +void ClassDeclaration::toObjFile(int multiobj) +{ + unsigned offset; + Symbol *sinit; + enum_SC scclass; + + //printf("ClassDeclaration::toObjFile('%s')\n", toChars()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + + if (!members) + return; + + if (multiobj && !hasStaticCtorOrDtor()) + { obj_append(this); + return; + } + + if (global.params.symdebug) + toDebug(); + + assert(!scope); // semantic() should have been run to completion + + scclass = SCglobal; + if (inTemplateInstance()) + scclass = SCcomdat; + + // Put out the members + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *member = (*members)[i]; + /* There might be static ctors in the members, and they cannot + * be put in separate obj files. + */ + member->toObjFile(multiobj); + } + +#if 0 + // Build destructor by aggregating dtors[] + Symbol *sdtor; + switch (dtors.dim) + { case 0: + // No destructors for this class + sdtor = NULL; + break; + + case 1: + // One destructor, just use it directly + sdtor = dtors[0]->toSymbol(); + break; + + default: + { /* Build a destructor that calls all the + * other destructors in dtors[]. + */ + + elem *edtor = NULL; + + // Declare 'this' pointer for our new destructor + Symbol *sthis = symbol_calloc("this"); + sthis->Stype = type_fake(TYnptr); + sthis->Stype->Tcount++; + sthis->Sclass = SCfastpar; + sthis->Spreg = AX; + sthis->Sfl = FLauto; + + // Call each of the destructors in dtors[] + // in reverse order + for (size_t i = 0; i < dtors.dim; i++) + { DtorDeclaration *d = dtors[i]; + Symbol *s = d->toSymbol(); + elem *e = el_bin(OPcall, TYvoid, el_var(s), el_var(sthis)); + edtor = el_combine(e, edtor); + } + + // Create type for the function + ::type *t = type_alloc(TYjfunc); + t->Tflags |= TFprototype | TFfixed; + t->Tmangle = mTYman_d; + t->Tnext = tsvoid; + tsvoid->Tcount++; + + // Create the function, sdtor, and write it out + localgot = NULL; + sdtor = toSymbolX("__dtor", SCglobal, t, "FZv"); + block *b = block_calloc(); + b->BC = BCret; + b->Belem = edtor; + sdtor->Sfunc->Fstartblock = b; + cstate.CSpsymtab = &sdtor->Sfunc->Flocsym; + symbol_add(sthis); + writefunc(sdtor); + } + } +#endif + + // Generate C symbols + toSymbol(); + toVtblSymbol(); + sinit = toInitializer(); + + ////////////////////////////////////////////// + + // Generate static initializer + sinit->Sclass = scclass; + sinit->Sfl = FLdata; +#if ELFOBJ // Burton + sinit->Sseg = CDATA; +#endif +#if MACHOBJ + sinit->Sseg = DATA; +#endif + toDt(&sinit->Sdt); + outdata(sinit); + + ////////////////////////////////////////////// + + // Put out the TypeInfo + type->getTypeInfo(NULL); + //type->vtinfo->toObjFile(multiobj); + + ////////////////////////////////////////////// + + // Put out the ClassInfo + csym->Sclass = scclass; + csym->Sfl = FLdata; + + /* The layout is: + { + void **vptr; + monitor_t monitor; + byte[] initializer; // static initialization data + char[] name; // class name + void *[] vtbl; + Interface[] interfaces; + ClassInfo *base; // base class + void *destructor; + void *invariant; // class invariant + uint flags; + void *deallocator; + OffsetTypeInfo[] offTi; + void *defaultConstructor; + const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function + //TypeInfo typeinfo; + } + */ + dt_t *dt = NULL; + unsigned classinfo_size = global.params.is64bit ? CLASSINFO_SIZE_64 : CLASSINFO_SIZE; // must be ClassInfo.size + offset = classinfo_size; + if (classinfo) + { + if (classinfo->structsize != classinfo_size) + { +#ifdef DEBUG + printf("CLASSINFO_SIZE = x%x, classinfo->structsize = x%x\n", offset, classinfo->structsize); +#endif + error("mismatch between dmd and object.d or object.di found. Check installation and import paths with -v compiler switch."); + fatal(); + } + } + + if (classinfo) + dtxoff(&dt, classinfo->toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo + else + dtsize_t(&dt, 0); // BUG: should be an assert() + dtsize_t(&dt, 0); // monitor + + // initializer[] + assert(structsize >= 8); + dtsize_t(&dt, structsize); // size + dtxoff(&dt, sinit, 0, TYnptr); // initializer + + // name[] + const char *name = ident->toChars(); + size_t namelen = strlen(name); + if (!(namelen > 9 && memcmp(name, "TypeInfo_", 9) == 0)) + { name = toPrettyChars(); + namelen = strlen(name); + } + dtsize_t(&dt, namelen); + dtabytes(&dt, TYnptr, 0, namelen + 1, name); + + // vtbl[] + dtsize_t(&dt, vtbl.dim); + dtxoff(&dt, vtblsym, 0, TYnptr); + + // interfaces[] + dtsize_t(&dt, vtblInterfaces->dim); + if (vtblInterfaces->dim) + dtxoff(&dt, csym, offset, TYnptr); // (*) + else + dtsize_t(&dt, 0); + + // base + if (baseClass) + dtxoff(&dt, baseClass->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); + + // destructor + if (dtor) + dtxoff(&dt, dtor->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); + + // invariant + if (inv) + dtxoff(&dt, inv->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); + + // flags + int flags = 4 | isCOMclass(); +#if DMDV2 + flags |= 16; +#endif + flags |= 32; + if (ctor) + flags |= 8; + if (isabstract) + flags |= 64; + for (ClassDeclaration *cd = this; cd; cd = cd->baseClass) + { + if (cd->members) + { + for (size_t i = 0; i < cd->members->dim; i++) + { + Dsymbol *sm = cd->members->tdata()[i]; + //printf("sm = %s %s\n", sm->kind(), sm->toChars()); + if (sm->hasPointers()) + goto L2; + } + } + } + flags |= 2; // no pointers + L2: + dtsize_t(&dt, flags); + + + // deallocator + if (aggDelete) + dtxoff(&dt, aggDelete->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); + + // offTi[] + dtsize_t(&dt, 0); + dtsize_t(&dt, 0); // null for now, fix later + + // defaultConstructor + if (defaultCtor) + dtxoff(&dt, defaultCtor->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); + +#if DMDV2 + FuncDeclaration *sgetmembers = findGetMembers(); + if (sgetmembers) + dtxoff(&dt, sgetmembers->toSymbol(), 0, TYnptr); + else + dtsize_t(&dt, 0); // module getMembers() function +#endif + + //dtxoff(&dt, type->vtinfo->toSymbol(), 0, TYnptr); // typeinfo + + ////////////////////////////////////////////// + + // Put out vtblInterfaces->tdata()[]. Must immediately follow csym, because + // of the fixup (*) + + offset += vtblInterfaces->dim * (4 * PTRSIZE); + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + ClassDeclaration *id = b->base; + + /* The layout is: + * struct Interface + * { + * ClassInfo *interface; + * void *[] vtbl; + * ptrdiff_t offset; + * } + */ + + // Fill in vtbl[] + b->fillVtbl(this, &b->vtbl, 1); + + dtxoff(&dt, id->toSymbol(), 0, TYnptr); // ClassInfo + + // vtbl[] + dtsize_t(&dt, id->vtbl.dim); + dtxoff(&dt, csym, offset, TYnptr); + + dtsize_t(&dt, b->offset); // this offset + + offset += id->vtbl.dim * PTRSIZE; + } + + // Put out the vtblInterfaces->tdata()[].vtbl[] + // This must be mirrored with ClassDeclaration::baseVtblOffset() + //printf("putting out %d interface vtbl[]s for '%s'\n", vtblInterfaces->dim, toChars()); + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + ClassDeclaration *id = b->base; + + //printf(" interface[%d] is '%s'\n", i, id->toChars()); + size_t j = 0; + if (id->vtblOffset()) + { + // First entry is ClassInfo reference + //dtxoff(&dt, id->toSymbol(), 0, TYnptr); + + // First entry is struct Interface reference + dtxoff(&dt, csym, classinfo_size + i * (4 * PTRSIZE), TYnptr); + j = 1; + } + assert(id->vtbl.dim == b->vtbl.dim); + for (; j < id->vtbl.dim; j++) + { + assert(j < b->vtbl.dim); +#if 0 + Object *o = b->vtbl.tdata()[j]; + if (o) + { + printf("o = %p\n", o); + assert(o->dyncast() == DYNCAST_DSYMBOL); + Dsymbol *s = (Dsymbol *)o; + printf("s->kind() = '%s'\n", s->kind()); + } +#endif + FuncDeclaration *fd = b->vtbl.tdata()[j]; + if (fd) + dtxoff(&dt, fd->toThunkSymbol(b->offset), 0, TYnptr); + else + dtsize_t(&dt, 0); + } + } + +#if 1 + // Put out the overriding interface vtbl[]s. + // This must be mirrored with ClassDeclaration::baseVtblOffset() + //printf("putting out overriding interface vtbl[]s for '%s' at offset x%x\n", toChars(), offset); + ClassDeclaration *cd; + FuncDeclarations bvtbl; + + for (cd = this->baseClass; cd; cd = cd->baseClass) + { + for (size_t k = 0; k < cd->vtblInterfaces->dim; k++) + { BaseClass *bs = cd->vtblInterfaces->tdata()[k]; + + if (bs->fillVtbl(this, &bvtbl, 0)) + { + //printf("\toverriding vtbl[] for %s\n", bs->base->toChars()); + ClassDeclaration *id = bs->base; + + size_t j = 0; + if (id->vtblOffset()) + { + // First entry is ClassInfo reference + //dtxoff(&dt, id->toSymbol(), 0, TYnptr); + + // First entry is struct Interface reference + dtxoff(&dt, cd->toSymbol(), classinfo_size + k * (4 * PTRSIZE), TYnptr); + j = 1; + } + + for (; j < id->vtbl.dim; j++) + { + FuncDeclaration *fd; + + assert(j < bvtbl.dim); + fd = bvtbl.tdata()[j]; + if (fd) + dtxoff(&dt, fd->toThunkSymbol(bs->offset), 0, TYnptr); + else + dtsize_t(&dt, 0); + } + } + } + } +#endif +#if INTERFACE_VIRTUAL + // Put out the overriding interface vtbl[]s. + // This must be mirrored with ClassDeclaration::baseVtblOffset() + //printf("putting out overriding interface vtbl[]s for '%s' at offset x%x\n", toChars(), offset); + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + ClassDeclaration *cd; + + for (cd = this->baseClass; cd; cd = cd->baseClass) + { + for (size_t k = 0; k < cd->vtblInterfaces->dim; k++) + { BaseClass *bs = cd->vtblInterfaces->tdata()[k]; + + if (b->base == bs->base) + { + //printf("\toverriding vtbl[] for %s\n", b->base->toChars()); + ClassDeclaration *id = b->base; + + size_t j = 0; + if (id->vtblOffset()) + { + // First entry is ClassInfo reference + //dtxoff(&dt, id->toSymbol(), 0, TYnptr); + + // First entry is struct Interface reference + dtxoff(&dt, cd->toSymbol(), classinfo_size + k * (4 * PTRSIZE), TYnptr); + j = 1; + } + + for (; j < id->vtbl.dim; j++) + { + assert(j < b->vtbl.dim); + FuncDeclaration *fd = b->vtbl.tdata()[j]; + if (fd) + dtxoff(&dt, fd->toThunkSymbol(bs->offset), 0, TYnptr); + else + dtsize_t(&dt, 0); + } + } + } + } + } +#endif + + + csym->Sdt = dt; +#if ELFOBJ || MACHOBJ // Burton + // ClassInfo cannot be const data, because we use the monitor on it + csym->Sseg = DATA; +#endif + outdata(csym); + if (isExport()) + obj_export(csym,0); + + ////////////////////////////////////////////// + + // Put out the vtbl[] + //printf("putting out %s.vtbl[]\n", toChars()); + dt = NULL; + dtxoff(&dt, csym, 0, TYnptr); // first entry is ClassInfo reference + for (size_t i = 1; i < vtbl.dim; i++) + { + FuncDeclaration *fd = vtbl.tdata()[i]->isFuncDeclaration(); + + //printf("\tvtbl[%d] = %p\n", i, fd); + if (fd && (fd->fbody || !isAbstract())) + { + // Ensure function has a return value (Bugzilla 4869) + if (fd->type->ty == Tfunction && !((TypeFunction *)fd->type)->next) + { + assert(fd->scope); + fd->semantic3(fd->scope); + } + + Symbol *s = fd->toSymbol(); + +#if DMDV2 + if (isFuncHidden(fd)) + { /* fd is hidden from the view of this class. + * If fd overlaps with any function in the vtbl[], then + * issue 'hidden' error. + */ + for (size_t j = 1; j < vtbl.dim; j++) + { if (j == i) + continue; + FuncDeclaration *fd2 = vtbl.tdata()[j]->isFuncDeclaration(); + if (!fd2->ident->equals(fd->ident)) + continue; + if (fd->leastAsSpecialized(fd2) || fd2->leastAsSpecialized(fd)) + { + if (!global.params.useDeprecated) + { + TypeFunction *tf = (TypeFunction *)fd->type; + if (tf->ty == Tfunction) + error("use of %s%s hidden by %s is deprecated\n", fd->toPrettyChars(), Parameter::argsTypesToChars(tf->parameters, tf->varargs), toChars()); + else + error("use of %s hidden by %s is deprecated\n", fd->toPrettyChars(), toChars()); + } + s = rtlsym[RTLSYM_DHIDDENFUNC]; + break; + } + } + } +#endif + dtxoff(&dt, s, 0, TYnptr); + } + else + dtsize_t(&dt, 0); + } + vtblsym->Sdt = dt; + vtblsym->Sclass = scclass; + vtblsym->Sfl = FLdata; +#if ELFOBJ + vtblsym->Sseg = CDATA; +#endif +#if MACHOBJ + vtblsym->Sseg = DATA; +#endif + outdata(vtblsym); + if (isExport()) + obj_export(vtblsym,0); +} + +/****************************************** + * Get offset of base class's vtbl[] initializer from start of csym. + * Returns ~0 if not this csym. + */ + +unsigned ClassDeclaration::baseVtblOffset(BaseClass *bc) +{ + unsigned csymoffset; + + //printf("ClassDeclaration::baseVtblOffset('%s', bc = %p)\n", toChars(), bc); + csymoffset = global.params.is64bit ? CLASSINFO_SIZE_64 : CLASSINFO_SIZE; // must be ClassInfo.size + csymoffset += vtblInterfaces->dim * (4 * PTRSIZE); + + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { + BaseClass *b = vtblInterfaces->tdata()[i]; + + if (b == bc) + return csymoffset; + csymoffset += b->base->vtbl.dim * PTRSIZE; + } + +#if 1 + // Put out the overriding interface vtbl[]s. + // This must be mirrored with ClassDeclaration::baseVtblOffset() + //printf("putting out overriding interface vtbl[]s for '%s' at offset x%x\n", toChars(), offset); + ClassDeclaration *cd; + FuncDeclarations bvtbl; + + for (cd = this->baseClass; cd; cd = cd->baseClass) + { + for (size_t k = 0; k < cd->vtblInterfaces->dim; k++) + { BaseClass *bs = cd->vtblInterfaces->tdata()[k]; + + if (bs->fillVtbl(this, NULL, 0)) + { + if (bc == bs) + { //printf("\tcsymoffset = x%x\n", csymoffset); + return csymoffset; + } + csymoffset += bs->base->vtbl.dim * PTRSIZE; + } + } + } +#endif +#if INTERFACE_VIRTUAL + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + ClassDeclaration *cd; + + for (cd = this->baseClass; cd; cd = cd->baseClass) + { + //printf("\tbase class %s\n", cd->toChars()); + for (size_t k = 0; k < cd->vtblInterfaces->dim; k++) + { BaseClass *bs = cd->vtblInterfaces->tdata()[k]; + + if (bc == bs) + { //printf("\tcsymoffset = x%x\n", csymoffset); + return csymoffset; + } + if (b->base == bs->base) + csymoffset += bs->base->vtbl.dim * PTRSIZE; + } + } + } +#endif + + return ~0; +} + +/* ================================================================== */ + +void InterfaceDeclaration::toObjFile(int multiobj) +{ + enum_SC scclass; + + //printf("InterfaceDeclaration::toObjFile('%s')\n", toChars()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + + if (!members) + return; + + if (global.params.symdebug) + toDebug(); + + scclass = SCglobal; + if (inTemplateInstance()) + scclass = SCcomdat; + + // Put out the members + for (size_t i = 0; i < members->dim; i++) + { Dsymbol *member = members->tdata()[i]; + + member->toObjFile(0); + } + + // Generate C symbols + toSymbol(); + + ////////////////////////////////////////////// + + // Put out the TypeInfo + type->getTypeInfo(NULL); + type->vtinfo->toObjFile(multiobj); + + ////////////////////////////////////////////// + + // Put out the ClassInfo + csym->Sclass = scclass; + csym->Sfl = FLdata; + + /* The layout is: + { + void **vptr; + monitor_t monitor; + byte[] initializer; // static initialization data + char[] name; // class name + void *[] vtbl; + Interface[] interfaces; + Object *base; // base class + void *destructor; + void *invariant; // class invariant + uint flags; + void *deallocator; + OffsetTypeInfo[] offTi; + void *defaultConstructor; +#if DMDV2 + const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function +#endif + //TypeInfo typeinfo; + } + */ + dt_t *dt = NULL; + + if (classinfo) + dtxoff(&dt, classinfo->toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo + else + dtsize_t(&dt, 0); // BUG: should be an assert() + dtsize_t(&dt, 0); // monitor + + // initializer[] + dtsize_t(&dt, 0); // size + dtsize_t(&dt, 0); // initializer + + // name[] + const char *name = toPrettyChars(); + size_t namelen = strlen(name); + dtsize_t(&dt, namelen); + dtabytes(&dt, TYnptr, 0, namelen + 1, name); + + // vtbl[] + dtsize_t(&dt, 0); + dtsize_t(&dt, 0); + + // vtblInterfaces->tdata()[] + unsigned offset; + dtsize_t(&dt, vtblInterfaces->dim); + if (vtblInterfaces->dim) + { + offset = global.params.is64bit ? CLASSINFO_SIZE_64 : CLASSINFO_SIZE; // must be ClassInfo.size + if (classinfo) + { + if (classinfo->structsize != offset) + { + error("mismatch between dmd and object.d or object.di found. Check installation and import paths with -v compiler switch."); + fatal(); + } + } + dtxoff(&dt, csym, offset, TYnptr); // (*) + } + else + { offset = 0; + dtsize_t(&dt, 0); + } + + // base + assert(!baseClass); + dtsize_t(&dt, 0); + + // dtor + dtsize_t(&dt, 0); + + // invariant + dtsize_t(&dt, 0); + + // flags + dtsize_t(&dt, 4 | isCOMinterface() | 32); + + // deallocator + dtsize_t(&dt, 0); + + // offTi[] + dtsize_t(&dt, 0); + dtsize_t(&dt, 0); // null for now, fix later + + // defaultConstructor + dtsize_t(&dt, 0); + +#if DMDV2 + // xgetMembers + dtsize_t(&dt, 0); +#endif + + //dtxoff(&dt, type->vtinfo->toSymbol(), 0, TYnptr); // typeinfo + + ////////////////////////////////////////////// + + // Put out vtblInterfaces->tdata()[]. Must immediately follow csym, because + // of the fixup (*) + + offset += vtblInterfaces->dim * (4 * PTRSIZE); + for (size_t i = 0; i < vtblInterfaces->dim; i++) + { BaseClass *b = vtblInterfaces->tdata()[i]; + ClassDeclaration *id = b->base; + + // ClassInfo + dtxoff(&dt, id->toSymbol(), 0, TYnptr); + + // vtbl[] + dtsize_t(&dt, 0); + dtsize_t(&dt, 0); + + // this offset + dtsize_t(&dt, b->offset); + } + + csym->Sdt = dt; +#if ELFOBJ + csym->Sseg = CDATA; +#endif +#if MACHOBJ + csym->Sseg = DATA; +#endif + outdata(csym); + if (isExport()) + obj_export(csym,0); +} + +/* ================================================================== */ + +void StructDeclaration::toObjFile(int multiobj) +{ + //printf("StructDeclaration::toObjFile('%s')\n", toChars()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + + if (multiobj && !hasStaticCtorOrDtor()) + { obj_append(this); + return; + } + + // Anonymous structs/unions only exist as part of others, + // do not output forward referenced structs's + if (!isAnonymous() && members) + { + if (global.params.symdebug) + toDebug(); + + type->getTypeInfo(NULL); // generate TypeInfo + + if (1) + { + // Generate static initializer + toInitializer(); +#if 0 + sinit->Sclass = SCcomdat; +#else + if (inTemplateInstance()) + { + sinit->Sclass = SCcomdat; + } + else + { + sinit->Sclass = SCglobal; + } +#endif + sinit->Sfl = FLdata; + toDt(&sinit->Sdt); + +#if OMFOBJ + /* For OMF, common blocks aren't pulled in from the library. + */ + /* ELF comdef's generate multiple + * definition errors for them from the gnu linker. + * Need to figure out how to generate proper comdef's for ELF. + */ + // See if we can convert a comdat to a comdef, + // which saves on exe file space. + if (0 && // causes multiple def problems with COMMON in one file and COMDAT in library + sinit->Sclass == SCcomdat && + sinit->Sdt && + sinit->Sdt->dt == DT_azeros && + sinit->Sdt->DTnext == NULL && + !global.params.multiobj) + { + sinit->Sclass = SCglobal; + sinit->Sdt->dt = DT_common; + } +#endif + +#if ELFOBJ + sinit->Sseg = CDATA; +#endif +#if MACHOBJ + sinit->Sseg = DATA; +#endif + outdata(sinit); + } + + // Put out the members + for (size_t i = 0; i < members->dim; i++) + { + Dsymbol *member = (*members)[i]; + /* There might be static ctors in the members, and they cannot + * be put in separate obj files. + */ + member->toObjFile(multiobj); + } + } +} + +/* ================================================================== */ + +void VarDeclaration::toObjFile(int multiobj) +{ + Symbol *s; + unsigned sz; + Dsymbol *parent; + + //printf("VarDeclaration::toObjFile(%p '%s' type=%s) protection %d\n", this, toChars(), type->toChars(), protection); + //printf("\talign = %d\n", type->alignsize()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + + if (aliassym) + { toAlias()->toObjFile(0); + return; + } + +#if DMDV2 + // Do not store variables we cannot take the address of + if (!canTakeAddressOf()) + { + return; + } +#endif + + if (isDataseg() && !(storage_class & STCextern)) + { + s = toSymbol(); + sz = type->size(); + + parent = this->toParent(); +#if DMDV1 /* private statics should still get a global symbol, in case + * another module inlines a function that references it. + */ + if (/*protection == PROTprivate ||*/ + !parent || parent->ident == NULL || parent->isFuncDeclaration()) + { + s->Sclass = SCstatic; + } + else +#endif + { + if (storage_class & STCcomdat) + s->Sclass = SCcomdat; + else + s->Sclass = SCglobal; + + do + { + /* Global template data members need to be in comdat's + * in case multiple .obj files instantiate the same + * template with the same types. + */ + if (parent->isTemplateInstance() && !parent->isTemplateMixin()) + { +#if DMDV1 + /* These symbol constants have already been copied, + * so no reason to output them. + * Note that currently there is no way to take + * the address of such a const. + */ + if (isConst() && type->toBasetype()->ty != Tsarray && + init && init->isExpInitializer()) + return; +#endif + s->Sclass = SCcomdat; + break; + } + parent = parent->parent; + } while (parent); + } + s->Sfl = FLdata; + + if (init) + { s->Sdt = init->toDt(); + + // Look for static array that is block initialized + Type *tb; + ExpInitializer *ie = init->isExpInitializer(); + + tb = type->toBasetype(); + if (tb->ty == Tsarray && ie && + !tb->nextOf()->equals(ie->exp->type->toBasetype()->nextOf()) && + ie->exp->implicitConvTo(tb->nextOf()) + ) + { + size_t dim = ((TypeSArray *)tb)->dim->toInteger(); + + // Duplicate Sdt 'dim-1' times, as we already have the first one + dt_t **pdt = &s->Sdt; + while (--dim > 0) + { + pdt = ie->exp->toDt(pdt); + } + } + } + else if (storage_class & STCextern) + { + s->Sclass = SCextern; + s->Sfl = FLextern; + s->Sdt = NULL; + // BUG: if isExport(), shouldn't we make it dllimport? + return; + } + else + { + type->toDt(&s->Sdt); + } + dt_optimize(s->Sdt); + + // See if we can convert a comdat to a comdef, + // which saves on exe file space. + if (s->Sclass == SCcomdat && + s->Sdt && + s->Sdt->dt == DT_azeros && + s->Sdt->DTnext == NULL && + !isThreadlocal()) + { + s->Sclass = SCglobal; + s->Sdt->dt = DT_common; + } + +#if ELFOBJ || MACHOBJ // Burton + if (s->Sdt && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL) + s->Sseg = UDATA; + else + s->Sseg = DATA; +#endif + if (sz) + { outdata(s); + if (isExport()) + obj_export(s,0); + } + } +} + +/* ================================================================== */ + +void TypedefDeclaration::toObjFile(int multiobj) +{ + //printf("TypedefDeclaration::toObjFile('%s')\n", toChars()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + + if (global.params.symdebug) + toDebug(); + + type->getTypeInfo(NULL); // generate TypeInfo + + TypeTypedef *tc = (TypeTypedef *)type; + if (type->isZeroInit() || !tc->sym->init) + ; + else + { + enum_SC scclass = SCglobal; + if (inTemplateInstance()) + scclass = SCcomdat; + + // Generate static initializer + toInitializer(); + sinit->Sclass = scclass; + sinit->Sfl = FLdata; +#if ELFOBJ // Burton + sinit->Sseg = CDATA; +#endif +#if MACHOBJ + sinit->Sseg = DATA; +#endif + sinit->Sdt = tc->sym->init->toDt(); + outdata(sinit); + } +} + +/* ================================================================== */ + +void EnumDeclaration::toObjFile(int multiobj) +{ + //printf("EnumDeclaration::toObjFile('%s')\n", toChars()); + + if (type->ty == Terror) + { error("had semantic errors when compiling"); + return; + } + +#if DMDV2 + if (isAnonymous()) + return; +#endif + + if (global.params.symdebug) + toDebug(); + + type->getTypeInfo(NULL); // generate TypeInfo + + TypeEnum *tc = (TypeEnum *)type; + if (!tc->sym->defaultval || type->isZeroInit()) + ; + else + { + enum_SC scclass = SCglobal; + if (inTemplateInstance()) + scclass = SCcomdat; + + // Generate static initializer + toInitializer(); + sinit->Sclass = scclass; + sinit->Sfl = FLdata; +#if ELFOBJ // Burton + sinit->Sseg = CDATA; +#endif +#if MACHOBJ + sinit->Sseg = DATA; +#endif +#if DMDV1 + dtnbytes(&sinit->Sdt, tc->size(0), (char *)&tc->sym->defaultval); + //sinit->Sdt = tc->sym->init->toDt(); +#endif +#if DMDV2 + tc->sym->defaultval->toDt(&sinit->Sdt); +#endif + outdata(sinit); + } +} + + + diff --git a/total.h b/total.h new file mode 100644 index 00000000..42f38765 --- /dev/null +++ b/total.h @@ -0,0 +1,46 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_TOTAL_H +#define DMD_TOTAL_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include +#include +#include +#include +#include + +#include "root.h" +#include "stringtable.h" + +#include "arraytypes.h" +#include "mars.h" +#include "lexer.h" +#include "parse.h" +#include "identifier.h" +#include "enum.h" +#include "aggregate.h" +#include "mtype.h" +#include "expression.h" +#include "declaration.h" +#include "statement.h" +#include "scope.h" +#include "import.h" +#include "module.h" +#include "id.h" +#include "cond.h" +#include "version.h" +#include "lib.h" + +#endif /* DMD_TOTAL_H */ diff --git a/traits.c b/traits.c new file mode 100644 index 00000000..e49fd553 --- /dev/null +++ b/traits.c @@ -0,0 +1,549 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include +#include +#include +#include + +#include "rmem.h" + +//#include "port.h" +#include "mtype.h" +#include "init.h" +#include "expression.h" +#include "template.h" +#include "utf.h" +#include "enum.h" +#include "scope.h" +#include "statement.h" +#include "declaration.h" +#include "aggregate.h" +#include "import.h" +#include "id.h" +#include "dsymbol.h" +#include "module.h" +#include "attrib.h" +#include "hdrgen.h" +#include "parse.h" + +#define LOGSEMANTIC 0 + +#if DMDV2 + +/************************************************ + * Delegate to be passed to overloadApply() that looks + * for functions matching a trait. + */ + +struct Ptrait +{ + Expression *e1; + Expressions *exps; // collected results + Identifier *ident; // which trait we're looking for +}; + +static int fptraits(void *param, FuncDeclaration *f) +{ Ptrait *p = (Ptrait *)param; + + if (p->ident == Id::getVirtualFunctions && !f->isVirtual()) + return 0; + + if (p->ident == Id::getVirtualMethods && !f->isVirtualMethod()) + return 0; + + Expression *e; + + if (p->e1->op == TOKdotvar) + { DotVarExp *dve = (DotVarExp *)p->e1; + e = new DotVarExp(0, dve->e1, f); + } + else + e = new DsymbolExp(0, f); + p->exps->push(e); + return 0; +} + +/************************ TraitsExp ************************************/ + +Expression *TraitsExp::semantic(Scope *sc) +{ +#if LOGSEMANTIC + printf("TraitsExp::semantic() %s\n", toChars()); +#endif + if (ident != Id::compiles && ident != Id::isSame && + ident != Id::identifier) + { + TemplateInstance::semanticTiargs(loc, sc, args, 1); + } + size_t dim = args ? args->dim : 0; + Declaration *d; + +#define ISTYPE(cond) \ + for (size_t i = 0; i < dim; i++) \ + { Type *t = getType(args->tdata()[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(args->tdata()[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) + { + FuncDeclaration *f; + ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isAbstract()) + } + else if (ident == Id::isVirtualFunction) + { + FuncDeclaration *f; + ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isVirtual()) + } + else if (ident == Id::isVirtualMethod) + { + FuncDeclaration *f; + ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isVirtualMethod()) + } + else if (ident == Id::isFinalFunction) + { + FuncDeclaration *f; + ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isFinal()) + } +#if DMDV2 + else if (ident == Id::isStaticFunction) + { + FuncDeclaration *f; + ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && !f->needThis() && !f->isNested()) + } + else if (ident == Id::isRef) + { + ISDSYMBOL((d = s->isDeclaration()) != NULL && d->isRef()) + } + else if (ident == Id::isOut) + { + ISDSYMBOL((d = s->isDeclaration()) != NULL && d->isOut()) + } + else if (ident == Id::isLazy) + { + ISDSYMBOL((d = s->isDeclaration()) != NULL && d->storage_class & STClazy) + } + else if (ident == Id::identifier) + { // Get identifier for symbol as a string literal + + // Specify 0 for the flags argument to semanticTiargs() so that + // a symbol should not be folded to a constant. + TemplateInstance::semanticTiargs(loc, sc, args, 0); + + if (dim != 1) + goto Ldimerror; + Object *o = args->tdata()[0]; + Dsymbol *s = getDsymbol(o); + if (!s || !s->ident) + { + error("argument %s has no identifier", o->toChars()); + goto Lfalse; + } + StringExp *se = new StringExp(loc, s->ident->toChars()); + return se->semantic(sc); + } + else if (ident == Id::parent) + { + if (dim != 1) + goto Ldimerror; + Object *o = args->tdata()[0]; + Dsymbol *s = getDsymbol(o); + if (s) + s = s->toParent(); + if (!s) + { + error("argument %s has no parent", o->toChars()); + goto Lfalse; + } + return (new DsymbolExp(loc, s))->semantic(sc); + } + +#endif + else if (ident == Id::hasMember || + ident == Id::getMember || + ident == Id::getOverloads || + ident == Id::getVirtualMethods || + ident == Id::getVirtualFunctions) + { + if (dim != 2) + goto Ldimerror; + Object *o = args->tdata()[0]; + Expression *e = isExpression(args->tdata()[1]); + if (!e) + { error("expression expected as second argument of __traits %s", ident->toChars()); + goto Lfalse; + } + e = e->optimize(WANTvalue | WANTinterpret); + StringExp *se = e->toString(); + if (!se || se->length() == 0) + { error("string expected as second argument of __traits %s instead of %s", ident->toChars(), e->toChars()); + goto Lfalse; + } + 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 = 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) + { + if (t) + { + Dsymbol *sym = t->toDsymbol(sc); + if (sym) + { + Dsymbol *sm = sym->search(loc, id, 0); + if (sm) + goto Ltrue; + } + } + + /* Take any errors as meaning it wasn't found + */ + Scope *sc2 = sc->push(); + //sc2->inHasMember++; + e = e->trySemantic(sc2); + sc2->pop(); + if (!e) + goto Lfalse; + else + goto Ltrue; + } + else if (ident == Id::getMember) + { + e = e->semantic(sc); + return e; + } + else if (ident == Id::getVirtualFunctions || + ident == Id::getVirtualMethods || + ident == Id::getOverloads) + { + 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 functions 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; + Ptrait p; + p.exps = exps; + p.e1 = e; + p.ident = ident; + overloadApply(f, fptraits, &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 = args->tdata()[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 = args->tdata()[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; + } + + // 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) + { + //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->tdata()[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); + } + return 0; + } + }; + + Identifiers *idents = new Identifiers; + ScopeDsymbol::foreach(sd->members, &PushIdentsDg::dg, idents); + + ClassDeclaration *cd = sd->isClassDeclaration(); + if (cd && 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(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->tdata()[i]; + StringExp *se = new StringExp(loc, id->toChars()); + exps->tdata()[i] = se; + } + +#if DMDV1 + Expression *e = new ArrayLiteralExp(loc, exps); +#endif +#if DMDV2 + /* Making this a tuple is more flexible, as it can be statically unrolled. + * To make an array literal, enclose __traits in [ ]: + * [ __traits(allMembers, ...) ] + */ + Expression *e = new TupleExp(loc, exps); +#endif + 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 = args->tdata()[i]; + Expression *e; + + unsigned errors = global.startGagging(); + + Type *t = isType(o); + if (t) + { Dsymbol *s; + t->resolve(loc, sc, &e, &t, &s); + if (t) + t->semantic(loc, sc); + else if (e) + { e = e->semantic(sc); + e = e->optimize(WANTvalue); + } + } + else + { e = isExpression(o); + if (e) + { e = e->semantic(sc); + e = e->optimize(WANTvalue); + } + } + + if (global.endGagging(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 = args->tdata()[0]; + Object *o2 = args->tdata()[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 == s2) + goto Ltrue; + else + goto Lfalse; + } + else + { error("unrecognized trait %s", ident->toChars()); + goto Lfalse; + } + + return NULL; + +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); +} + + +#endif diff --git a/typinf.c b/typinf.c new file mode 100644 index 00000000..ceb768a1 --- /dev/null +++ b/typinf.c @@ -0,0 +1,949 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2011 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +//#include "mem.h" + +#include "mars.h" +#include "module.h" +#include "mtype.h" +#include "scope.h" +#include "init.h" +#include "expression.h" +#include "attrib.h" +#include "declaration.h" +#include "template.h" +#include "id.h" +#include "enum.h" +#include "import.h" +#include "aggregate.h" + +#ifndef TARGET_NET +#include "rmem.h" +#include "cc.h" +#include "global.h" +#include "oper.h" +#include "code.h" +#include "type.h" +#include "dt.h" +#include "cgcv.h" +#include "outbuf.h" +#include "irstate.h" +#endif + +extern Symbol *static_sym(); + +/******************************************* + * Get a canonicalized form of the TypeInfo for use with the internal + * runtime library routines. Canonicalized in that static arrays are + * represented as dynamic arrays, enums are represented by their + * underlying type, etc. This reduces the number of TypeInfo's needed, + * so we can use the custom internal ones more. + */ + +Expression *Type::getInternalTypeInfo(Scope *sc) +{ TypeInfoDeclaration *tid; + Expression *e; + Type *t; + static TypeInfoDeclaration *internalTI[TMAX]; + + //printf("Type::getInternalTypeInfo() %s\n", toChars()); + t = toBasetype(); + switch (t->ty) + { + case Tsarray: +#if 0 + // convert to corresponding dynamic array type + t = t->nextOf()->mutableOf()->arrayOf(); +#endif + break; + + case Tclass: + if (((TypeClass *)t)->sym->isInterfaceDeclaration()) + break; + goto Linternal; + + case Tarray: + // convert to corresponding dynamic array type + t = t->nextOf()->mutableOf()->arrayOf(); + if (t->nextOf()->ty != Tclass) + break; + goto Linternal; + + case Tfunction: + case Tdelegate: + case Tpointer: + Linternal: + tid = internalTI[t->ty]; + if (!tid) + { tid = new TypeInfoDeclaration(t, 1); + internalTI[t->ty] = tid; + } + e = new VarExp(0, tid); + e = e->addressOf(sc); + e->type = tid->type; // do this so we don't get redundant dereference + return e; + + default: + break; + } + //printf("\tcalling getTypeInfo() %s\n", t->toChars()); + return t->getTypeInfo(sc); +} + + +/**************************************************** + * Get the exact TypeInfo. + */ + +Expression *Type::getTypeInfo(Scope *sc) +{ + //printf("Type::getTypeInfo() %p, %s\n", this, toChars()); + if (!Type::typeinfo) + { + error(0, "TypeInfo not found. object.d may be incorrectly installed or corrupt, compile with -v switch"); + fatal(); + } + + Type *t = merge2(); // do this since not all Type's are merge'd + if (!t->vtinfo) + { +#if DMDV2 + if (t->isShared()) // does both 'shared' and 'shared const' + t->vtinfo = new TypeInfoSharedDeclaration(t); + else if (t->isConst()) + t->vtinfo = new TypeInfoConstDeclaration(t); + else if (t->isImmutable()) + t->vtinfo = new TypeInfoInvariantDeclaration(t); + else if (t->isWild()) + t->vtinfo = new TypeInfoWildDeclaration(t); + else +#endif + t->vtinfo = t->getTypeInfoDeclaration(); + assert(t->vtinfo); + vtinfo = t->vtinfo; + + /* If this has a custom implementation in std/typeinfo, then + * do not generate a COMDAT for it. + */ + if (!t->builtinTypeInfo()) + { // Generate COMDAT + if (sc) // if in semantic() pass + { // Find module that will go all the way to an object file + Module *m = sc->module->importedFrom; + m->members->push(t->vtinfo); + } + else // if in obj generation pass + { + t->vtinfo->toObjFile(global.params.multiobj); + } + } + } + if (!vtinfo) + vtinfo = t->vtinfo; // Types aren't merged, but we can share the vtinfo's + Expression *e = new VarExp(0, t->vtinfo); + e = e->addressOf(sc); + e->type = t->vtinfo->type; // do this so we don't get redundant dereference + return e; +} + +TypeInfoDeclaration *Type::getTypeInfoDeclaration() +{ + //printf("Type::getTypeInfoDeclaration() %s\n", toChars()); + return new TypeInfoDeclaration(this, 0); +} + +TypeInfoDeclaration *TypeTypedef::getTypeInfoDeclaration() +{ + return new TypeInfoTypedefDeclaration(this); +} + +TypeInfoDeclaration *TypePointer::getTypeInfoDeclaration() +{ + return new TypeInfoPointerDeclaration(this); +} + +TypeInfoDeclaration *TypeDArray::getTypeInfoDeclaration() +{ + return new TypeInfoArrayDeclaration(this); +} + +TypeInfoDeclaration *TypeSArray::getTypeInfoDeclaration() +{ + return new TypeInfoStaticArrayDeclaration(this); +} + +TypeInfoDeclaration *TypeAArray::getTypeInfoDeclaration() +{ + return new TypeInfoAssociativeArrayDeclaration(this); +} + +TypeInfoDeclaration *TypeStruct::getTypeInfoDeclaration() +{ + return new TypeInfoStructDeclaration(this); +} + +TypeInfoDeclaration *TypeClass::getTypeInfoDeclaration() +{ + if (sym->isInterfaceDeclaration()) + return new TypeInfoInterfaceDeclaration(this); + else + return new TypeInfoClassDeclaration(this); +} + +TypeInfoDeclaration *TypeVector::getTypeInfoDeclaration() +{ + return new TypeInfoVectorDeclaration(this); +} + +TypeInfoDeclaration *TypeEnum::getTypeInfoDeclaration() +{ + return new TypeInfoEnumDeclaration(this); +} + +TypeInfoDeclaration *TypeFunction::getTypeInfoDeclaration() +{ + return new TypeInfoFunctionDeclaration(this); +} + +TypeInfoDeclaration *TypeDelegate::getTypeInfoDeclaration() +{ + return new TypeInfoDelegateDeclaration(this); +} + +TypeInfoDeclaration *TypeTuple::getTypeInfoDeclaration() +{ + return new TypeInfoTupleDeclaration(this); +} + +#ifndef TARGET_NET +/**************************************************** + */ + +#if 1 + +void TypeInfoDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoDeclaration::toDt() %s\n", toChars()); + dtxoff(pdt, Type::typeinfo->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo + dtsize_t(pdt, 0); // monitor +} + +#if DMDV2 +void TypeInfoConstDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoConstDeclaration::toDt() %s\n", toChars()); + dtxoff(pdt, Type::typeinfoconst->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Const + dtsize_t(pdt, 0); // monitor + Type *tm = tinfo->mutableOf(); + tm = tm->merge(); + tm->getTypeInfo(NULL); + dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr); +} + +void TypeInfoInvariantDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoInvariantDeclaration::toDt() %s\n", toChars()); + dtxoff(pdt, Type::typeinfoinvariant->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Invariant + dtsize_t(pdt, 0); // monitor + Type *tm = tinfo->mutableOf(); + tm = tm->merge(); + tm->getTypeInfo(NULL); + dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr); +} + +void TypeInfoSharedDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoSharedDeclaration::toDt() %s\n", toChars()); + dtxoff(pdt, Type::typeinfoshared->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Shared + dtsize_t(pdt, 0); // monitor + Type *tm = tinfo->unSharedOf(); + tm = tm->merge(); + tm->getTypeInfo(NULL); + dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr); +} + +void TypeInfoWildDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoWildDeclaration::toDt() %s\n", toChars()); + dtxoff(pdt, Type::typeinfowild->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Wild + dtsize_t(pdt, 0); // monitor + Type *tm = tinfo->mutableOf(); + tm = tm->merge(); + tm->getTypeInfo(NULL); + dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr); +} + +#endif + +void TypeInfoTypedefDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoTypedefDeclaration::toDt() %s\n", toChars()); + + dtxoff(pdt, Type::typeinfotypedef->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Typedef + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Ttypedef); + + TypeTypedef *tc = (TypeTypedef *)tinfo; + TypedefDeclaration *sd = tc->sym; + //printf("basetype = %s\n", sd->basetype->toChars()); + + /* Put out: + * TypeInfo base; + * char[] name; + * void[] m_init; + */ + + sd->basetype = sd->basetype->merge(); + sd->basetype->getTypeInfo(NULL); // generate vtinfo + assert(sd->basetype->vtinfo); + dtxoff(pdt, sd->basetype->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for basetype + + const char *name = sd->toPrettyChars(); + size_t namelen = strlen(name); + dtsize_t(pdt, namelen); + dtabytes(pdt, TYnptr, 0, namelen + 1, name); + + // void[] init; + if (tinfo->isZeroInit() || !sd->init) + { // 0 initializer, or the same as the base type + dtsize_t(pdt, 0); // init.length + dtsize_t(pdt, 0); // init.ptr + } + else + { + dtsize_t(pdt, sd->type->size()); // init.length + dtxoff(pdt, sd->toInitializer(), 0, TYnptr); // init.ptr + } +} + +void TypeInfoEnumDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoEnumDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfoenum->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Enum + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tenum); + + TypeEnum *tc = (TypeEnum *)tinfo; + EnumDeclaration *sd = tc->sym; + + /* Put out: + * TypeInfo base; + * char[] name; + * void[] m_init; + */ + + if (sd->memtype) + { sd->memtype->getTypeInfo(NULL); + dtxoff(pdt, sd->memtype->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for enum members + } + else + dtsize_t(pdt, 0); + + const char *name = sd->toPrettyChars(); + size_t namelen = strlen(name); + dtsize_t(pdt, namelen); + dtabytes(pdt, TYnptr, 0, namelen + 1, name); + + // void[] init; + if (!sd->defaultval || tinfo->isZeroInit()) + { // 0 initializer, or the same as the base type + dtsize_t(pdt, 0); // init.length + dtsize_t(pdt, 0); // init.ptr + } + else + { + dtsize_t(pdt, sd->type->size()); // init.length + dtxoff(pdt, sd->toInitializer(), 0, TYnptr); // init.ptr + } +} + +void TypeInfoPointerDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoPointerDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfopointer->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Pointer + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tpointer); + + TypePointer *tc = (TypePointer *)tinfo; + + tc->next->getTypeInfo(NULL); + dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for type being pointed to +} + +void TypeInfoArrayDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoArrayDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfoarray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Array + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tarray); + + TypeDArray *tc = (TypeDArray *)tinfo; + + tc->next->getTypeInfo(NULL); + dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type +} + +void TypeInfoStaticArrayDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoStaticArrayDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfostaticarray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_StaticArray + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tsarray); + + TypeSArray *tc = (TypeSArray *)tinfo; + + tc->next->getTypeInfo(NULL); + dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type + + dtsize_t(pdt, tc->dim->toInteger()); // length +} + +void TypeInfoVectorDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoVectorDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfovector->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Vector + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tvector); + + TypeVector *tc = (TypeVector *)tinfo; + + tc->basetype->getTypeInfo(NULL); + dtxoff(pdt, tc->basetype->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for equivalent static array +} + +void TypeInfoAssociativeArrayDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoAssociativeArrayDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfoassociativearray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_AssociativeArray + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Taarray); + + TypeAArray *tc = (TypeAArray *)tinfo; + + tc->next->getTypeInfo(NULL); + dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type + + tc->index->getTypeInfo(NULL); + dtxoff(pdt, tc->index->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type + +#if DMDV2 + tc->getImpl()->type->getTypeInfo(NULL); + dtxoff(pdt, tc->getImpl()->type->vtinfo->toSymbol(), 0, TYnptr); // impl +#endif +} + +void TypeInfoFunctionDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoFunctionDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfofunction->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Function + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tfunction); + + TypeFunction *tc = (TypeFunction *)tinfo; + + tc->next->getTypeInfo(NULL); + dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for function return value + + const char *name = tinfo->deco; + assert(name); + size_t namelen = strlen(name); + dtsize_t(pdt, namelen); + dtabytes(pdt, TYnptr, 0, namelen + 1, name); +} + +void TypeInfoDelegateDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoDelegateDeclaration::toDt()\n"); + dtxoff(pdt, Type::typeinfodelegate->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Delegate + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tdelegate); + + TypeDelegate *tc = (TypeDelegate *)tinfo; + + tc->next->nextOf()->getTypeInfo(NULL); + dtxoff(pdt, tc->next->nextOf()->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for delegate return value + + const char *name = tinfo->deco; + assert(name); + size_t namelen = strlen(name); + dtsize_t(pdt, namelen); + dtabytes(pdt, TYnptr, 0, namelen + 1, name); +} + +void TypeInfoStructDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoStructDeclaration::toDt() '%s'\n", toChars()); + + unsigned offset = Type::typeinfostruct->structsize; + + dtxoff(pdt, Type::typeinfostruct->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Struct + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tstruct); + + TypeStruct *tc = (TypeStruct *)tinfo; + StructDeclaration *sd = tc->sym; + + /* Put out: + * char[] name; + * void[] init; + * hash_t function(in void*) xtoHash; + * bool function(in void*, in void*) xopEquals; + * int function(in void*, in void*) xopCmp; + * string function(const(void)*) xtoString; + * uint m_flags; + * xgetMembers; + * xdtor; + * xpostblit; + * uint m_align; + * version (X86_64) + * TypeInfo m_arg1; + * TypeInfo m_arg2; + * + * name[] + */ + + const char *name = sd->toPrettyChars(); + size_t namelen = strlen(name); + dtsize_t(pdt, namelen); + //dtabytes(pdt, TYnptr, 0, namelen + 1, name); + dtxoff(pdt, toSymbol(), offset, TYnptr); + offset += namelen + 1; + + // void[] init; + dtsize_t(pdt, sd->structsize); // init.length + if (sd->zeroInit) + dtsize_t(pdt, 0); // NULL for 0 initialization + else + dtxoff(pdt, sd->toInitializer(), 0, TYnptr); // init.ptr + + FuncDeclaration *fd; + FuncDeclaration *fdx; + Dsymbol *s; + + static TypeFunction *tftohash; + static TypeFunction *tftostring; + + if (!tftohash) + { + Scope sc; + + tftohash = new TypeFunction(NULL, Type::thash_t, 0, LINKd); + tftohash->mod = MODconst; + tftohash = (TypeFunction *)tftohash->semantic(0, &sc); + + tftostring = new TypeFunction(NULL, Type::tchar->invariantOf()->arrayOf(), 0, LINKd); + tftostring = (TypeFunction *)tftostring->semantic(0, &sc); + } + + TypeFunction *tfcmpptr; + { + Scope sc; + Parameters *arguments = new Parameters; +#if STRUCTTHISREF + // arg type is ref const T + Parameter *arg = new Parameter(STCref, tc->constOf(), NULL, NULL); +#else + // arg type is const T* + Parameter *arg = new Parameter(STCin, tc->pointerTo(), NULL, NULL); +#endif + + arguments->push(arg); + tfcmpptr = new TypeFunction(arguments, Type::tint32, 0, LINKd); + tfcmpptr->mod = MODconst; + tfcmpptr = (TypeFunction *)tfcmpptr->semantic(0, &sc); + } + + s = search_function(sd, Id::tohash); + fdx = s ? s->isFuncDeclaration() : NULL; + if (fdx) + { fd = fdx->overloadExactMatch(tftohash); + if (fd) + dtxoff(pdt, fd->toSymbol(), 0, TYnptr); + else + //fdx->error("must be declared as extern (D) uint toHash()"); + dtsize_t(pdt, 0); + } + else + dtsize_t(pdt, 0); + + if (sd->xeq) + dtxoff(pdt, sd->xeq->toSymbol(), 0, TYnptr); + else + dtsize_t(pdt, 0); + + s = search_function(sd, Id::cmp); + fdx = s ? s->isFuncDeclaration() : NULL; + if (fdx) + { + //printf("test1 %s, %s, %s\n", fdx->toChars(), fdx->type->toChars(), tfeqptr->toChars()); + fd = fdx->overloadExactMatch(tfcmpptr); + if (fd) + { dtxoff(pdt, fd->toSymbol(), 0, TYnptr); + //printf("test2\n"); + } + else + //fdx->error("must be declared as extern (D) int %s(%s*)", fdx->toChars(), sd->toChars()); + dtsize_t(pdt, 0); + } + else + dtsize_t(pdt, 0); + + s = search_function(sd, Id::tostring); + fdx = s ? s->isFuncDeclaration() : NULL; + if (fdx) + { fd = fdx->overloadExactMatch(tftostring); + if (fd) + dtxoff(pdt, fd->toSymbol(), 0, TYnptr); + else + //fdx->error("must be declared as extern (D) char[] toString()"); + dtsize_t(pdt, 0); + } + else + dtsize_t(pdt, 0); + + // uint m_flags; + dtsize_t(pdt, tc->hasPointers()); + +#if DMDV2 + // xgetMembers + FuncDeclaration *sgetmembers = sd->findGetMembers(); + if (sgetmembers) + dtxoff(pdt, sgetmembers->toSymbol(), 0, TYnptr); + else + dtsize_t(pdt, 0); // xgetMembers + + // xdtor + FuncDeclaration *sdtor = sd->dtor; + if (sdtor) + dtxoff(pdt, sdtor->toSymbol(), 0, TYnptr); + else + dtsize_t(pdt, 0); // xdtor + + // xpostblit + FuncDeclaration *spostblit = sd->postblit; + if (spostblit && !(spostblit->storage_class & STCdisable)) + dtxoff(pdt, spostblit->toSymbol(), 0, TYnptr); + else + dtsize_t(pdt, 0); // xpostblit +#endif + + // uint m_align; + dtsize_t(pdt, tc->alignsize()); + + if (global.params.is64bit) + { + TypeTuple *tup = tc->toArgTypes(); + assert(tup->arguments->dim <= 2); + for (size_t i = 0; i < 2; i++) + { + if (i < tup->arguments->dim) + { + Type *targ = (tup->arguments->tdata()[i])->type; + targ = targ->merge(); + targ->getTypeInfo(NULL); + dtxoff(pdt, targ->vtinfo->toSymbol(), 0, TYnptr); // m_argi + } + else + dtsize_t(pdt, 0); // m_argi + } + } + + // name[] + dtnbytes(pdt, namelen + 1, name); +} + +void TypeInfoClassDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoClassDeclaration::toDt() %s\n", tinfo->toChars()); +#if DMDV1 + dtxoff(pdt, Type::typeinfoclass->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoClass + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tclass); + + TypeClass *tc = (TypeClass *)tinfo; + Symbol *s; + + if (!tc->sym->vclassinfo) + tc->sym->vclassinfo = new ClassInfoDeclaration(tc->sym); + s = tc->sym->vclassinfo->toSymbol(); + dtxoff(pdt, s, 0, TYnptr); // ClassInfo for tinfo +#else + assert(0); +#endif +} + +void TypeInfoInterfaceDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoInterfaceDeclaration::toDt() %s\n", tinfo->toChars()); + dtxoff(pdt, Type::typeinfointerface->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Tclass); + + TypeClass *tc = (TypeClass *)tinfo; + Symbol *s; + + if (!tc->sym->vclassinfo) +#if DMDV1 + tc->sym->vclassinfo = new ClassInfoDeclaration(tc->sym); +#else + tc->sym->vclassinfo = new TypeInfoClassDeclaration(tc); +#endif + s = tc->sym->vclassinfo->toSymbol(); + dtxoff(pdt, s, 0, TYnptr); // ClassInfo for tinfo +} + +void TypeInfoTupleDeclaration::toDt(dt_t **pdt) +{ + //printf("TypeInfoTupleDeclaration::toDt() %s\n", tinfo->toChars()); + dtxoff(pdt, Type::typeinfotypelist->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface + dtsize_t(pdt, 0); // monitor + + assert(tinfo->ty == Ttuple); + + TypeTuple *tu = (TypeTuple *)tinfo; + + size_t dim = tu->arguments->dim; + dtsize_t(pdt, dim); // elements.length + + dt_t *d = NULL; + for (size_t i = 0; i < dim; i++) + { Parameter *arg = tu->arguments->tdata()[i]; + Expression *e = arg->type->getTypeInfo(NULL); + e = e->optimize(WANTvalue); + e->toDt(&d); + } + + Symbol *s; + s = static_sym(); + s->Sdt = d; + outdata(s); + + dtxoff(pdt, s, 0, TYnptr); // elements.ptr +} + +void TypeInfoDeclaration::toObjFile(int multiobj) +{ + Symbol *s; + unsigned sz; + Dsymbol *parent; + + //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d\n", this, toChars(), protection); + + if (multiobj) + { + obj_append(this); + return; + } + + s = toSymbol(); + sz = type->size(); + + parent = this->toParent(); + s->Sclass = SCcomdat; + s->Sfl = FLdata; + + toDt(&s->Sdt); + + dt_optimize(s->Sdt); + + // See if we can convert a comdat to a comdef, + // which saves on exe file space. + if (s->Sclass == SCcomdat && + s->Sdt->dt == DT_azeros && + s->Sdt->DTnext == NULL) + { + s->Sclass = SCglobal; + s->Sdt->dt = DT_common; + } + +#if ELFOBJ || MACHOBJ // Burton + if (s->Sdt && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL) + s->Sseg = UDATA; + else + s->Sseg = DATA; +#endif + outdata(s); + if (isExport()) + obj_export(s,0); +} + +#endif +#endif // TARGET_NET + +/* ========================================================================= */ + +/* These decide if there's an instance for them already in std.typeinfo, + * because then the compiler doesn't need to build one. + */ + +int Type::builtinTypeInfo() +{ + return 0; +} + +int TypeBasic::builtinTypeInfo() +{ +#if DMDV2 + return mod ? 0 : 1; +#else + return 1; +#endif +} + +int TypeDArray::builtinTypeInfo() +{ +#if DMDV2 + return !mod && (next->isTypeBasic() != NULL && !next->mod || + // strings are so common, make them builtin + next->ty == Tchar && next->mod == MODimmutable); +#else + return next->isTypeBasic() != NULL; +#endif +} + +int TypeClass::builtinTypeInfo() +{ + /* This is statically put out with the ClassInfo, so + * claim it is built in so it isn't regenerated by each module. + */ +#if DMDV2 + return mod ? 0 : 1; +#else + return 1; +#endif +} + +/* ========================================================================= */ + +/*************************************** + * Create a static array of TypeInfo references + * corresponding to an array of Expression's. + * Used to supply hidden _arguments[] value for variadic D functions. + */ + +Expression *createTypeInfoArray(Scope *sc, Expression *exps[], unsigned dim) +{ +#if 1 + /* Get the corresponding TypeInfo_Tuple and + * point at its elements[]. + */ + + /* Create the TypeTuple corresponding to the types of args[] + */ + Parameters *args = new Parameters; + args->setDim(dim); + for (size_t i = 0; i < dim; i++) + { Parameter *arg = new Parameter(STCin, exps[i]->type, NULL, NULL); + args->tdata()[i] = arg; + } + TypeTuple *tup = new TypeTuple(args); + Expression *e = tup->getTypeInfo(sc); + e = e->optimize(WANTvalue); + assert(e->op == TOKsymoff); // should be SymOffExp + +#if BREAKABI + /* + * Should just pass a reference to TypeInfo_Tuple instead, + * but that would require existing code to be recompiled. + * Source compatibility can be maintained by computing _arguments[] + * at the start of the called function by offseting into the + * TypeInfo_Tuple reference. + */ + +#else + // Advance to elements[] member of TypeInfo_Tuple + SymOffExp *se = (SymOffExp *)e; + se->offset += PTRSIZE + PTRSIZE; + + // Set type to TypeInfo[]* + se->type = Type::typeinfo->type->arrayOf()->pointerTo(); + + // Indirect to get the _arguments[] value + e = new PtrExp(0, se); + e->type = se->type->next; +#endif + return e; +#else + /* Improvements: + * 1) create an array literal instead, + * as it would eliminate the extra dereference of loading the + * static variable. + */ + + ArrayInitializer *ai = new ArrayInitializer(0); + VarDeclaration *v; + Type *t; + Expression *e; + OutBuffer buf; + Identifier *id; + char *name; + + // Generate identifier for _arguments[] + buf.writestring("_arguments_"); + for (int i = 0; i < dim; i++) + { t = exps[i]->type; + t->toDecoBuffer(&buf); + } + buf.writeByte(0); + id = Lexer::idPool((char *)buf.data); + + Module *m = sc->module; + Dsymbol *s = m->symtab->lookup(id); + + if (s && s->parent == m) + { // Use existing one + v = s->isVarDeclaration(); + assert(v); + } + else + { // Generate new one + + for (int i = 0; i < dim; i++) + { t = exps[i]->type; + e = t->getTypeInfo(sc); + ai->addInit(new IntegerExp(i), new ExpInitializer(0, e)); + } + + t = Type::typeinfo->type->arrayOf(); + ai->type = t; + v = new VarDeclaration(0, t, id, ai); + m->members->push(v); + m->symtabInsert(v); + sc = sc->push(); + sc->linkage = LINKc; + sc->stc = STCstatic | STCcomdat; + ai->semantic(sc, t); + v->semantic(sc); + v->parent = m; + sc = sc->pop(); + } + e = new VarExp(0, v); + e = e->semantic(sc); + return e; +#endif +} + + + diff --git a/unialpha.c b/unialpha.c new file mode 100644 index 00000000..5c407180 --- /dev/null +++ b/unialpha.c @@ -0,0 +1,323 @@ + +// Copyright (c) 2003 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include + +/******************************* + * Return !=0 if unicode alpha. + * Use table from C99 Appendix D. + */ + +int isUniAlpha(unsigned u) +{ + static unsigned short table[][2] = + { + { 0x00AA, 0x00AA }, + { 0x00B5, 0x00B5 }, + { 0x00B7, 0x00B7 }, + { 0x00BA, 0x00BA }, + { 0x00C0, 0x00D6 }, + { 0x00D8, 0x00F6 }, + { 0x00F8, 0x01F5 }, + { 0x01FA, 0x0217 }, + { 0x0250, 0x02A8 }, + { 0x02B0, 0x02B8 }, + { 0x02BB, 0x02BB }, + { 0x02BD, 0x02C1 }, + { 0x02D0, 0x02D1 }, + { 0x02E0, 0x02E4 }, + { 0x037A, 0x037A }, + { 0x0386, 0x0386 }, + { 0x0388, 0x038A }, + { 0x038C, 0x038C }, + { 0x038E, 0x03A1 }, + { 0x03A3, 0x03CE }, + { 0x03D0, 0x03D6 }, + { 0x03DA, 0x03DA }, + { 0x03DC, 0x03DC }, + { 0x03DE, 0x03DE }, + { 0x03E0, 0x03E0 }, + { 0x03E2, 0x03F3 }, + { 0x0401, 0x040C }, + { 0x040E, 0x044F }, + { 0x0451, 0x045C }, + { 0x045E, 0x0481 }, + { 0x0490, 0x04C4 }, + { 0x04C7, 0x04C8 }, + { 0x04CB, 0x04CC }, + { 0x04D0, 0x04EB }, + { 0x04EE, 0x04F5 }, + { 0x04F8, 0x04F9 }, + { 0x0531, 0x0556 }, + { 0x0559, 0x0559 }, + { 0x0561, 0x0587 }, + { 0x05B0, 0x05B9 }, + { 0x05BB, 0x05BD }, + { 0x05BF, 0x05BF }, + { 0x05C1, 0x05C2 }, + { 0x05D0, 0x05EA }, + { 0x05F0, 0x05F2 }, + { 0x0621, 0x063A }, + { 0x0640, 0x0652 }, + { 0x0660, 0x0669 }, + { 0x0670, 0x06B7 }, + { 0x06BA, 0x06BE }, + { 0x06C0, 0x06CE }, + { 0x06D0, 0x06DC }, + { 0x06E5, 0x06E8 }, + { 0x06EA, 0x06ED }, + { 0x06F0, 0x06F9 }, + { 0x0901, 0x0903 }, + { 0x0905, 0x0939 }, + { 0x093D, 0x093D }, + { 0x093E, 0x094D }, + { 0x0950, 0x0952 }, + { 0x0958, 0x0963 }, + { 0x0966, 0x096F }, + { 0x0981, 0x0983 }, + { 0x0985, 0x098C }, + { 0x098F, 0x0990 }, + { 0x0993, 0x09A8 }, + { 0x09AA, 0x09B0 }, + { 0x09B2, 0x09B2 }, + { 0x09B6, 0x09B9 }, + { 0x09BE, 0x09C4 }, + { 0x09C7, 0x09C8 }, + { 0x09CB, 0x09CD }, + { 0x09DC, 0x09DD }, + { 0x09DF, 0x09E3 }, + { 0x09E6, 0x09EF }, + { 0x09F0, 0x09F1 }, + { 0x0A02, 0x0A02 }, + { 0x0A05, 0x0A0A }, + { 0x0A0F, 0x0A10 }, + { 0x0A13, 0x0A28 }, + { 0x0A2A, 0x0A30 }, + { 0x0A32, 0x0A33 }, + { 0x0A35, 0x0A36 }, + { 0x0A38, 0x0A39 }, + { 0x0A3E, 0x0A42 }, + { 0x0A47, 0x0A48 }, + { 0x0A4B, 0x0A4D }, + { 0x0A59, 0x0A5C }, + { 0x0A5E, 0x0A5E }, + { 0x0A66, 0x0A6F }, + { 0x0A74, 0x0A74 }, + { 0x0A81, 0x0A83 }, + { 0x0A85, 0x0A8B }, + { 0x0A8D, 0x0A8D }, + { 0x0A8F, 0x0A91 }, + { 0x0A93, 0x0AA8 }, + { 0x0AAA, 0x0AB0 }, + { 0x0AB2, 0x0AB3 }, + { 0x0AB5, 0x0AB9 }, + { 0x0ABD, 0x0AC5 }, + { 0x0AC7, 0x0AC9 }, + { 0x0ACB, 0x0ACD }, + { 0x0AD0, 0x0AD0 }, + { 0x0AE0, 0x0AE0 }, + { 0x0AE6, 0x0AEF }, + { 0x0B01, 0x0B03 }, + { 0x0B05, 0x0B0C }, + { 0x0B0F, 0x0B10 }, + { 0x0B13, 0x0B28 }, + { 0x0B2A, 0x0B30 }, + { 0x0B32, 0x0B33 }, + { 0x0B36, 0x0B39 }, + { 0x0B3D, 0x0B3D }, + { 0x0B3E, 0x0B43 }, + { 0x0B47, 0x0B48 }, + { 0x0B4B, 0x0B4D }, + { 0x0B5C, 0x0B5D }, + { 0x0B5F, 0x0B61 }, + { 0x0B66, 0x0B6F }, + { 0x0B82, 0x0B83 }, + { 0x0B85, 0x0B8A }, + { 0x0B8E, 0x0B90 }, + { 0x0B92, 0x0B95 }, + { 0x0B99, 0x0B9A }, + { 0x0B9C, 0x0B9C }, + { 0x0B9E, 0x0B9F }, + { 0x0BA3, 0x0BA4 }, + { 0x0BA8, 0x0BAA }, + { 0x0BAE, 0x0BB5 }, + { 0x0BB7, 0x0BB9 }, + { 0x0BBE, 0x0BC2 }, + { 0x0BC6, 0x0BC8 }, + { 0x0BCA, 0x0BCD }, + { 0x0BE7, 0x0BEF }, + { 0x0C01, 0x0C03 }, + { 0x0C05, 0x0C0C }, + { 0x0C0E, 0x0C10 }, + { 0x0C12, 0x0C28 }, + { 0x0C2A, 0x0C33 }, + { 0x0C35, 0x0C39 }, + { 0x0C3E, 0x0C44 }, + { 0x0C46, 0x0C48 }, + { 0x0C4A, 0x0C4D }, + { 0x0C60, 0x0C61 }, + { 0x0C66, 0x0C6F }, + { 0x0C82, 0x0C83 }, + { 0x0C85, 0x0C8C }, + { 0x0C8E, 0x0C90 }, + { 0x0C92, 0x0CA8 }, + { 0x0CAA, 0x0CB3 }, + { 0x0CB5, 0x0CB9 }, + { 0x0CBE, 0x0CC4 }, + { 0x0CC6, 0x0CC8 }, + { 0x0CCA, 0x0CCD }, + { 0x0CDE, 0x0CDE }, + { 0x0CE0, 0x0CE1 }, + { 0x0CE6, 0x0CEF }, + { 0x0D02, 0x0D03 }, + { 0x0D05, 0x0D0C }, + { 0x0D0E, 0x0D10 }, + { 0x0D12, 0x0D28 }, + { 0x0D2A, 0x0D39 }, + { 0x0D3E, 0x0D43 }, + { 0x0D46, 0x0D48 }, + { 0x0D4A, 0x0D4D }, + { 0x0D60, 0x0D61 }, + { 0x0D66, 0x0D6F }, + { 0x0E01, 0x0E3A }, + { 0x0E40, 0x0E5B }, +// { 0x0E50, 0x0E59 }, + { 0x0E81, 0x0E82 }, + { 0x0E84, 0x0E84 }, + { 0x0E87, 0x0E88 }, + { 0x0E8A, 0x0E8A }, + { 0x0E8D, 0x0E8D }, + { 0x0E94, 0x0E97 }, + { 0x0E99, 0x0E9F }, + { 0x0EA1, 0x0EA3 }, + { 0x0EA5, 0x0EA5 }, + { 0x0EA7, 0x0EA7 }, + { 0x0EAA, 0x0EAB }, + { 0x0EAD, 0x0EAE }, + { 0x0EB0, 0x0EB9 }, + { 0x0EBB, 0x0EBD }, + { 0x0EC0, 0x0EC4 }, + { 0x0EC6, 0x0EC6 }, + { 0x0EC8, 0x0ECD }, + { 0x0ED0, 0x0ED9 }, + { 0x0EDC, 0x0EDD }, + { 0x0F00, 0x0F00 }, + { 0x0F18, 0x0F19 }, + { 0x0F20, 0x0F33 }, + { 0x0F35, 0x0F35 }, + { 0x0F37, 0x0F37 }, + { 0x0F39, 0x0F39 }, + { 0x0F3E, 0x0F47 }, + { 0x0F49, 0x0F69 }, + { 0x0F71, 0x0F84 }, + { 0x0F86, 0x0F8B }, + { 0x0F90, 0x0F95 }, + { 0x0F97, 0x0F97 }, + { 0x0F99, 0x0FAD }, + { 0x0FB1, 0x0FB7 }, + { 0x0FB9, 0x0FB9 }, + { 0x10A0, 0x10C5 }, + { 0x10D0, 0x10F6 }, + { 0x1E00, 0x1E9B }, + { 0x1EA0, 0x1EF9 }, + { 0x1F00, 0x1F15 }, + { 0x1F18, 0x1F1D }, + { 0x1F20, 0x1F45 }, + { 0x1F48, 0x1F4D }, + { 0x1F50, 0x1F57 }, + { 0x1F59, 0x1F59 }, + { 0x1F5B, 0x1F5B }, + { 0x1F5D, 0x1F5D }, + { 0x1F5F, 0x1F7D }, + { 0x1F80, 0x1FB4 }, + { 0x1FB6, 0x1FBC }, + { 0x1FBE, 0x1FBE }, + { 0x1FC2, 0x1FC4 }, + { 0x1FC6, 0x1FCC }, + { 0x1FD0, 0x1FD3 }, + { 0x1FD6, 0x1FDB }, + { 0x1FE0, 0x1FEC }, + { 0x1FF2, 0x1FF4 }, + { 0x1FF6, 0x1FFC }, + { 0x203F, 0x2040 }, + { 0x207F, 0x207F }, + { 0x2102, 0x2102 }, + { 0x2107, 0x2107 }, + { 0x210A, 0x2113 }, + { 0x2115, 0x2115 }, + { 0x2118, 0x211D }, + { 0x2124, 0x2124 }, + { 0x2126, 0x2126 }, + { 0x2128, 0x2128 }, + { 0x212A, 0x2131 }, + { 0x2133, 0x2138 }, + { 0x2160, 0x2182 }, + { 0x3005, 0x3007 }, + { 0x3021, 0x3029 }, + { 0x3041, 0x3093 }, + { 0x309B, 0x309C }, + { 0x30A1, 0x30F6 }, + { 0x30FB, 0x30FC }, + { 0x3105, 0x312C }, + { 0x4E00, 0x9FA5 }, + { 0xAC00, 0xD7A3 }, + }; + +#ifdef DEBUG + for (int i = 0; i < sizeof(table) / sizeof(table[0]); i++) + { + //printf("%x\n", table[i][0]); + assert(table[i][0] <= table[i][1]); + if (i < sizeof(table) / sizeof(table[0]) - 1) + assert(table[i][1] < table[i + 1][0]); + } +#endif + + if (u > 0xD7A3) + goto Lisnot; + + // Binary search + int mid; + int low; + int high; + + low = 0; + high = sizeof(table) / sizeof(table[0]) - 1; + while (low <= high) + { + mid = (low + high) >> 1; + if (u < table[mid][0]) + high = mid - 1; + else if (u > table[mid][1]) + low = mid + 1; + else + goto Lis; + } + +Lisnot: +#ifdef DEBUG + for (int i = 0; i < sizeof(table) / sizeof(table[0]); i++) + { + assert(u < table[i][0] || u > table[i][1]); + } +#endif + return 0; + +Lis: +#ifdef DEBUG + for (int i = 0; i < sizeof(table) / sizeof(table[0]); i++) + { + if (u >= table[i][0] && u <= table[i][1]) + return 1; + } + assert(0); // should have been in table +#endif + return 1; +} + diff --git a/unittests.c b/unittests.c new file mode 100644 index 00000000..1b3c2770 --- /dev/null +++ b/unittests.c @@ -0,0 +1,17 @@ + +#include + +#include "mars.h" + +void unittest_speller(); +void unittest_importHint(); +void unittest_aa(); + +void unittests() +{ +#if UNITTEST + unittest_speller(); + unittest_importHint(); + unittest_aa(); +#endif +} diff --git a/utf.c b/utf.c new file mode 100644 index 00000000..78f8cd4a --- /dev/null +++ b/utf.c @@ -0,0 +1,320 @@ +// utf.c +// Copyright (c) 2003-2009 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +// Description of UTF-8 at: +// http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + +#include +#include +#include + +#include "utf.h" + +int utf_isValidDchar(dchar_t c) +{ + return c < 0xD800 || + (c > 0xDFFF && c <= 0x10FFFF && c != 0xFFFE && c != 0xFFFF); +} + +static const unsigned char UTF8stride[256] = +{ + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, + 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, + 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, + 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,5,5,5,5,6,6,0xFF,0xFF, +}; + +/** + * stride() returns the length of a UTF-8 sequence starting at index i + * in string s. + * Returns: + * The number of bytes in the UTF-8 sequence or + * 0xFF meaning s[i] is not the start of of UTF-8 sequence. + */ + +unsigned stride(unsigned char* s, size_t i) +{ + unsigned result = UTF8stride[s[i]]; + return result; +} + +/******************************************** + * Decode a single UTF-8 character sequence. + * Returns: + * NULL success + * !=NULL error message string + */ + +const char *utf_decodeChar(unsigned char *s, size_t len, size_t *pidx, dchar_t *presult) +{ + dchar_t V; + size_t i = *pidx; + unsigned char u = s[i]; + + //printf("utf_decodeChar(s = %02x, %02x, %02x len = %d)\n", u, s[1], s[2], len); + + assert(i >= 0 && i < len); + + if (u & 0x80) + { unsigned n; + unsigned char u2; + + /* The following encodings are valid, except for the 5 and 6 byte + * combinations: + * 0xxxxxxx + * 110xxxxx 10xxxxxx + * 1110xxxx 10xxxxxx 10xxxxxx + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + * 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + * 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + for (n = 1; ; n++) + { + if (n > 4) + goto Lerr; // only do the first 4 of 6 encodings + if (((u << n) & 0x80) == 0) + { + if (n == 1) + goto Lerr; + break; + } + } + + // Pick off (7 - n) significant bits of B from first byte of octet + V = (dchar_t)(u & ((1 << (7 - n)) - 1)); + + if (i + (n - 1) >= len) + goto Lerr; // off end of string + + /* The following combinations are overlong, and illegal: + * 1100000x (10xxxxxx) + * 11100000 100xxxxx (10xxxxxx) + * 11110000 1000xxxx (10xxxxxx 10xxxxxx) + * 11111000 10000xxx (10xxxxxx 10xxxxxx 10xxxxxx) + * 11111100 100000xx (10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx) + */ + u2 = s[i + 1]; + if ((u & 0xFE) == 0xC0 || + (u == 0xE0 && (u2 & 0xE0) == 0x80) || + (u == 0xF0 && (u2 & 0xF0) == 0x80) || + (u == 0xF8 && (u2 & 0xF8) == 0x80) || + (u == 0xFC && (u2 & 0xFC) == 0x80)) + goto Lerr; // overlong combination + + for (unsigned j = 1; j != n; j++) + { + u = s[i + j]; + if ((u & 0xC0) != 0x80) + goto Lerr; // trailing bytes are 10xxxxxx + V = (V << 6) | (u & 0x3F); + } + if (!utf_isValidDchar(V)) + goto Lerr; + i += n; + } + else + { + V = (dchar_t) u; + i++; + } + + assert(utf_isValidDchar(V)); + *pidx = i; + *presult = V; + return NULL; + + Lerr: + *presult = (dchar_t) s[i]; + *pidx = i + 1; + return "invalid UTF-8 sequence"; +} + +/*************************************************** + * Validate a UTF-8 string. + * Returns: + * NULL success + * !=NULL error message string + */ + +const char *utf_validateString(unsigned char *s, size_t len) +{ + size_t idx; + const char *err = NULL; + dchar_t dc; + + for (idx = 0; idx < len; ) + { + err = utf_decodeChar(s, len, &idx, &dc); + if (err) + break; + } + return err; +} + + +/******************************************** + * Decode a single UTF-16 character sequence. + * Returns: + * NULL success + * !=NULL error message string + */ + + +const char *utf_decodeWchar(unsigned short *s, size_t len, size_t *pidx, dchar_t *presult) +{ + const char *msg; + size_t i = *pidx; + unsigned u = s[i]; + + assert(i >= 0 && i < len); + if (u & ~0x7F) + { if (u >= 0xD800 && u <= 0xDBFF) + { unsigned u2; + + if (i + 1 == len) + { msg = "surrogate UTF-16 high value past end of string"; + goto Lerr; + } + u2 = s[i + 1]; + if (u2 < 0xDC00 || u2 > 0xDFFF) + { msg = "surrogate UTF-16 low value out of range"; + goto Lerr; + } + u = ((u - 0xD7C0) << 10) + (u2 - 0xDC00); + i += 2; + } + else if (u >= 0xDC00 && u <= 0xDFFF) + { msg = "unpaired surrogate UTF-16 value"; + goto Lerr; + } + else if (u == 0xFFFE || u == 0xFFFF) + { msg = "illegal UTF-16 value"; + goto Lerr; + } + else + i++; + } + else + { + i++; + } + + assert(utf_isValidDchar(u)); + *pidx = i; + *presult = (dchar_t)u; + return NULL; + + Lerr: + *presult = (dchar_t)s[i]; + *pidx = i + 1; + return msg; +} + +void utf_encodeChar(unsigned char *s, dchar_t c) +{ + if (c <= 0x7F) + { + s[0] = (char) c; + } + else if (c <= 0x7FF) + { + s[0] = (char)(0xC0 | (c >> 6)); + s[1] = (char)(0x80 | (c & 0x3F)); + } + else if (c <= 0xFFFF) + { + s[0] = (char)(0xE0 | (c >> 12)); + s[1] = (char)(0x80 | ((c >> 6) & 0x3F)); + s[2] = (char)(0x80 | (c & 0x3F)); + } + else if (c <= 0x10FFFF) + { + s[0] = (char)(0xF0 | (c >> 18)); + s[1] = (char)(0x80 | ((c >> 12) & 0x3F)); + s[2] = (char)(0x80 | ((c >> 6) & 0x3F)); + s[3] = (char)(0x80 | (c & 0x3F)); + } + else + assert(0); +} + +void utf_encodeWchar(unsigned short *s, dchar_t c) +{ + if (c <= 0xFFFF) + { + s[0] = (wchar_t) c; + } + else + { + s[0] = (wchar_t) ((((c - 0x10000) >> 10) & 0x3FF) + 0xD800); + s[1] = (wchar_t) (((c - 0x10000) & 0x3FF) + 0xDC00); + } +} + + +/** + * Returns the code length of c in the encoding. + * The code is returned in character count, not in bytes. + */ + +int utf_codeLengthChar(dchar_t c) +{ + return + c <= 0x7F ? 1 + : c <= 0x7FF ? 2 + : c <= 0xFFFF ? 3 + : c <= 0x10FFFF ? 4 + : (assert(false), 6); +} + +int utf_codeLengthWchar(dchar_t c) +{ + return c <= 0xFFFF ? 1 : 2; +} + +/** + * Returns the code length of c in the encoding. + * sz is the encoding: 1 = utf8, 2 = utf16, 4 = utf32. + * The code is returned in character count, not in bytes. + */ +int utf_codeLength(int sz, dchar_t c) +{ + if (sz == 1) + return utf_codeLengthChar(c); + if (sz == 2) + return utf_codeLengthWchar(c); + assert(sz == 4); + return 1; +} + +void utf_encode(int sz, void *s, dchar_t c) +{ + if (sz == 1) + utf_encodeChar((unsigned char *)s, c); + else if (sz == 2) + utf_encodeWchar((unsigned short *)s, c); + else + { + assert(sz == 4); + memcpy((unsigned char *)s, &c, sz); + } +} + diff --git a/utf.h b/utf.h new file mode 100644 index 00000000..22d8d3eb --- /dev/null +++ b/utf.h @@ -0,0 +1,35 @@ +// Compiler implementation of the D programming language +// utf.h +// Copyright (c) 2003-2010 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_UTF_H +#define DMD_UTF_H + + +typedef unsigned dchar_t; + +int utf_isValidDchar(dchar_t c); + +const char *utf_decodeChar(unsigned char *s, size_t len, size_t *pidx, dchar_t *presult); +const char *utf_decodeWchar(unsigned short *s, size_t len, size_t *pidx, dchar_t *presult); + +const char *utf_validateString(unsigned char *s, size_t len); + +extern int isUniAlpha(dchar_t); + +void utf_encodeChar(unsigned char *s, dchar_t c); +void utf_encodeWchar(unsigned short *s, dchar_t c); + +int utf_codeLengthChar(dchar_t c); +int utf_codeLengthWchar(dchar_t c); + +int utf_codeLength(int sz, dchar_t c); +void utf_encode(int sz, void *s, dchar_t c); + +#endif diff --git a/util.c b/util.c new file mode 100644 index 00000000..77ecf8e8 --- /dev/null +++ b/util.c @@ -0,0 +1,342 @@ +/* + * Some portions copyright (c) 1984-1993 by Symantec + * Copyright (c) 1999-2011 by Digital Mars + * All Rights Reserved + * http://www.digitalmars.com + * Written by Walter Bright + * + * This source file is made available for personal use + * only. The license is in /dmd/src/dmd/backendlicense.txt + * For any other uses, please contact Digital Mars. + */ + +// Utility subroutines + +#include +#include +#include +#include +#include + +#include "cc.h" +#include "global.h" +#include "mem.h" +#include "token.h" +#if SCPP || MARS +#include "el.h" +#endif + +#if _WIN32 && __DMC__ +//#include "scdll.h" +#include +#endif + +static char __file__[] = __FILE__; /* for tassert.h */ +#include "tassert.h" + +void *ph_malloc(size_t nbytes); +void *ph_calloc(size_t nbytes); +void ph_free(void *p); +void *ph_realloc(void *p , size_t nbytes); + + +void util_exit(int exitcode); + +void file_progress() +{ +} + +/******************************* + * Alternative assert failure. + */ + +void util_assert(char *file,int line) +{ + fflush(stdout); + printf("Internal error: %s %d\n",file,line); + err_exit(); +} + +/**************************** + * Clean up and exit program. + */ + +void err_exit() +{ + util_exit(EXIT_FAILURE); +} + +/******************************** + * Clean up and exit program. + */ + +void err_break() +{ + util_exit(255); +} + + +/**************************** + * Clean up and exit program. + */ + +void util_exit(int exitcode) +{ + exit(exitcode); /* terminate abnormally */ +} + + +#if _WIN32 + +volatile int controlc_saw; + +/******************************** + * Control C interrupts go here. + */ + +static void __cdecl controlc_handler(void) +{ + //printf("saw controlc\n"); + controlc_saw = 1; +} + +/********************************* + * Trap control C interrupts. + */ + +void _STI_controlc() +{ + //printf("_STI_controlc()\n"); + _controlc_handler = controlc_handler; + controlc_open(); /* trap control C */ +} + +void _STD_controlc() +{ + //printf("_STD_controlc()\n"); + controlc_close(); +} + + +/*********************************** + * Send progress report. + */ + +void util_progress() +{ + if (controlc_saw) + err_break(); +} + +void util_progress(int linnum) +{ + if (controlc_saw) + err_break(); +} + +#endif + +#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4 +void util_progress() +{ +} + +void util_progress(int linnum) +{ +} +#endif + +/********************************** + * Binary string search. + * Input: + * p -> string of characters + * tab array of pointers to strings + * n = number of pointers in the array + * Returns: + * index (0..n-1) into tab[] if we found a string match + * else -1 + */ + +#if TX86 && __INTSIZE == 4 && __DMC__ && !_DEBUG_TRACE + +int binary(const char *p, const char **table,int high) +{ +#define len high // reuse parameter storage + _asm + { + +;First find the length of the identifier. + xor EAX,EAX ;Scan for a 0. + mov EDI,p + mov ECX,EAX + dec ECX ;Longest possible string. + repne scasb + mov EDX,high ;EDX = high + not ECX ;length of the id including '/0', stays in ECX + dec EDX ;high-- + js short Lnotfound + dec EAX ;EAX = -1, so that eventually EBX = low (0) + mov len,ECX + + even +L4D: mov EBX,EAX ;EBX (low) = mid + inc EBX ;low = mid + 1 + cmp EBX,EDX + jg Lnotfound + + even +L15: lea EAX,[EBX + EDX] ;EAX = EBX + EDX + +;Do the string compare. + + mov EDI,table + sar EAX,1 ;mid = (low + high) >> 1; + mov ESI,p + mov EDI,DS:[4*EAX+EDI] ;Load table[mid] + mov ECX,len ;length of id + repe cmpsb + + je short L63 ;return mid if equal + jns short L4D ;if (cond < 0) + lea EDX,-1[EAX] ;high = mid - 1 + cmp EBX,EDX + jle L15 + +Lnotfound: + mov EAX,-1 ;Return -1. + + even +L63: + } +#undef len +} + +#else + +int binary(const char *p, const char __near * __near *table,int high) +{ int low,mid; + signed char cond; + char cp; + + low = 0; + high--; + cp = *p; + p++; + while (low <= high) + { mid = (low + high) >> 1; + if ((cond = table[mid][0] - cp) == 0) + cond = strcmp(table[mid] + 1,p); + if (cond > 0) + high = mid - 1; + else if (cond < 0) + low = mid + 1; + else + return mid; /* match index */ + } + return -1; +} + +#endif + +/********************** + * If c is a power of 2, return that power else -1. + */ + +int ispow2(unsigned long long c) +{ int i; + + if (c == 0 || (c & (c - 1))) + i = -1; + else + for (i = 0; c >>= 1; i++) + ; + return i; +} + +/*************************** + */ + +#define UTIL_PH 1 + +#if _WIN32 +void *util_malloc(unsigned n,unsigned size) +{ +#if 0 && MEM_DEBUG + void *p; + + p = mem_malloc(n * size); + //dbg_printf("util_calloc(%d) = %p\n",n * size,p); + return p; +#elif UTIL_PH + return ph_malloc(n * size); +#else + size_t nbytes = (size_t)n * (size_t)size; + void *p = malloc(nbytes); + if (!p && nbytes) + err_nomem(); + return p; +#endif +} +#endif + +/*************************** + */ + +#if _WIN32 +void *util_calloc(unsigned n,unsigned size) +{ +#if 0 && MEM_DEBUG + void *p; + + p = mem_calloc(n * size); + //dbg_printf("util_calloc(%d) = %p\n",n * size,p); + return p; +#elif UTIL_PH + return ph_calloc(n * size); +#else + size_t nbytes = (size_t) n * (size_t) size; + void *p = calloc(n,size); + if (!p && nbytes) + err_nomem(); + return p; +#endif +} +#endif + +/*************************** + */ + +#if _WIN32 +void util_free(void *p) +{ + //dbg_printf("util_free(%p)\n",p); +#if 0 && MEM_DEBUG + mem_free(p); +#elif UTIL_PH + ph_free(p); +#else + free(p); +#endif +} +#endif + +/*************************** + */ + +#if _WIN32 +void *util_realloc(void *oldp,unsigned n,unsigned size) +{ +#if 0 && MEM_DEBUG + //dbg_printf("util_realloc(%p,%d)\n",oldp,n * size); + return mem_realloc(oldp,n * size); +#elif UTIL_PH + return ph_realloc(oldp,n * size); +#else + size_t nbytes = (size_t) n * (size_t) size; + void *p = realloc(oldp,nbytes); + if (!p && nbytes) + err_nomem(); + return p; +#endif +} +#endif diff --git a/version.c b/version.c new file mode 100644 index 00000000..37f33c06 --- /dev/null +++ b/version.c @@ -0,0 +1,181 @@ + +// Copyright (c) 1999-2005 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" + +#include "identifier.h" +#include "dsymbol.h" +#include "cond.h" +#include "version.h" +#include "module.h" + +/* ================================================== */ + +/* DebugSymbol's happen for statements like: + * debug = identifier; + * debug = integer; + */ + +DebugSymbol::DebugSymbol(Loc loc, Identifier *ident) + : Dsymbol(ident) +{ + this->loc = loc; +} + +DebugSymbol::DebugSymbol(Loc loc, unsigned level) + : Dsymbol() +{ + this->level = level; + this->loc = loc; +} + +Dsymbol *DebugSymbol::syntaxCopy(Dsymbol *s) +{ + assert(!s); + DebugSymbol *ds = new DebugSymbol(loc, ident); + ds->level = level; + return ds; +} + +int DebugSymbol::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + //printf("DebugSymbol::addMember('%s') %s\n", sd->toChars(), toChars()); + Module *m; + + // Do not add the member to the symbol table, + // just make sure subsequent debug declarations work. + m = sd->isModule(); + if (ident) + { + if (!m) + error("declaration must be at module level"); + else + { + if (findCondition(m->debugidsNot, ident)) + error("defined after use"); + if (!m->debugids) + m->debugids = new Strings(); + m->debugids->push(ident->toChars()); + } + } + else + { + if (!m) + error("level declaration must be at module level"); + else + m->debuglevel = level; + } + return 0; +} + +void DebugSymbol::semantic(Scope *sc) +{ + //printf("DebugSymbol::semantic() %s\n", toChars()); +} + +void DebugSymbol::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("debug = "); + if (ident) + buf->writestring(ident->toChars()); + else + buf->printf("%u", level); + buf->writestring(";"); + buf->writenl(); +} + +const char *DebugSymbol::kind() +{ + return "debug"; +} + +/* ================================================== */ + +/* VersionSymbol's happen for statements like: + * version = identifier; + * version = integer; + */ + +VersionSymbol::VersionSymbol(Loc loc, Identifier *ident) + : Dsymbol(ident) +{ + this->loc = loc; +} + +VersionSymbol::VersionSymbol(Loc loc, unsigned level) + : Dsymbol() +{ + this->level = level; + this->loc = loc; +} + +Dsymbol *VersionSymbol::syntaxCopy(Dsymbol *s) +{ + assert(!s); + VersionSymbol *ds = new VersionSymbol(loc, ident); + ds->level = level; + return ds; +} + +int VersionSymbol::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + //printf("VersionSymbol::addMember('%s') %s\n", sd->toChars(), toChars()); + Module *m; + + // Do not add the member to the symbol table, + // just make sure subsequent debug declarations work. + m = sd->isModule(); + if (ident) + { + VersionCondition::checkPredefined(loc, ident->toChars()); + if (!m) + error("declaration must be at module level"); + else + { + if (findCondition(m->versionidsNot, ident)) + error("defined after use"); + if (!m->versionids) + m->versionids = new Strings(); + m->versionids->push(ident->toChars()); + } + } + else + { + if (!m) + error("level declaration must be at module level"); + else + m->versionlevel = level; + } + return 0; +} + +void VersionSymbol::semantic(Scope *sc) +{ +} + +void VersionSymbol::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring("version = "); + if (ident) + buf->writestring(ident->toChars()); + else + buf->printf("%u", level); + buf->writestring(";"); + buf->writenl(); +} + +const char *VersionSymbol::kind() +{ + return "version"; +} + + diff --git a/version.h b/version.h new file mode 100644 index 00000000..b5ae51d2 --- /dev/null +++ b/version.h @@ -0,0 +1,51 @@ + +// Compiler implementation of the D programming language +// Copyright (c) 1999-2006 by Digital Mars +// All Rights Reserved +// written by Walter Bright +// http://www.digitalmars.com +// License for redistribution is by either the Artistic License +// in artistic.txt, or the GNU General Public License in gnu.txt. +// See the included readme.txt for details. + +#ifndef DMD_VERSION_H +#define DMD_VERSION_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "dsymbol.h" + +struct OutBuffer; +struct HdrGenState; + +struct DebugSymbol : Dsymbol +{ + unsigned level; + + DebugSymbol(Loc loc, Identifier *ident); + DebugSymbol(Loc loc, unsigned level); + Dsymbol *syntaxCopy(Dsymbol *); + + int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); +}; + +struct VersionSymbol : Dsymbol +{ + unsigned level; + + VersionSymbol(Loc loc, Identifier *ident); + VersionSymbol(Loc loc, unsigned level); + Dsymbol *syntaxCopy(Dsymbol *); + + int addMember(Scope *sc, ScopeDsymbol *s, int memnum); + void semantic(Scope *sc); + void toCBuffer(OutBuffer *buf, HdrGenState *hgs); + const char *kind(); +}; + +#endif /* DMD_VERSION_H */ diff --git a/win32.mak b/win32.mak new file mode 100644 index 00000000..1b1ab046 --- /dev/null +++ b/win32.mak @@ -0,0 +1,583 @@ +#_ win32.mak +# Copyright (C) 1999-2011 by Digital Mars, http://www.digitalmars.com +# Written by Walter Bright +# All Rights Reserved +# Build dmd with Digital Mars C++ compiler +# http://www.digitalmars.com/ctg/sc.html +# This makefile is designed to be used with Digital Mars make.exe +# http://www.digitalmars.com/ctg/make.html +# which should be in \dm\bin or in \dmd\windows\bin + +D= +DMDSVN=\svnproj\dmd\trunk\src +#DMDSVN=\svnproj\dmd\branches\dmd-1.x\src +SCROOT=$D\dm +INCLUDE=$(SCROOT)\include +CC=dmc +LIBNT=$(SCROOT)\lib +SNN=$(SCROOT)\lib\snn +DIR=\dmd2 +CP=cp + +C=backend +TK=tk +ROOT=root + +MAKE=make -fwin32.mak C=$C TK=$(TK) ROOT=$(ROOT) + +TARGET=dmd +XFLG= +MODEL=n +OPT= +DEBUG=-gl -D -DUNITTEST +#PREC=-H -HItotal.h -HO +PREC= +LFLAGS= + +LINKN=$(SCROOT)\bin\link /de + +CFLAGS=-I$(ROOT);$(INCLUDE) $(XFLG) $(OPT) $(DEBUG) -cpp +MFLAGS=-I$C;$(TK) $(OPT) -DMARS -cpp $(DEBUG) -e -wx + +# Makerules: +.c.obj: + $(CC) -c $(CFLAGS) $(PREC) $* + +.asm.obj: + $(CC) -c $(CFLAGS) $* + +defaulttarget: debdmd + +################ RELEASES ######################### + +release: + $(MAKE) clean + $(MAKE) dmd + $(MAKE) clean + +################ NT COMMAND LINE RELEASE ######################### + +trace: + $(MAKE) OPT=-o "DEBUG=-gt -Nc" LFLAGS=-L/ma/co/delexe dmd.exe + +dmd: + $(MAKE) OPT=-o "DEBUG=" LFLAGS=-L/delexe dmd.exe +# $(MAKE) OPT=-o "DEBUG=" LFLAGS=-L/ma/co/delexe dmd.exe + +################ NT COMMAND LINE DEBUG ######################### + +debdmd: + $(MAKE) OPT= "DEBUG=-D -g -DUNITTEST" LFLAGS=-L/ma/co dmd.exe + +######################################### + +# D front end + +OBJ1= mars.obj enum.obj struct.obj dsymbol.obj import.obj id.obj \ + staticassert.obj identifier.obj mtype.obj expression.obj \ + optimize.obj template.obj lexer.obj declaration.obj cast.obj \ + init.obj func.obj utf.obj unialpha.obj parse.obj statement.obj \ + constfold.obj version.obj inifile.obj typinf.obj \ + module.obj scope.obj dump.obj cond.obj inline.obj opover.obj \ + entity.obj class.obj mangle.obj attrib.obj impcnvtab.obj \ + link.obj access.obj doc.obj macro.obj hdrgen.obj delegatize.obj \ + interpret.obj traits.obj aliasthis.obj intrange.obj \ + builtin.obj clone.obj libomf.obj arrayop.obj irstate.obj \ + glue.obj msc.obj ph.obj tk.obj s2ir.obj todt.obj e2ir.obj tocsym.obj \ + util.obj eh.obj toobj.obj toctype.obj tocvdebug.obj toir.obj \ + json.obj unittests.obj imphint.obj argtypes.obj apply.obj canthrow.obj \ + sideeffect.obj + +# from C/C++ compiler optimizer and back end + +OBJ8= go.obj gdag.obj gother.obj gflow.obj gloop.obj var.obj el.obj \ + newman.obj glocal.obj os.obj nteh.obj evalu8.obj cgcs.obj \ + rtlsym.obj html.obj cgelem.obj cgen.obj cgreg.obj out.obj \ + blockopt.obj cgobj.obj cg.obj cgcv.obj type.obj dt.obj \ + debug.obj code.obj cg87.obj cgxmm.obj cgsched.obj ee.obj csymbol.obj \ + cgcod.obj cod1.obj cod2.obj cod3.obj cod4.obj cod5.obj outbuf.obj \ + bcomplex.obj iasm.obj ptrntab.obj aa.obj ti_achar.obj md5.obj \ + ti_pvoid.obj + +# from ROOT + +GCOBJS=rmem.obj +#GCOBJS=dmgcmem.obj bits.obj win32.obj gc.obj + +ROOTOBJS= lstring.obj array.obj gnuc.obj man.obj root.obj port.obj \ + stringtable.obj dchar.obj response.obj async.obj speller.obj aav.obj \ + $(GCOBJS) + +OBJS= $(OBJ1) $(OBJ8) $(ROOTOBJS) + +SRCS= mars.c enum.c struct.c dsymbol.c import.c idgen.c impcnvgen.c utf.h \ + utf.c entity.c identifier.c mtype.c expression.c optimize.c \ + template.h template.c lexer.c declaration.c cast.c \ + cond.h cond.c link.c aggregate.h staticassert.h parse.c statement.c \ + constfold.c version.h version.c inifile.c iasm.c staticassert.c \ + module.c scope.c dump.c init.h init.c attrib.h attrib.c opover.c \ + eh.c toctype.c class.c mangle.c tocsym.c func.c inline.c \ + access.c complex_t.h unialpha.c irstate.h irstate.c glue.c msc.c \ + ph.c tk.c s2ir.c todt.c e2ir.c util.c toobj.c cppmangle.c \ + identifier.h parse.h scope.h enum.h import.h intrange.h \ + typinf.c tocvdebug.c toelfdebug.c mars.h module.h mtype.h dsymbol.h \ + declaration.h lexer.h expression.h statement.h doc.h doc.c \ + macro.h macro.c hdrgen.h hdrgen.c arraytypes.h \ + delegatize.c toir.h toir.c interpret.c traits.c builtin.c \ + clone.c lib.h libomf.c libelf.c libmach.c arrayop.c intrange.c \ + aliasthis.h aliasthis.c json.h json.c unittests.c imphint.c argtypes.c \ + apply.c canthrow.c sideeffect.c + +# From C++ compiler + +BACKSRC= $C\cdef.h $C\cc.h $C\oper.h $C\ty.h $C\optabgen.c \ + $C\global.h $C\code.h $C\type.h $C\dt.h $C\cgcv.h \ + $C\el.h $C\iasm.h $C\rtlsym.h $C\html.h \ + $C\bcomplex.c $C\blockopt.c $C\cg.c $C\cg87.c $C\cgxmm.c \ + $C\cgcod.c $C\cgcs.c $C\cgcv.c $C\cgelem.c $C\cgen.c $C\cgobj.c \ + $C\cgreg.c $C\var.c \ + $C\cgsched.c $C\cod1.c $C\cod2.c $C\cod3.c $C\cod4.c $C\cod5.c \ + $C\code.c $C\symbol.c $C\debug.c $C\dt.c $C\ee.c $C\el.c \ + $C\evalu8.c $C\go.c $C\gflow.c $C\gdag.c \ + $C\gother.c $C\glocal.c $C\gloop.c $C\html.c $C\newman.c \ + $C\nteh.c $C\os.c $C\out.c $C\outbuf.c $C\ptrntab.c $C\rtlsym.c \ + $C\type.c $C\melf.h $C\mach.h $C\bcomplex.h \ + $C\cdeflnx.h $C\outbuf.h $C\token.h $C\tassert.h \ + $C\elfobj.c $C\cv4.h $C\dwarf2.h $C\exh.h $C\go.h \ + $C\dwarf.c $C\dwarf.h $C\cppman.c $C\machobj.c \ + $C\strtold.c $C\aa.h $C\aa.c $C\tinfo.h $C\ti_achar.c \ + $C\md5.h $C\md5.c $C\ti_pvoid.c $C\xmm.h \ + $C\backend.txt + +# From TK + +TKSRC= $(TK)\filespec.h $(TK)\mem.h $(TK)\list.h $(TK)\vec.h \ + $(TK)\filespec.c $(TK)\mem.c $(TK)\vec.c $(TK)\list.c + +# From root + +ROOTSRC= $(ROOT)\dchar.h $(ROOT)\dchar.c $(ROOT)\lstring.h \ + $(ROOT)\lstring.c $(ROOT)\root.h $(ROOT)\root.c $(ROOT)\array.c \ + $(ROOT)\rmem.h $(ROOT)\rmem.c $(ROOT)\port.h \ + $(ROOT)\stringtable.h $(ROOT)\stringtable.c \ + $(ROOT)\gnuc.h $(ROOT)\gnuc.c $(ROOT)\man.c $(ROOT)\port.c \ + $(ROOT)\response.c $(ROOT)\async.h $(ROOT)\async.c \ + $(ROOT)\speller.h $(ROOT)\speller.c \ + $(ROOT)\aav.h $(ROOT)\aav.c \ + $(ROOT)\dmgcmem.c $(ROOT)\gc\bits.c $(ROOT)\gc\gc.c $(ROOT)\gc\gc.h $(ROOT)\gc\mscbitops.h \ + $(ROOT)\gc\bits.h $(ROOT)\gc\gccbitops.h $(ROOT)\gc\linux.c $(ROOT)\gc\os.h \ + $(ROOT)\gc\win32.c + +MAKEFILES=win32.mak posix.mak + +######################################### + +$(TARGET).exe : $(OBJS) win32.mak + dmc -o$(TARGET).exe $(OBJS) -cpp -mn -Ar $(LFLAGS) + + +##################### INCLUDE MACROS ##################### + +CCH= +#TOTALH=$(CCH) total.sym +TOTALH=$(CCH) id.h +CH= $C\cc.h $C\global.h $C\oper.h $C\code.h $C\type.h $C\dt.h $C\cgcv.h $C\el.h $C\iasm.h + +##################### GENERATED SOURCE ##################### + +msgs.h msgs.c sj1041.msg sj1036.msg sj1031.msg : msgsx.exe + msgsx + +msgsx.exe : msgsx.c + dmc msgsx -mn -D$(TARGET) $(DEFINES) $(WINLIBS) + +elxxx.c cdxxx.c optab.c debtab.c fltables.c tytab.c : \ + $C\cdef.h $C\cc.h $C\oper.h $C\ty.h $C\optabgen.c + dmc -cpp -ooptabgen.exe $C\optabgen -DMARS -I$(TK) $(WINLIBS) #-L$(LINKS) + optabgen + +impcnvtab.c : impcnvgen.c + $(CC) -I$(ROOT) -cpp impcnvgen + impcnvgen + +id.h id.c : idgen.c + dmc -cpp idgen + idgen + +##################### SPECIAL BUILDS ##################### + +total.sym : $(ROOT)\root.h mars.h lexer.h parse.h enum.h dsymbol.h \ + mtype.h expression.h attrib.h init.h cond.h version.h \ + declaration.h statement.h scope.h import.h module.h id.h \ + template.h aggregate.h arraytypes.h lib.h total.h + $(CC) -c $(CFLAGS) -HFtotal.sym total.h + +impcnvtab.obj : mtype.h impcnvtab.c + $(CC) -c -I$(ROOT) -cpp impcnvtab + +iasm.obj : $(CH) $(TOTALH) $C\iasm.h iasm.c + $(CC) -c $(MFLAGS) -I$(ROOT) iasm + +bcomplex.obj : $C\bcomplex.c + $(CC) -c $(MFLAGS) $C\bcomplex + +aa.obj : $C\tinfo.h $C\aa.h $C\aa.c + $(CC) -c $(MFLAGS) -I. $C\aa + +blockopt.obj : $C\blockopt.c + $(CC) -c $(MFLAGS) $C\blockopt + +cg.obj : $C\cg.c + $(CC) -c $(MFLAGS) -I. $C\cg + +cg87.obj : $C\cg87.c + $(CC) -c $(MFLAGS) $C\cg87 + +cgcod.obj : $C\cgcod.c + $(CC) -c $(MFLAGS) -I. $C\cgcod + +cgcs.obj : $C\cgcs.c + $(CC) -c $(MFLAGS) $C\cgcs + +cgcv.obj : $C\cgcv.c + $(CC) -c $(MFLAGS) $C\cgcv + +cgelem.obj : $C\rtlsym.h $C\cgelem.c + $(CC) -c $(MFLAGS) -I. $C\cgelem + +cgen.obj : $C\rtlsym.h $C\cgen.c + $(CC) -c $(MFLAGS) $C\cgen + +cgobj.obj : $C\md5.h $C\cgobj.c + $(CC) -c $(MFLAGS) $C\cgobj + +cgreg.obj : $C\cgreg.c + $(CC) -c $(MFLAGS) $C\cgreg + +cgsched.obj : $C\rtlsym.h $C\cgsched.c + $(CC) -c $(MFLAGS) $C\cgsched + +cgxmm.obj : $C\xmm.h $C\cgxmm.c + $(CC) -c $(MFLAGS) $C\cgxmm + +cod1.obj : $C\rtlsym.h $C\cod1.c + $(CC) -c $(MFLAGS) $C\cod1 + +cod2.obj : $C\rtlsym.h $C\cod2.c + $(CC) -c $(MFLAGS) $C\cod2 + +cod3.obj : $C\rtlsym.h $C\cod3.c + $(CC) -c $(MFLAGS) $C\cod3 + +cod4.obj : $C\cod4.c + $(CC) -c $(MFLAGS) $C\cod4 + +cod5.obj : $C\cod5.c + $(CC) -c $(MFLAGS) $C\cod5 + +code.obj : $C\code.c + $(CC) -c $(MFLAGS) $C\code + +irstate.obj : irstate.h irstate.c + $(CC) -c $(MFLAGS) -I$(ROOT) irstate + +csymbol.obj : $C\symbol.c + $(CC) -c $(MFLAGS) $C\symbol -ocsymbol.obj + +debug.obj : $C\debug.c + $(CC) -c $(MFLAGS) -I. $C\debug + +dt.obj : $C\dt.h $C\dt.c + $(CC) -c $(MFLAGS) $C\dt + +ee.obj : $C\ee.c + $(CC) -c $(MFLAGS) $C\ee + +eh.obj : $C\cc.h $C\code.h $C\type.h $C\dt.h eh.c + $(CC) -c $(MFLAGS) eh + +el.obj : $C\rtlsym.h $C\el.h $C\el.c + $(CC) -c $(MFLAGS) $C\el + +evalu8.obj : $C\evalu8.c + $(CC) -c $(MFLAGS) $C\evalu8 + +go.obj : $C\go.c + $(CC) -c $(MFLAGS) $C\go + +gflow.obj : $C\gflow.c + $(CC) -c $(MFLAGS) $C\gflow + +gdag.obj : $C\gdag.c + $(CC) -c $(MFLAGS) $C\gdag + +gother.obj : $C\gother.c + $(CC) -c $(MFLAGS) $C\gother + +glocal.obj : $C\rtlsym.h $C\glocal.c + $(CC) -c $(MFLAGS) $C\glocal + +gloop.obj : $C\gloop.c + $(CC) -c $(MFLAGS) $C\gloop + +glue.obj : $(CH) $(TOTALH) $C\rtlsym.h mars.h module.h glue.c + $(CC) -c $(MFLAGS) -I$(ROOT) glue + +html.obj : $(CH) $(TOTALH) $C\html.h $C\html.c + $(CC) -c -I$(ROOT) $(MFLAGS) $C\html + +imphint.obj : imphint.c + $(CC) -c $(CFLAGS) $* + +mars.obj : $(TOTALH) module.h mars.h mars.c + $(CC) -c $(CFLAGS) $(PREC) $* -Ae + +md5.obj : $C\md5.h $C\md5.c + $(CC) -c $(MFLAGS) $C\md5 + +module.obj : $(TOTALH) $C\html.h module.c + $(CC) -c $(CFLAGS) -I$C $(PREC) module.c + +msc.obj : $(CH) mars.h msc.c + $(CC) -c $(MFLAGS) msc + +newman.obj : $(CH) $C\newman.c + $(CC) -c $(MFLAGS) $C\newman + +nteh.obj : $C\rtlsym.h $C\nteh.c + $(CC) -c $(MFLAGS) $C\nteh + +os.obj : $C\os.c + $(CC) -c $(MFLAGS) $C\os + +out.obj : $C\out.c + $(CC) -c $(MFLAGS) $C\out + +outbuf.obj : $C\outbuf.h $C\outbuf.c + $(CC) -c $(MFLAGS) $C\outbuf + +ph.obj : ph.c + $(CC) -c $(MFLAGS) ph + +ptrntab.obj : $C\iasm.h $C\ptrntab.c + $(CC) -c $(MFLAGS) $C\ptrntab + +rtlsym.obj : $C\rtlsym.h $C\rtlsym.c + $(CC) -c $(MFLAGS) $C\rtlsym + +ti_achar.obj : $C\tinfo.h $C\ti_achar.c + $(CC) -c $(MFLAGS) -I. $C\ti_achar + +ti_pvoid.obj : $C\tinfo.h $C\ti_pvoid.c + $(CC) -c $(MFLAGS) -I. $C\ti_pvoid + +toctype.obj : $(CH) $(TOTALH) $C\rtlsym.h mars.h module.h toctype.c + $(CC) -c $(MFLAGS) -I$(ROOT) toctype + +tocvdebug.obj : $(CH) $(TOTALH) $C\rtlsym.h mars.h module.h tocvdebug.c + $(CC) -c $(MFLAGS) -I$(ROOT) tocvdebug + +toobj.obj : $(CH) $(TOTALH) mars.h module.h toobj.c + $(CC) -c $(MFLAGS) -I$(ROOT) toobj + +type.obj : $C\type.c + $(CC) -c $(MFLAGS) $C\type + +typinf.obj : $(CH) $(TOTALH) $C\rtlsym.h mars.h module.h typinf.c + $(CC) -c $(MFLAGS) -I$(ROOT) typinf + +todt.obj : mtype.h expression.h $C\dt.h todt.c + $(CC) -c -I$(ROOT) $(MFLAGS) todt + +s2ir.obj : $C\rtlsym.h statement.h s2ir.c + $(CC) -c -I$(ROOT) $(MFLAGS) s2ir + +e2ir.obj : $C\rtlsym.h expression.h toir.h e2ir.c + $(CC) -c -I$(ROOT) $(MFLAGS) e2ir + +toir.obj : $C\rtlsym.h expression.h toir.h toir.c + $(CC) -c -I$(ROOT) $(MFLAGS) toir + +tocsym.obj : $(CH) $(TOTALH) mars.h module.h tocsym.c + $(CC) -c $(MFLAGS) -I$(ROOT) tocsym + +unittests.obj : $(TOTALH) unittests.c + $(CC) -c $(CFLAGS) $(PREC) $* + +util.obj : util.c + $(CC) -c $(MFLAGS) util + +var.obj : $C\var.c optab.c + $(CC) -c $(MFLAGS) -I. $C\var + + +tk.obj : tk.c + $(CC) -c $(MFLAGS) tk.c + +# ROOT + +aav.obj : $(ROOT)\aav.h $(ROOT)\aav.c + $(CC) -c $(CFLAGS) $(ROOT)\aav.c + +array.obj : $(ROOT)\array.c + $(CC) -c $(CFLAGS) $(ROOT)\array.c + +async.obj : $(ROOT)\async.h $(ROOT)\async.c + $(CC) -c $(CFLAGS) $(ROOT)\async.c + +dchar.obj : $(ROOT)\dchar.c + $(CC) -c $(CFLAGS) $(ROOT)\dchar.c + +dmgcmem.obj : $(ROOT)\dmgcmem.c + $(CC) -c $(CFLAGS) $(ROOT)\dmgcmem.c + +gnuc.obj : $(ROOT)\gnuc.c + $(CC) -c $(CFLAGS) $(ROOT)\gnuc.c + +lstring.obj : $(ROOT)\lstring.c + $(CC) -c $(CFLAGS) $(ROOT)\lstring.c + +man.obj : $(ROOT)\man.c + $(CC) -c $(CFLAGS) $(ROOT)\man.c + +rmem.obj : $(ROOT)\rmem.c + $(CC) -c $(CFLAGS) $(ROOT)\rmem.c + +port.obj : $(ROOT)\port.c + $(CC) -c $(CFLAGS) $(ROOT)\port.c + +root.obj : $(ROOT)\root.c + $(CC) -c $(CFLAGS) $(ROOT)\root.c + +response.obj : $(ROOT)\response.c + $(CC) -c $(CFLAGS) $(ROOT)\response.c + +speller.obj : $(ROOT)\speller.h $(ROOT)\speller.c + $(CC) -c $(CFLAGS) $(ROOT)\speller.c + +stringtable.obj : $(ROOT)\stringtable.c + $(CC) -c $(CFLAGS) $(ROOT)\stringtable.c + +# ROOT/GC + +bits.obj : $(ROOT)\gc\bits.h $(ROOT)\gc\bits.c + $(CC) -c $(CFLAGS) -I$(ROOT)\gc $(ROOT)\gc\bits.c + +gc.obj : $(ROOT)\gc\bits.h $(ROOT)\gc\os.h $(ROOT)\gc\gc.h $(ROOT)\gc\gc.c + $(CC) -c $(CFLAGS) -I$(ROOT)\gc $(ROOT)\gc\gc.c + +win32.obj : $(ROOT)\gc\os.h $(ROOT)\gc\win32.c + $(CC) -c $(CFLAGS) -I$(ROOT)\gc $(ROOT)\gc\win32.c + + +################# Source file dependencies ############### + +access.obj : $(TOTALH) enum.h aggregate.h init.h attrib.h access.c +aliasthis.obj : $(TOTALH) aliasthis.h aliasthis.c +apply.obj : $(TOTALH) apply.c +argtypes.obj : $(TOTALH) mtype.h argtypes.c +arrayop.obj : $(TOTALH) identifier.h declaration.h arrayop.c +attrib.obj : $(TOTALH) dsymbol.h identifier.h declaration.h attrib.h attrib.c +builtin.obj : $(TOTALH) builtin.c +canthrow.obj : $(TOTALH) canthrow.c +cast.obj : $(TOTALH) expression.h mtype.h cast.c +class.obj : $(TOTALH) enum.h class.c +clone.obj : $(TOTALH) clone.c +constfold.obj : $(TOTALH) expression.h constfold.c +cond.obj : $(TOTALH) identifier.h declaration.h cond.h cond.c +declaration.obj : $(TOTALH) identifier.h attrib.h declaration.h declaration.c expression.h +delegatize.obj : $(TOTALH) delegatize.c +doc.obj : $(TOTALH) doc.h doc.c +enum.obj : $(TOTALH) dsymbol.h identifier.h enum.h enum.c +expression.obj : $(TOTALH) expression.h expression.c +func.obj : $(TOTALH) identifier.h attrib.h declaration.h func.c +hdrgen.obj : $(TOTALH) hdrgen.h hdrgen.c +id.obj : $(TOTALH) id.h id.c +identifier.obj : $(TOTALH) identifier.h identifier.c +import.obj : $(TOTALH) dsymbol.h import.h import.c +inifile.obj : $(TOTALH) inifile.c +init.obj : $(TOTALH) init.h init.c +inline.obj : $(TOTALH) inline.c +interpret.obj : $(TOTALH) interpret.c declaration.h expression.h +intrange.obj : $(TOTALH) intrange.h intrange.c +json.obj : $(TOTALH) json.h json.c +lexer.obj : $(TOTALH) lexer.c +libomf.obj : $(TOTALH) lib.h libomf.c +link.obj : $(TOTALH) link.c +macro.obj : $(TOTALH) macro.h macro.c +mangle.obj : $(TOTALH) dsymbol.h declaration.h mangle.c +#module.obj : $(TOTALH) mars.h $C\html.h module.h module.c +opover.obj : $(TOTALH) expression.h opover.c +optimize.obj : $(TOTALH) expression.h optimize.c +parse.obj : $(TOTALH) attrib.h lexer.h parse.h parse.c +scope.obj : $(TOTALH) scope.h scope.c +sideeffect.obj : $(TOTALH) sideeffect.c +statement.obj : $(TOTALH) statement.h statement.c expression.h +staticassert.obj : $(TOTALH) staticassert.h staticassert.c +struct.obj : $(TOTALH) identifier.h enum.h struct.c +traits.obj : $(TOTALH) traits.c +dsymbol.obj : $(TOTALH) identifier.h dsymbol.h dsymbol.c +mtype.obj : $(TOTALH) mtype.h mtype.c +#typinf.obj : $(TOTALH) mtype.h typinf.c +utf.obj : utf.h utf.c +template.obj : $(TOTALH) template.h template.c +version.obj : $(TOTALH) identifier.h dsymbol.h cond.h version.h version.c + +################### Utilities ################ + +clean: + del *.obj + del total.sym + del msgs.h msgs.c + del elxxx.c cdxxx.c optab.c debtab.c fltables.c tytab.c + del impcnvtab.c + +zip : detab tolf $(MAKEFILES) + del dmdsrc.zip + zip32 dmdsrc $(MAKEFILES) + zip32 dmdsrc $(SRCS) + zip32 dmdsrc $(BACKSRC) + zip32 dmdsrc $(TKSRC) + zip32 dmdsrc $(ROOTSRC) + +################### Detab ################ + +detab: + detab $(SRCS) $(ROOTSRC) $(TKSRC) $(BACKSRC) + +tolf: + tolf $(SRCS) $(ROOTSRC) $(TKSRC) $(BACKSRC) $(MAKEFILES) + +################### Install ################ + +install: detab install2 + +install2: + copy dmd.exe $(DIR)\windows\bin\ + copy phobos\phobos.lib $(DIR)\windows\lib + $(CP) $(SRCS) $(DIR)\src\dmd\ + $(CP) $(ROOTSRC) $(DIR)\src\dmd\root\ + $(CP) $(TKSRC) $(DIR)\src\dmd\tk\ + $(CP) $(BACKSRC) $(DIR)\src\dmd\backend\ + $(CP) $(MAKEFILES) $(DIR)\src\dmd\ + copy gpl.txt $(DIR)\src\dmd\ + copy readme.txt $(DIR)\src\dmd\ + copy artistic.txt $(DIR)\src\dmd\ + copy backendlicense.txt $(DIR)\src\dmd\ + +################### Write to SVN ################ + +svn: detab tolf svn2 + +svn2: + $(CP) $(SRCS) $(DMDSVN)\ + $(CP) $(ROOTSRC) $(DMDSVN)\root\ + $(CP) $(TKSRC) $(DMDSVN)\tk\ + $(CP) $(BACKSRC) $(DMDSVN)\backend\ + $(CP) $(MAKEFILES) $(DMDSVN)\ + copy gpl.txt $(DMDSVN)\ + copy readme.txt $(DMDSVN)\ + copy artistic.txt $(DMDSVN)\ + copy backendlicense.txt $(DMDSVN)\ + +###################################